From 6bc880dc48e86dd2f99c14ea30973e3904dd04cb Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Thu, 29 Jan 2026 11:06:19 -0500
Subject: [PATCH 01/18] #11912 WIP

---
 .../iq/dataverse/api/dto/NewTemplateDTO.java  | 42 ++++++++++++++++++-
 .../iq/dataverse/api/DataversesIT.java        |  4 --
 2 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java b/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java
index 31adc30f2b9..8cf45bd8fa3 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java
@@ -15,6 +15,7 @@ public class NewTemplateDTO {
     private List<DatasetField> datasetFields;
     private Map<String, String> instructionsMap;
     private boolean isDefault;
+    private Map<String, String> termsOfUseAndAccess;
 
     public static NewTemplateDTO fromRequestBody(String requestBody, JsonParser jsonParser) throws JsonParseException {
         NewTemplateDTO newTemplateDTO = new NewTemplateDTO();
@@ -25,7 +26,8 @@ public static NewTemplateDTO fromRequestBody(String requestBody, JsonParser json
         newTemplateDTO.datasetFields = jsonParser.parseMultipleFields(jsonObject);
         newTemplateDTO.instructionsMap = parseRequestBodyInstructionsMap(jsonObject);
         newTemplateDTO.isDefault = jsonObject.getBoolean("isDefault", false);
-
+        newTemplateDTO.termsOfUseAndAccess = parseRequestBodyTerms(jsonObject);
+               
         return newTemplateDTO;
     }
 
@@ -58,6 +60,44 @@ public Map<String, String> getInstructionsMap() {
     public boolean isDefault() {
         return isDefault;
     }
+    
+    private static Map<String, String> parseRequestBodyTerms(JsonObject jsonObject){
+        Map<String, String> termsMap = new HashMap<>();
+        JsonArray termsJsonArray = jsonObject.getJsonArray("termsOfUseAndAccess");
+        if (termsJsonArray == null) {
+            return null;
+        }
+        /*
+                License license = termsOfUseAndAccess.getLicense();
+        return jsonObjectBuilder()
+                .add("id", termsOfUseAndAccess.getId())
+                .add("license", license != null ? json(license) : null)
+                .add("termsOfUse", termsOfUseAndAccess.getTermsOfUse())
+                .add("termsOfAccess", termsOfUseAndAccess.getTermsOfAccess())
+                .add("confidentialityDeclaration", termsOfUseAndAccess.getConfidentialityDeclaration())
+                .add("specialPermissions", termsOfUseAndAccess.getSpecialPermissions())
+                .add("restrictions", termsOfUseAndAccess.getRestrictions())
+                .add("citationRequirements", termsOfUseAndAccess.getCitationRequirements())
+                .add("depositorRequirements", termsOfUseAndAccess.getDepositorRequirements())
+                .add("conditions", termsOfUseAndAccess.getConditions())
+                .add("disclaimer", termsOfUseAndAccess.getDisclaimer())
+                .add("dataAccessPlace", termsOfUseAndAccess.getDataAccessPlace())
+                .add("originalArchive", termsOfUseAndAccess.getOriginalArchive())
+                .add("availabilityStatus", termsOfUseAndAccess.getAvailabilityStatus())
+                .add("sizeOfCollection", termsOfUseAndAccess.getSizeOfCollection())
+                .add("studyCompletion", termsOfUseAndAccess.getStudyCompletion())
+                .add("contactForAccess", termsOfUseAndAccess.getContactForAccess())
+                .add("fileAccessRequest", termsOfUseAndAccess.isFileAccessRequest());
+        */
+        
+        for (JsonObject instructionJsonObject : termsJsonArray.getValuesAs(JsonObject.class)) {
+            termsMap.put(
+                    instructionJsonObject.getString("instructionField"),
+                    instructionJsonObject.getString("instructionText")
+            );
+        }
+        return termsMap;
+    }
 
     private static Map<String, String> parseRequestBodyInstructionsMap(JsonObject jsonObject) {
         Map<String, String> instructionsMap = new HashMap<>();
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index dc658c7134b..a1d8a3ea565 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -2729,10 +2729,6 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
                 .body("data[0].instructions[0].instructionField", equalTo("author"))
                 .body("data[0].instructions[0].instructionText", equalTo("The author data"))
                 .body("data[0].dataverseAlias", equalTo(dataverseAlias));
-        
-                
-            // Remove default template
-            System.out.print("***************: " + dataverseAlias );
             
             Response removeDefaultResp = UtilIT.removeDefaultTemplate(dataverseAlias, apiToken);
             removeDefaultResp.prettyPrint();

From 9cd09053cd21a129056c1f81d5ae06fd4cb01397 Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Mon, 2 Feb 2026 09:41:31 -0500
Subject: [PATCH 02/18] #11912 add commands, etc.

---
 .../iq/dataverse/api/AbstractApiBean.java     |  15 +-
 .../harvard/iq/dataverse/api/Dataverses.java  |  28 ++-
 .../{NewTemplateDTO.java => TemplateDTO.java} |  22 ++-
 .../impl/UpdateTemplateFieldsCommand.java     | 161 ++++++++++++++++++
 .../impl/UpdateTemplateLicenseCommand.java    |  89 ++++++++++
 .../iq/dataverse/api/DataversesIT.java        | 126 +++++++++++++-
 .../edu/harvard/iq/dataverse/api/UtilIT.java  |   8 +
 7 files changed, 430 insertions(+), 19 deletions(-)
 rename src/main/java/edu/harvard/iq/dataverse/api/dto/{NewTemplateDTO.java => TemplateDTO.java} (86%)
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommand.java

diff --git a/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java b/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
index 2ee5730153e..ffa9ae27f31 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/AbstractApiBean.java
@@ -242,6 +242,9 @@ String getWrappedMessageWhenJson() {
     
     @EJB 
     GuestbookResponseServiceBean gbRespSvc;
+    
+    @EJB 
+    TemplateServiceBean templateSvc;
 
     @Inject
     FailedPIDResolutionLoggingServiceBean fprLogService;
@@ -370,8 +373,18 @@ protected Dataverse findDataverseOrDie( String dvIdtf ) throws WrappedResponse {
         }
         return dv;
     }
+    
+    protected Template findTemplateOrDie(Long templateId) throws WrappedResponse {
+        
+        Template template = templateSvc.find(templateId);
+        if (template == null) {
+            throw new WrappedResponse(
+                    error(Response.Status.NOT_FOUND, "Can't find template with identifier='" + templateId + "'"));
+        }
+        return template;
+    }
 
-    protected Template findTemplateOrDie(Long templateId, Dataverse dataverse) throws WrappedResponse {
+    protected Template findAllTemplatesOrDie(Long templateId, Dataverse dataverse) throws WrappedResponse {
         
         List<Template> templates = new ArrayList<>();
         
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
index caf778be675..3ba2bb27772 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -2016,9 +2016,9 @@ public Response getTemplate(@Context ContainerRequestContext crc, @PathParam("id
     public Response createTemplate(@Context ContainerRequestContext crc, String body, @PathParam("identifier") String dvIdtf) {
         try {
             Dataverse dataverse = findDataverseOrDie(dvIdtf);
-            NewTemplateDTO newTemplateDTO;
+            TemplateDTO newTemplateDTO;
             try {
-                newTemplateDTO = NewTemplateDTO.fromRequestBody(body, jsonParser());
+                newTemplateDTO = TemplateDTO.fromRequestBody(body, jsonParser());
             } catch (JsonParseException ex) {
                 return error(Status.BAD_REQUEST, MessageFormat.format(BundleUtil.getStringFromBundle("dataverse.createTemplate.error.jsonParseMetadataFields"), ex.getMessage()));
             }
@@ -2030,6 +2030,28 @@ public Response createTemplate(@Context ContainerRequestContext crc, String body
             return e.getResponse();
         }
     }
+    
+    @PUT
+    @AuthRequired
+    @Path("{templateId}/template")
+    public Response updateTemplate(@Context ContainerRequestContext crc, String body, @PathParam("templateId") Long templateId) {
+        try {
+            Template template = findTemplateOrDie(templateId);
+          //  Dataverse dataverse = findDataverseOrDie(dvIdtf);
+            TemplateDTO templateDTO;
+            try {
+                templateDTO = TemplateDTO.fromRequestBody(body, jsonParser());
+            } catch (JsonParseException ex) {
+                return error(Status.BAD_REQUEST, MessageFormat.format(BundleUtil.getStringFromBundle("dataverse.createTemplate.error.jsonParseMetadataFields"), ex.getMessage()));
+            }
+            Template created = execCommand(new CreateTemplateCommand(templateDTO.toTemplate(), createDataverseRequest(getRequestUser(crc)), dataverse, true));
+            
+            return created("/dataverses/template/" + created.getId(), jsonTemplate(created));
+        
+        } catch (WrappedResponse e) {
+            return e.getResponse();
+        }
+    }
 
     @POST
     @AuthRequired
@@ -2041,7 +2063,7 @@ public Response setDefaultTemplate(@Context ContainerRequestContext crc,
         try {
 
             Dataverse dataverse = findDataverseOrDie(dvId);
-            Template template = findTemplateOrDie(templateId, dataverse);
+            Template template = findAllTemplatesOrDie(templateId, dataverse);
             DataverseRequest dvReq = createDataverseRequest(getRequestUser(crc));
             SetDefaultTemplateCommand command = new SetDefaultTemplateCommand(template, dvReq, dataverse);
             
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java b/src/main/java/edu/harvard/iq/dataverse/api/dto/TemplateDTO.java
similarity index 86%
rename from src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java
rename to src/main/java/edu/harvard/iq/dataverse/api/dto/TemplateDTO.java
index 8cf45bd8fa3..8826048370d 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/dto/TemplateDTO.java
@@ -9,7 +9,7 @@
 import java.sql.Timestamp;
 import java.util.*;
 
-public class NewTemplateDTO {
+public class TemplateDTO {
 
     private String name;
     private List<DatasetField> datasetFields;
@@ -17,18 +17,18 @@ public class NewTemplateDTO {
     private boolean isDefault;
     private Map<String, String> termsOfUseAndAccess;
 
-    public static NewTemplateDTO fromRequestBody(String requestBody, JsonParser jsonParser) throws JsonParseException {
-        NewTemplateDTO newTemplateDTO = new NewTemplateDTO();
+    public static TemplateDTO fromRequestBody(String requestBody, JsonParser jsonParser) throws JsonParseException {
+        TemplateDTO templateDTO = new TemplateDTO();
 
         JsonObject jsonObject = JsonUtil.getJsonObject(requestBody);
 
-        newTemplateDTO.name = jsonObject.getString("name");
-        newTemplateDTO.datasetFields = jsonParser.parseMultipleFields(jsonObject);
-        newTemplateDTO.instructionsMap = parseRequestBodyInstructionsMap(jsonObject);
-        newTemplateDTO.isDefault = jsonObject.getBoolean("isDefault", false);
-        newTemplateDTO.termsOfUseAndAccess = parseRequestBodyTerms(jsonObject);
+        templateDTO.name = jsonObject.getString("name");
+        templateDTO.datasetFields = jsonParser.parseMultipleFields(jsonObject);
+        templateDTO.instructionsMap = parseRequestBodyInstructionsMap(jsonObject);
+        templateDTO.isDefault = jsonObject.getBoolean("isDefault", false);
+        templateDTO.termsOfUseAndAccess = parseRequestBodyTerms(jsonObject);
                
-        return newTemplateDTO;
+        return templateDTO;
     }
 
     public Template toTemplate() {
@@ -68,6 +68,10 @@ private static Map<String, String> parseRequestBodyTerms(JsonObject jsonObject){
             return null;
         }
         /*
+        
+        {
+  "name": "CC BY 4.0"
+}
                 License license = termsOfUseAndAccess.getLicense();
         return jsonObjectBuilder()
                 .add("id", termsOfUseAndAccess.getId())
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java
new file mode 100644
index 00000000000..28c38728158
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java
@@ -0,0 +1,161 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.ControlledVocabularyValue;
+import edu.harvard.iq.dataverse.DatasetField;
+import edu.harvard.iq.dataverse.DatasetFieldCompoundValue;
+import edu.harvard.iq.dataverse.DatasetFieldValue;
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.Template;
+import edu.harvard.iq.dataverse.engine.command.AbstractCommand;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ * @author stephenkraffmiller
+ */
+public class UpdateTemplateFieldsCommand extends AbstractCommand<Template> {
+
+    private final Template template;   
+    private final List<DatasetField> updatedFields;
+    private final boolean replaceData;
+
+    public UpdateTemplateFieldsCommand(Template template, Dataverse dataverse,  List<DatasetField> updatedFields, boolean replaceData, DataverseRequest request) {
+        super(request, dataverse);
+        this.template = template;
+        this.updatedFields = updatedFields;
+        this.replaceData = replaceData;
+    }
+
+    @Override
+    public Template execute(CommandContext ctxt) throws CommandException {
+        /*
+        Since this is a template we do not need to validate the incoming fields - that will occur if
+        the template is used to create a new dataset.
+        */
+                
+        Template savedTemplate;
+        updateTemplateFields(template);
+        savedTemplate = ctxt.templates().save(template);
+
+        return savedTemplate;
+    }
+
+    /**
+     * Updates the template fields by iterating through the updated fields and
+     * comparing them to the existing fields in the template
+     * <p>
+     * - If a matching field exists, its values are added or replaced based on conditions:
+     * - If the field is empty, allows multiple values, or replaceData is enabled, the values are updated.
+     * - If replaceData is enabled, the field is reset before updating.
+     * - If the field is a controlled vocabulary type, it is updated accordingly.
+     * - Otherwise, a regular template field update is performed.
+     * </p>
+     * <p>
+     * - If no matching field exists, the updated field is added to the template.
+     * </p>
+     *
+     * @param template The template to update with the new fields.
+     */
+    private void updateTemplateFields(Template template) {
+        for (DatasetField updatedField : updatedFields) {
+            boolean found = false;
+
+            for (DatasetField datasetVersionField : template.getDatasetFields()) {
+                if (!datasetVersionField.getDatasetFieldType().equals(updatedField.getDatasetFieldType())) {
+                    continue;
+                }
+
+                found = true;
+
+                if (datasetVersionField.isEmpty() || datasetVersionField.getDatasetFieldType().isAllowMultiples() || replaceData) {
+
+                    if (replaceData) {
+                        resetDatasetField(datasetVersionField);
+                    }
+
+                    if (updatedField.getDatasetFieldType().isControlledVocabulary()) {
+                        updateControlledVocabularyDatasetField(
+                                updatedField, datasetVersionField, datasetVersionField.getDisplayValue(),
+                                new ArrayList<>(datasetVersionField.getControlledVocabularyValues())
+                        );
+                    } else {
+                        updateRegularDatasetField(updatedField, datasetVersionField, template);
+                    }
+                    break;
+                }
+            }
+
+            if (!found) {
+                updatedField.setTemplate(template);
+                template.getDatasetFields().add(updatedField);
+            }
+        }
+    }
+
+    private void resetDatasetField(DatasetField datasetVersionField) {
+        if (datasetVersionField.getDatasetFieldType().isAllowMultiples()) {
+            datasetVersionField.setDatasetFieldValues(new ArrayList<>());
+            datasetVersionField.setControlledVocabularyValues(new ArrayList<>());
+            datasetVersionField.setDatasetFieldCompoundValues(new ArrayList<>());
+        } else {
+            datasetVersionField.setSingleValue("");
+            datasetVersionField.setSingleControlledVocabularyValue(null);
+        }
+    }
+
+    private static void updateRegularDatasetField(DatasetField updatedField, DatasetField datasetVersionField, Template template) {
+        if (!updatedField.getDatasetFieldType().isCompound()) {
+            updateSingleDatasetField(updatedField, datasetVersionField);
+        } else {
+            updateCompoundDatasetField(updatedField, datasetVersionField, template);
+        }
+    }
+
+    private static void updateSingleDatasetField(DatasetField updatedField, DatasetField datasetVersionField) {
+        if (datasetVersionField.getDatasetFieldType().isAllowMultiples()) {
+            for (DatasetFieldValue datasetFieldValue : updatedField.getDatasetFieldValues()) {
+                if (!datasetVersionField.getDisplayValue().contains(datasetFieldValue.getDisplayValue())) {
+                    datasetFieldValue.setDatasetField(datasetVersionField);
+                    datasetVersionField.getDatasetFieldValues().add(datasetFieldValue);
+                }
+            }
+        } else {
+            datasetVersionField.setSingleValue(updatedField.getValue());
+        }
+    }
+
+    private static void updateCompoundDatasetField(DatasetField updatedField, DatasetField datasetVersionField, Template template) {
+        for (DatasetFieldCompoundValue datasetFieldCompoundValue : updatedField.getDatasetFieldCompoundValues()) {
+            if (!datasetVersionField.getCompoundDisplayValue().contains(updatedField.getCompoundDisplayValue())) {
+                datasetFieldCompoundValue.setParentDatasetField(datasetVersionField);
+                datasetVersionField.setTemplate(template);
+                datasetVersionField.getDatasetFieldCompoundValues().add(datasetFieldCompoundValue);
+            }
+        }
+    }
+
+    private static void updateControlledVocabularyDatasetField(DatasetField updatedField,
+                                                               DatasetField datasetVersionField,
+                                                               String controlledVocabularyDisplayValue,
+                                                               List<ControlledVocabularyValue> priorControlledVocabularyValues) {
+        if (datasetVersionField.getDatasetFieldType().isAllowMultiples()) {
+            for (ControlledVocabularyValue controlledVocabularyValue : updatedField.getControlledVocabularyValues()) {
+                if (!controlledVocabularyDisplayValue.contains(controlledVocabularyValue.getStrValue())) {
+                    priorControlledVocabularyValues.add(controlledVocabularyValue);
+                }
+            }
+            datasetVersionField.setControlledVocabularyValues(priorControlledVocabularyValues);
+        } else {
+            datasetVersionField.setSingleControlledVocabularyValue(updatedField.getSingleControlledVocabularyValue());
+        }
+    }
+    
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommand.java
new file mode 100644
index 00000000000..82de6adde13
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommand.java
@@ -0,0 +1,89 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.Template;
+import edu.harvard.iq.dataverse.TermsOfUseAndAccess;
+import edu.harvard.iq.dataverse.engine.command.AbstractCommand;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.license.License;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import java.util.List;
+
+/**
+ *
+ * @author stephenkraffmiller
+ */
+public class UpdateTemplateLicenseCommand extends AbstractCommand<Template>{
+    
+    private License license = null;
+    private TermsOfUseAndAccess customTermsOfUseAndAccess = null;
+    private Template template;
+
+    public UpdateTemplateLicenseCommand(DataverseRequest request, Template template, Dataverse dataverse, License license) {
+        super(request, dataverse);
+        this.template = template;
+        this.license = license;
+    }
+    
+    public UpdateTemplateLicenseCommand(DataverseRequest request, Template template, Dataverse dataverse, TermsOfUseAndAccess customTermsOfUseAndAccess) {
+        super(request, dataverse);
+        this.template = template;
+        this.customTermsOfUseAndAccess = customTermsOfUseAndAccess;
+    }
+
+    @Override
+    public Template execute(CommandContext ctxt) throws CommandException {
+        Template savedTemplate;
+        
+        if (license == null && customTermsOfUseAndAccess == null) {
+            throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("updateDatasetLicenseCommand.errors.customTermsOfUseNotProvided"), this);
+        }
+
+        if (license != null) {
+            if (!license.isActive()) {
+                throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("updateDatasetLicenseCommand.errors.licenseNotActive", List.of(license.getName())), this);
+            }
+            TermsOfUseAndAccess termsOfUseAndAccess = template.getTermsOfUseAndAccess();
+            termsOfUseAndAccess.setLicense(license);
+            savedTemplate = ctxt.templates().save(template);
+
+        } else  {
+            if (customTermsOfUseAndAccess.getTermsOfUse() == null || customTermsOfUseAndAccess.getTermsOfUse().isBlank()) {
+                throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("updateDatasetLicenseCommand.errors.customTermsOfUseNotProvided"), this);
+            }
+            TermsOfUseAndAccess termsToUpdate = template.getTermsOfUseAndAccess();
+            applyCustomTerms(termsToUpdate, customTermsOfUseAndAccess);
+            template.setTermsOfUseAndAccess(termsToUpdate);
+            savedTemplate = ctxt.templates().save(template);
+        }
+        
+        return savedTemplate;
+        
+    }
+    
+        /**
+     * Copies all custom term-related fields from the 'source' object
+     * to the 'target' object.
+     *
+     * @param target The TermsOfUseAndAccess object to be modified
+     * @param source The TermsOfUseAndAccess object containing the new data
+     */
+    private void applyCustomTerms(TermsOfUseAndAccess target, TermsOfUseAndAccess source) {
+        target.setTermsOfUse(source.getTermsOfUse());
+        target.setConfidentialityDeclaration(source.getConfidentialityDeclaration());
+        target.setSpecialPermissions(source.getSpecialPermissions());
+        target.setRestrictions(source.getRestrictions());
+        target.setCitationRequirements(source.getCitationRequirements());
+        target.setDepositorRequirements(source.getDepositorRequirements());
+        target.setConditions(source.getConditions());
+        target.setDisclaimer(source.getDisclaimer());
+    }
+    
+}
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index a1d8a3ea565..b54ffb63270 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -2617,9 +2617,9 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
         String apiToken = UtilIT.getApiTokenFromResponse(createUserResponse);
         String username = UtilIT.getUsernameFromResponse(createUserResponse);
 
-            Response createSecondUserResponse = UtilIT.createRandomUser();
-            String secondApiToken = UtilIT.getApiTokenFromResponse(createSecondUserResponse);
-            String secondUsername = UtilIT.getUsernameFromResponse(createSecondUserResponse);
+        Response createSecondUserResponse = UtilIT.createRandomUser();
+        String secondApiToken = UtilIT.getApiTokenFromResponse(createSecondUserResponse);
+        String secondUsername = UtilIT.getUsernameFromResponse(createSecondUserResponse);
 
         
         /*
@@ -2630,9 +2630,7 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
         createDataverseResponse.prettyPrint();
         createDataverseResponse.then().assertThat().statusCode(CREATED.getStatusCode());
         String dataverseAlias = UtilIT.getAliasFromResponse(createDataverseResponse);
-        Integer dataverseId = UtilIT.getDataverseIdFromResponse(createDataverseResponse);
-        
-        System.out.print("dataverseId: " + dataverseId);
+
         
         String newName = "New Test Dataverse Name";
         String newAffiliation = "New Test Dataverse Affiliation";
@@ -2802,6 +2800,122 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
         
 
     }
+    
+    
+    @Test
+    public void testUpdateTemplates() throws JsonParseException  {
+        /*
+          Also Terms of Use/access
+        */
+        
+        Response createUserResponse = UtilIT.createRandomUser();
+        String apiToken = UtilIT.getApiTokenFromResponse(createUserResponse);
+        String username = UtilIT.getUsernameFromResponse(createUserResponse);
+
+        Response createSecondUserResponse = UtilIT.createRandomUser();
+        String secondApiToken = UtilIT.getApiTokenFromResponse(createSecondUserResponse);
+        String secondUsername = UtilIT.getUsernameFromResponse(createSecondUserResponse);
+
+        
+        /*
+        We need to make this a non-inherited metadatablocks so the get template will only get templates from current dv
+         */
+        
+        Response createDataverseResponse = UtilIT.createRandomDataverse(apiToken);
+        createDataverseResponse.prettyPrint();
+        createDataverseResponse.then().assertThat().statusCode(CREATED.getStatusCode());
+        String dataverseAlias = UtilIT.getAliasFromResponse(createDataverseResponse);
+        
+        String newName = "New Test Dataverse Name";
+        String newAffiliation = "New Test Dataverse Affiliation";
+        String newDataverseType = Dataverse.DataverseType.TEACHING_COURSES.toString();
+        String[] newContactEmails = new String[]{"new_email@dataverse.com"};
+        String[] newInputLevelNames = new String[]{"geographicCoverage"};
+        String[] newFacetIds = new String[]{"contributorName"};
+        String[] newMetadataBlockNames = new String[]{"citation", "geospatial", "biomedical"};
+
+        // Giving the new Dataverse updated metadatablocks so that it will not inherit
+        // templates
+        Response updateDataverseResponse = UtilIT.updateDataverse(
+                dataverseAlias, dataverseAlias, newName, newAffiliation, newDataverseType, newContactEmails,
+                newInputLevelNames,
+                null, newMetadataBlockNames, apiToken,
+                Boolean.FALSE, Boolean.FALSE, null);
+
+        updateDataverseResponse.then().assertThat()
+                .statusCode(OK.getStatusCode());
+
+        String jsonString = """
+                            {
+                              "name": "Dataverse template",
+                              "isDefault": true,
+                              "fields": [
+                                {
+                                  "typeName": "author",
+                                  "value": [
+                                    {
+                                      "authorName": {
+                                        "typeName": "authorName",
+                                        "value": "Belicheck, Bill"
+                                      },
+                                      "authorAffiliation": {
+                                        "typeName": "authorIdentifierScheme",
+                                        "value": "ORCID"
+                                      }
+                                    }
+                                  ]
+                                }
+                              ],
+                              "instructions": [
+                                {
+                                    "instructionField": "author",
+                                    "instructionText": "The author data"
+                                }
+                              ]
+                            }
+                            """;
+
+        Response createTemplateResponse = UtilIT.createTemplate(
+                dataverseAlias,
+                jsonString,
+                apiToken);
+
+        createTemplateResponse.then().assertThat().statusCode(CREATED.getStatusCode())
+                .body("data.name", equalTo("Dataverse template"))
+                .body("data.isDefault", equalTo(true))
+                .body("data.usageCount", equalTo(0))
+                .body("data.termsOfUseAndAccess.license.name", equalTo("CC0 1.0"))
+                .body("data.datasetFields.citation.fields.size()", equalTo(1))
+                .body("data.instructions.size()", equalTo(1))
+                .body("data.instructions[0].instructionField", equalTo("author"))
+                .body("data.instructions[0].instructionText", equalTo("The author data"))
+                .body("data.dataverseAlias", equalTo(dataverseAlias));
+
+        Long templateId = createTemplateResponse.body().jsonPath().getLong("data.id");
+        
+        
+        Response updateTemplateResponse = UtilIT.updateTemplate(templateId.toString(), jsonString, apiToken);
+        
+        updateTemplateResponse.prettyPrint();
+
+        // back to super for cleanup
+        
+        UtilIT.setSuperuserStatus(username, true);
+        /*
+        Response deleteDataverse1Response = UtilIT.deleteDataverse(dataverseAlias, apiToken);
+        deleteDataverse1Response.prettyPrint();
+        assertEquals(200, deleteDataverse1Response.getStatusCode());
+        
+        Response deleteUserResponse = UtilIT.deleteUser(secondUsername);
+        deleteUserResponse.prettyPrint();
+        assertEquals(200, deleteUserResponse.getStatusCode());
+        
+        deleteUserResponse = UtilIT.deleteUser(username);
+        deleteUserResponse.prettyPrint();
+        assertEquals(200, deleteUserResponse.getStatusCode()); 
+*/
+
+    }
 
     @Test
     public void testGetStorageDriver() {
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
index 24ab8b56eff..ba95b4cbfcd 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
@@ -5157,6 +5157,14 @@ public static Response createTemplate(String dataverseAlias, String jsonString,
                 .post("/api/dataverses/" + dataverseAlias + "/templates");
     }
     
+    public static Response updateTemplate(String templateId, String jsonString, String apiToken) {
+        return given()
+                .contentType(ContentType.JSON)
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .body(jsonString)
+                .put("/api/dataverses/" + templateId + "/template");
+    }
+    
     public static Response deleteTemplate(String id,  String apiToken) {
         return given()
                 .header(API_TOKEN_HTTP_HEADER, apiToken)

From a314c7b2a958e3ba9b30a8f40ddca362aef0cb47 Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Tue, 3 Feb 2026 11:44:29 -0500
Subject: [PATCH 03/18] #11912 fix endpoints

---
 .../harvard/iq/dataverse/api/Dataverses.java  | 53 +++++++++++++++++--
 src/main/java/propertyFiles/Bundle.properties |  1 +
 2 files changed, 49 insertions(+), 5 deletions(-)

diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
index 3ba2bb27772..09c712f35ce 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -26,6 +26,7 @@
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
 import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
 import edu.harvard.iq.dataverse.engine.command.impl.*;
+import edu.harvard.iq.dataverse.license.License;
 import edu.harvard.iq.dataverse.pidproviders.PidProvider;
 import edu.harvard.iq.dataverse.pidproviders.PidUtil;
 import edu.harvard.iq.dataverse.settings.JvmSettings;
@@ -2033,20 +2034,62 @@ public Response createTemplate(@Context ContainerRequestContext crc, String body
     
     @PUT
     @AuthRequired
-    @Path("{templateId}/template")
-    public Response updateTemplate(@Context ContainerRequestContext crc, String body, @PathParam("templateId") Long templateId) {
+    @Path("{templateId}/editTemplateMetadata")
+    public Response updateTemplateMetadata(@Context ContainerRequestContext crc, String body, @PathParam("templateId") Long templateId, @QueryParam("replace") boolean replaceData) {
         try {
             Template template = findTemplateOrDie(templateId);
-          //  Dataverse dataverse = findDataverseOrDie(dvIdtf);
+            Dataverse dataverse = template.getDataverse();
             TemplateDTO templateDTO;
             try {
                 templateDTO = TemplateDTO.fromRequestBody(body, jsonParser());
             } catch (JsonParseException ex) {
                 return error(Status.BAD_REQUEST, MessageFormat.format(BundleUtil.getStringFromBundle("dataverse.createTemplate.error.jsonParseMetadataFields"), ex.getMessage()));
             }
-            Template created = execCommand(new CreateTemplateCommand(templateDTO.toTemplate(), createDataverseRequest(getRequestUser(crc)), dataverse, true));
             
-            return created("/dataverses/template/" + created.getId(), jsonTemplate(created));
+            JsonObject json = JsonUtil.getJsonObject(body);
+            List<DatasetField> updatedFields = new ArrayList<>();
+            if (json.getJsonArray("fields") == null) {
+                updatedFields.add(jsonParser().parseField(json, Boolean.FALSE, replaceData));
+            } else {
+                updatedFields = jsonParser().parseMultipleFields(json, replaceData);
+            }
+            
+            Template updated = execCommand(new UpdateTemplateFieldsCommand(templateDTO.toTemplate(), dataverse,  updatedFields,   true, createDataverseRequest(getRequestUser(crc))));
+            
+            return created("/dataverses/template/" + updated.getId(), jsonTemplate(updated));
+                } catch (JsonParseException ex) {
+            logger.log(Level.SEVERE, "Semantic error parsing dataset update Json: " + ex.getMessage(), ex);
+            return error(Response.Status.BAD_REQUEST, BundleUtil.getStringFromBundle("datasets.api.editMetadata.error.parseUpdate", List.of(ex.getMessage())));
+    
+        
+        } catch (WrappedResponse e) {
+            return e.getResponse();
+        }
+    }
+    
+    @PUT
+    @AuthRequired
+    @Path("{templateId}/editTemplateTerms")
+    public Response updateTemplateTerms(@Context ContainerRequestContext crc, LicenseUpdateRequest requestBody, @PathParam("templateId") Long templateId, @QueryParam("replace") boolean replaceData) {
+        try {
+            Template template = findTemplateOrDie(templateId);
+            Dataverse dataverse = template.getDataverse();
+            
+            if (requestBody.getName() != null && !requestBody.getName().isEmpty()) {
+                String licenseName = requestBody.getName();
+                License license = licenseSvc.getByNameOrUri(licenseName);
+                if (license == null) {
+                    return notFound(BundleUtil.getStringFromBundle("datasets.api.updateLicense.licenseNotFound", List.of(licenseName)));
+                }
+                execCommand(new UpdateTemplateLicenseCommand(createDataverseRequest(getRequestUser(crc)), template, dataverse, license));
+                return ok(BundleUtil.getStringFromBundle("dataverses.api.update.template.license.succes"));
+            } else if (requestBody.getCustomTerms() != null) {
+                CustomTermsDTO customTerms = requestBody.getCustomTerms();
+                execCommand(new UpdateTemplateLicenseCommand(createDataverseRequest(getRequestUser(crc)), template, dataverse, customTerms.toTermsOfUseAndAccess()));
+                return ok(BundleUtil.getStringFromBundle("dataverses.api.update.template.license.success"));
+            } else {
+                return badRequest(BundleUtil.getStringFromBundle("datasets.api.updateLicense.licenseNameIsEmpty"));
+            }
         
         } catch (WrappedResponse e) {
             return e.getResponse();
diff --git a/src/main/java/propertyFiles/Bundle.properties b/src/main/java/propertyFiles/Bundle.properties
index f6c0054a43a..16a3943d1bb 100644
--- a/src/main/java/propertyFiles/Bundle.properties
+++ b/src/main/java/propertyFiles/Bundle.properties
@@ -2907,6 +2907,7 @@ dataverses.api.validate.json.succeeded=The Dataset JSON provided is valid for th
 dataverses.api.validate.json.failed=The Dataset JSON provided failed validation with the following error:
 dataverses.api.validate.json.exception=Validation failed with following exception:
 dataverses.api.update.featured.items.error.onlyImageFilesAllowed=Invalid file type. Only image files are allowed.
+dataverses.api.update.template.license.success=Template license updated
 
 #Access.java
 access.api.allowRequests.failure.noDataset=Could not find Dataset with id: {0}

From cefb654eda0945811d966c07d4e60946f27cd8a8 Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Thu, 5 Feb 2026 10:29:08 -0500
Subject: [PATCH 04/18] #11912 update instructions, etc.

---
 .../harvard/iq/dataverse/api/Dataverses.java  | 12 ++--
 .../iq/dataverse/api/dto/TemplateDTO.java     | 60 +------------------
 .../impl/UpdateTemplateFieldsCommand.java     | 20 ++++++-
 .../iq/dataverse/util/json/JsonParser.java    | 15 +++++
 4 files changed, 39 insertions(+), 68 deletions(-)

diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
index 09c712f35ce..ce2502e357b 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -2039,13 +2039,7 @@ public Response updateTemplateMetadata(@Context ContainerRequestContext crc, Str
         try {
             Template template = findTemplateOrDie(templateId);
             Dataverse dataverse = template.getDataverse();
-            TemplateDTO templateDTO;
-            try {
-                templateDTO = TemplateDTO.fromRequestBody(body, jsonParser());
-            } catch (JsonParseException ex) {
-                return error(Status.BAD_REQUEST, MessageFormat.format(BundleUtil.getStringFromBundle("dataverse.createTemplate.error.jsonParseMetadataFields"), ex.getMessage()));
-            }
-            
+          
             JsonObject json = JsonUtil.getJsonObject(body);
             List<DatasetField> updatedFields = new ArrayList<>();
             if (json.getJsonArray("fields") == null) {
@@ -2053,8 +2047,10 @@ public Response updateTemplateMetadata(@Context ContainerRequestContext crc, Str
             } else {
                 updatedFields = jsonParser().parseMultipleFields(json, replaceData);
             }
+                      
+            Map<String, String> instructionsMap = jsonParser().parseRequestBodyInstructionsMap(json);
             
-            Template updated = execCommand(new UpdateTemplateFieldsCommand(templateDTO.toTemplate(), dataverse,  updatedFields,   true, createDataverseRequest(getRequestUser(crc))));
+            Template updated = execCommand(new UpdateTemplateFieldsCommand(template, dataverse,  updatedFields, instructionsMap, replaceData, createDataverseRequest(getRequestUser(crc))));
             
             return created("/dataverses/template/" + updated.getId(), jsonTemplate(updated));
                 } catch (JsonParseException ex) {
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/dto/TemplateDTO.java b/src/main/java/edu/harvard/iq/dataverse/api/dto/TemplateDTO.java
index 8826048370d..ace7b27f723 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/dto/TemplateDTO.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/dto/TemplateDTO.java
@@ -15,7 +15,6 @@ public class TemplateDTO {
     private List<DatasetField> datasetFields;
     private Map<String, String> instructionsMap;
     private boolean isDefault;
-    private Map<String, String> termsOfUseAndAccess;
 
     public static TemplateDTO fromRequestBody(String requestBody, JsonParser jsonParser) throws JsonParseException {
         TemplateDTO templateDTO = new TemplateDTO();
@@ -24,9 +23,8 @@ public static TemplateDTO fromRequestBody(String requestBody, JsonParser jsonPar
 
         templateDTO.name = jsonObject.getString("name");
         templateDTO.datasetFields = jsonParser.parseMultipleFields(jsonObject);
-        templateDTO.instructionsMap = parseRequestBodyInstructionsMap(jsonObject);
+        templateDTO.instructionsMap = jsonParser.parseRequestBodyInstructionsMap(jsonObject);
         templateDTO.isDefault = jsonObject.getBoolean("isDefault", false);
-        templateDTO.termsOfUseAndAccess = parseRequestBodyTerms(jsonObject);
                
         return templateDTO;
     }
@@ -60,61 +58,5 @@ public Map<String, String> getInstructionsMap() {
     public boolean isDefault() {
         return isDefault;
     }
-    
-    private static Map<String, String> parseRequestBodyTerms(JsonObject jsonObject){
-        Map<String, String> termsMap = new HashMap<>();
-        JsonArray termsJsonArray = jsonObject.getJsonArray("termsOfUseAndAccess");
-        if (termsJsonArray == null) {
-            return null;
-        }
-        /*
-        
-        {
-  "name": "CC BY 4.0"
-}
-                License license = termsOfUseAndAccess.getLicense();
-        return jsonObjectBuilder()
-                .add("id", termsOfUseAndAccess.getId())
-                .add("license", license != null ? json(license) : null)
-                .add("termsOfUse", termsOfUseAndAccess.getTermsOfUse())
-                .add("termsOfAccess", termsOfUseAndAccess.getTermsOfAccess())
-                .add("confidentialityDeclaration", termsOfUseAndAccess.getConfidentialityDeclaration())
-                .add("specialPermissions", termsOfUseAndAccess.getSpecialPermissions())
-                .add("restrictions", termsOfUseAndAccess.getRestrictions())
-                .add("citationRequirements", termsOfUseAndAccess.getCitationRequirements())
-                .add("depositorRequirements", termsOfUseAndAccess.getDepositorRequirements())
-                .add("conditions", termsOfUseAndAccess.getConditions())
-                .add("disclaimer", termsOfUseAndAccess.getDisclaimer())
-                .add("dataAccessPlace", termsOfUseAndAccess.getDataAccessPlace())
-                .add("originalArchive", termsOfUseAndAccess.getOriginalArchive())
-                .add("availabilityStatus", termsOfUseAndAccess.getAvailabilityStatus())
-                .add("sizeOfCollection", termsOfUseAndAccess.getSizeOfCollection())
-                .add("studyCompletion", termsOfUseAndAccess.getStudyCompletion())
-                .add("contactForAccess", termsOfUseAndAccess.getContactForAccess())
-                .add("fileAccessRequest", termsOfUseAndAccess.isFileAccessRequest());
-        */
-        
-        for (JsonObject instructionJsonObject : termsJsonArray.getValuesAs(JsonObject.class)) {
-            termsMap.put(
-                    instructionJsonObject.getString("instructionField"),
-                    instructionJsonObject.getString("instructionText")
-            );
-        }
-        return termsMap;
-    }
 
-    private static Map<String, String> parseRequestBodyInstructionsMap(JsonObject jsonObject) {
-        Map<String, String> instructionsMap = new HashMap<>();
-        JsonArray instructionsJsonArray = jsonObject.getJsonArray("instructions");
-        if (instructionsJsonArray == null) {
-            return null;
-        }
-        for (JsonObject instructionJsonObject : instructionsJsonArray.getValuesAs(JsonObject.class)) {
-            instructionsMap.put(
-                    instructionJsonObject.getString("instructionField"),
-                    instructionJsonObject.getString("instructionText")
-            );
-        }
-        return instructionsMap;
-    }
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java
index 28c38728158..55641fda088 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java
@@ -15,7 +15,9 @@
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
 import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  *
@@ -25,13 +27,15 @@ public class UpdateTemplateFieldsCommand extends AbstractCommand<Template> {
 
     private final Template template;   
     private final List<DatasetField> updatedFields;
+    private  final Map<String, String> instructions;
     private final boolean replaceData;
 
-    public UpdateTemplateFieldsCommand(Template template, Dataverse dataverse,  List<DatasetField> updatedFields, boolean replaceData, DataverseRequest request) {
+    public UpdateTemplateFieldsCommand(Template template, Dataverse dataverse,  List<DatasetField> updatedFields, Map<String, String> instructions, boolean replaceData, DataverseRequest request) {
         super(request, dataverse);
         this.template = template;
         this.updatedFields = updatedFields;
         this.replaceData = replaceData;
+        this.instructions = instructions;
     }
 
     @Override
@@ -43,6 +47,7 @@ public Template execute(CommandContext ctxt) throws CommandException {
                 
         Template savedTemplate;
         updateTemplateFields(template);
+        updateInstructions(template);
         savedTemplate = ctxt.templates().save(template);
 
         return savedTemplate;
@@ -158,4 +163,17 @@ private static void updateControlledVocabularyDatasetField(DatasetField updatedF
         }
     }
     
+    private void updateInstructions(Template template){
+        if(replaceData){
+            template.setInstructionsMap(instructions);
+            template.updateInstructions();
+        } else {
+            Map <String, String> currentInstructionsMap = template.getInstructionsMap();            
+            Map<String, String> merged = new HashMap<>(currentInstructionsMap);
+            merged.putAll(instructions);
+            template.setInstructionsMap(merged);
+            template.updateInstructions();           
+        }       
+    }
+    
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java
index 15cb5d7febf..81d13eeb1b6 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java
@@ -646,6 +646,21 @@ public List<DatasetField> parseMetadataBlocks(JsonObject json) throws JsonParseE
         }
         return fields;
     }
+    
+    public Map<String, String> parseRequestBodyInstructionsMap(JsonObject jsonObject) {
+        Map<String, String> instructionsMap = new HashMap<>();
+        JsonArray instructionsJsonArray = jsonObject.getJsonArray("instructions");
+        if (instructionsJsonArray == null) {
+            return null;
+        }
+        for (JsonObject instructionJsonObject : instructionsJsonArray.getValuesAs(JsonObject.class)) {
+            instructionsMap.put(
+                    instructionJsonObject.getString("instructionField"),
+                    instructionJsonObject.getString("instructionText")
+            );
+        }
+        return instructionsMap;
+    }
 
     public List<DatasetField> parseMultipleFields(JsonObject json) throws JsonParseException {
         return parseMultipleFields(json, false);

From 84c50cc225d596ce16ac0d83b2814561de3b638a Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Thu, 5 Feb 2026 14:06:36 -0500
Subject: [PATCH 05/18] #11912 update tests

---
 .../impl/UpdateTemplateFieldsCommand.java     |  3 ++
 .../iq/dataverse/api/DataversesIT.java        | 46 ++++++++++++++++++-
 .../edu/harvard/iq/dataverse/api/UtilIT.java  |  2 +-
 3 files changed, 49 insertions(+), 2 deletions(-)

diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java
index 55641fda088..f99ed498cc5 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommand.java
@@ -10,9 +10,11 @@
 import edu.harvard.iq.dataverse.DatasetFieldValue;
 import edu.harvard.iq.dataverse.Dataverse;
 import edu.harvard.iq.dataverse.Template;
+import edu.harvard.iq.dataverse.authorization.Permission;
 import edu.harvard.iq.dataverse.engine.command.AbstractCommand;
 import edu.harvard.iq.dataverse.engine.command.CommandContext;
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.RequiredPermissions;
 import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -23,6 +25,7 @@
  *
  * @author stephenkraffmiller
  */
+@RequiredPermissions(Permission.EditDataverse)
 public class UpdateTemplateFieldsCommand extends AbstractCommand<Template> {
 
     private final Template template;   
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index b54ffb63270..5e4b66c269d 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -2874,6 +2874,50 @@ public void testUpdateTemplates() throws JsonParseException  {
                               ]
                             }
                             """;
+        
+        String jsonStringForUpdate = """
+                            {
+                              "name": "Dataverse template - edited",
+                              "isDefault": true,
+                              "fields": [
+                                {
+                                  "typeName": "author",
+                                  "value": [
+                                    {
+                                      "authorName": {
+                                        "typeName": "authorName",
+                                        "value": "Belicheck, Bill"
+                                      },
+                                      "authorAffiliation": {
+                                        "typeName": "authorIdentifierScheme",
+                                        "value": "ORCID"
+                                      }
+                                    },
+                                    {
+                                        "authorName": {
+                                            "typeName": "authorName",
+                                            "value": "Brady, Tom"
+                                        },
+                                        "authorAffiliation": {
+                                            "typeName": "authorIdentifierScheme",
+                                            "value": "ORCID"
+                                        }
+                                    }
+                                  ]
+                                }
+                              ],
+                              "instructions": [
+                                {
+                                    "instructionField": "author",
+                                    "instructionText": "The author data, edited"
+                                },
+                                {
+                                    "instructionField": "subtitle",
+                                    "instructionText": "Info on subtitle"
+                                }
+                              ]
+                            }
+                            """;
 
         Response createTemplateResponse = UtilIT.createTemplate(
                 dataverseAlias,
@@ -2894,7 +2938,7 @@ public void testUpdateTemplates() throws JsonParseException  {
         Long templateId = createTemplateResponse.body().jsonPath().getLong("data.id");
         
         
-        Response updateTemplateResponse = UtilIT.updateTemplate(templateId.toString(), jsonString, apiToken);
+        Response updateTemplateResponse = UtilIT.updateTemplate(templateId.toString(), jsonStringForUpdate, apiToken);
         
         updateTemplateResponse.prettyPrint();
 
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
index ba95b4cbfcd..be4ad19ad52 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
@@ -5162,7 +5162,7 @@ public static Response updateTemplate(String templateId, String jsonString, Stri
                 .contentType(ContentType.JSON)
                 .header(API_TOKEN_HTTP_HEADER, apiToken)
                 .body(jsonString)
-                .put("/api/dataverses/" + templateId + "/template");
+                .put("/api/dataverses/" + templateId + "/editTemplateMetadata");
     }
     
     public static Response deleteTemplate(String id,  String apiToken) {

From 2fb60837c2fa74560e21a48249da22981efa7d8d Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Thu, 5 Feb 2026 15:02:21 -0500
Subject: [PATCH 06/18] #11912 update name

---
 .../java/edu/harvard/iq/dataverse/api/Dataverses.java | 11 +++++++++++
 .../edu/harvard/iq/dataverse/api/DataversesIT.java    |  6 ++++--
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
index ce2502e357b..980c237bfe9 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -2041,6 +2041,17 @@ public Response updateTemplateMetadata(@Context ContainerRequestContext crc, Str
             Dataverse dataverse = template.getDataverse();
           
             JsonObject json = JsonUtil.getJsonObject(body);
+            
+            /*
+            You can also set a new name for your template in the json
+            */
+            
+            String templateName = json.getString("name");
+            if (!templateName.isEmpty() && !templateName.isBlank()){
+                 template.setName(templateName);                
+            }
+
+            
             List<DatasetField> updatedFields = new ArrayList<>();
             if (json.getJsonArray("fields") == null) {
                 updatedFields.add(jsonParser().parseField(json, Boolean.FALSE, replaceData));
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index 5e4b66c269d..9b899b13f1b 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -2727,7 +2727,7 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
                 .body("data[0].instructions[0].instructionField", equalTo("author"))
                 .body("data[0].instructions[0].instructionText", equalTo("The author data"))
                 .body("data[0].dataverseAlias", equalTo(dataverseAlias));
-            
+
             Response removeDefaultResp = UtilIT.removeDefaultTemplate(dataverseAlias, apiToken);
             removeDefaultResp.prettyPrint();
             removeDefaultResp.then().assertThat().statusCode(OK.getStatusCode());       
@@ -2738,7 +2738,7 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
                             .body("data.size()", equalTo(1))
                             .body("data[0].isDefault", equalTo(false));
 
-
+        
             // Templates retrieval should fail if a secondary user lacks dataset creation
             // permissions
 
@@ -2923,6 +2923,8 @@ public void testUpdateTemplates() throws JsonParseException  {
                 dataverseAlias,
                 jsonString,
                 apiToken);
+        
+        createTemplateResponse.prettyPrint();
 
         createTemplateResponse.then().assertThat().statusCode(CREATED.getStatusCode())
                 .body("data.name", equalTo("Dataverse template"))

From ede1c8466fdc66d0cb012e12a80c7d97fb669bc2 Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Fri, 6 Feb 2026 14:22:28 -0500
Subject: [PATCH 07/18] #11912 more tests

---
 .../harvard/iq/dataverse/api/Dataverses.java  |  2 +-
 .../iq/dataverse/api/DataversesIT.java        | 65 +++++++++++++++----
 .../edu/harvard/iq/dataverse/api/UtilIT.java  |  4 +-
 3 files changed, 55 insertions(+), 16 deletions(-)

diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
index 980c237bfe9..d31ce214aac 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -2039,7 +2039,7 @@ public Response updateTemplateMetadata(@Context ContainerRequestContext crc, Str
         try {
             Template template = findTemplateOrDie(templateId);
             Dataverse dataverse = template.getDataverse();
-          
+      
             JsonObject json = JsonUtil.getJsonObject(body);
             
             /*
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index 9b899b13f1b..f1391bac31d 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -2875,24 +2875,13 @@ public void testUpdateTemplates() throws JsonParseException  {
                             }
                             """;
         
-        String jsonStringForUpdate = """
+        String jsonStringForUpdateNotReplace = """
                             {
                               "name": "Dataverse template - edited",
-                              "isDefault": true,
                               "fields": [
                                 {
                                   "typeName": "author",
                                   "value": [
-                                    {
-                                      "authorName": {
-                                        "typeName": "authorName",
-                                        "value": "Belicheck, Bill"
-                                      },
-                                      "authorAffiliation": {
-                                        "typeName": "authorIdentifierScheme",
-                                        "value": "ORCID"
-                                      }
-                                    },
                                     {
                                         "authorName": {
                                             "typeName": "authorName",
@@ -2918,6 +2907,36 @@ public void testUpdateTemplates() throws JsonParseException  {
                               ]
                             }
                             """;
+        
+                
+        String jsonStringForUpdateReplaceData = """
+                            {
+                              "name": "Dataverse template - edited - again",
+                              "fields": [
+                                {
+                                  "typeName": "author",
+                                  "value": [
+                                    {
+                                        "authorName": {
+                                            "typeName": "authorName",
+                                            "value": "Vrabel, Mike"
+                                        },
+                                        "authorAffiliation": {
+                                            "typeName": "authorIdentifierScheme",
+                                            "value": "ORCID"
+                                        }
+                                    }
+                                  ]
+                                }
+                              ],
+                              "instructions": [
+                                {
+                                    "instructionField": "title",
+                                    "instructionText": "A title for, you know, your thing"
+                                }
+                              ]
+                            }
+                            """;
 
         Response createTemplateResponse = UtilIT.createTemplate(
                 dataverseAlias,
@@ -2940,10 +2959,30 @@ public void testUpdateTemplates() throws JsonParseException  {
         Long templateId = createTemplateResponse.body().jsonPath().getLong("data.id");
         
         
-        Response updateTemplateResponse = UtilIT.updateTemplate(templateId.toString(), jsonStringForUpdate, apiToken);
+        Response updateTemplateResponse = UtilIT.updateTemplateMetadata(templateId.toString(), jsonStringForUpdateNotReplace, apiToken, false);
         
         updateTemplateResponse.prettyPrint();
 
+        updateTemplateResponse.then().assertThat().statusCode(CREATED.getStatusCode())
+                .body("data.name", equalTo("Dataverse template - edited"))
+                .body("data.usageCount", equalTo(0))
+                .body("data.termsOfUseAndAccess.license.name", equalTo("CC0 1.0"))
+                .body("data.datasetFields.citation.fields.size()", equalTo(1))
+                .body("data.instructions.size()", equalTo(2))
+                .body("data.dataverseAlias", equalTo(dataverseAlias));
+        
+        Response updateTemplateReplaceResponse = UtilIT.updateTemplateMetadata(templateId.toString(), jsonStringForUpdateReplaceData, apiToken, true);
+        
+        updateTemplateReplaceResponse.prettyPrint();
+
+        updateTemplateReplaceResponse.then().assertThat().statusCode(CREATED.getStatusCode())
+                .body("data.name", equalTo("Dataverse template - edited - again"))
+                .body("data.usageCount", equalTo(0))
+                .body("data.termsOfUseAndAccess.license.name", equalTo("CC0 1.0"))
+                .body("data.datasetFields.citation.fields.size()", equalTo(1))
+                .body("data.instructions.size()", equalTo(1))
+                .body("data.dataverseAlias", equalTo(dataverseAlias));
+        
         // back to super for cleanup
         
         UtilIT.setSuperuserStatus(username, true);
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
index be4ad19ad52..7c821027f89 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
@@ -5157,12 +5157,12 @@ public static Response createTemplate(String dataverseAlias, String jsonString,
                 .post("/api/dataverses/" + dataverseAlias + "/templates");
     }
     
-    public static Response updateTemplate(String templateId, String jsonString, String apiToken) {
+    public static Response updateTemplateMetadata(String templateId, String jsonString, String apiToken, Boolean replaceData) {
         return given()
                 .contentType(ContentType.JSON)
                 .header(API_TOKEN_HTTP_HEADER, apiToken)
                 .body(jsonString)
-                .put("/api/dataverses/" + templateId + "/editTemplateMetadata");
+                .put("/api/dataverses/" + templateId + "/editTemplateMetadata?replace=" + replaceData);
     }
     
     public static Response deleteTemplate(String id,  String apiToken) {

From 9bdcae57960a999d198186c149b3fe6e5c9b228e Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Mon, 9 Feb 2026 10:48:47 -0500
Subject: [PATCH 08/18] #11912 fix command/tests

---
 .../harvard/iq/dataverse/api/Dataverses.java  |  3 +-
 .../impl/UpdateTemplateLicenseCommand.java    |  3 ++
 .../iq/dataverse/api/DataversesIT.java        | 46 +++++++++++++++++++
 .../edu/harvard/iq/dataverse/api/UtilIT.java  |  8 ++++
 4 files changed, 59 insertions(+), 1 deletion(-)

diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
index d31ce214aac..01353423bf0 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -2088,8 +2088,9 @@ public Response updateTemplateTerms(@Context ContainerRequestContext crc, Licens
                 if (license == null) {
                     return notFound(BundleUtil.getStringFromBundle("datasets.api.updateLicense.licenseNotFound", List.of(licenseName)));
                 }
+                
                 execCommand(new UpdateTemplateLicenseCommand(createDataverseRequest(getRequestUser(crc)), template, dataverse, license));
-                return ok(BundleUtil.getStringFromBundle("dataverses.api.update.template.license.succes"));
+                return ok(BundleUtil.getStringFromBundle("dataverses.api.update.template.license.success"));
             } else if (requestBody.getCustomTerms() != null) {
                 CustomTermsDTO customTerms = requestBody.getCustomTerms();
                 execCommand(new UpdateTemplateLicenseCommand(createDataverseRequest(getRequestUser(crc)), template, dataverse, customTerms.toTermsOfUseAndAccess()));
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommand.java
index 82de6adde13..126350cf510 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommand.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommand.java
@@ -7,9 +7,11 @@
 import edu.harvard.iq.dataverse.Dataverse;
 import edu.harvard.iq.dataverse.Template;
 import edu.harvard.iq.dataverse.TermsOfUseAndAccess;
+import edu.harvard.iq.dataverse.authorization.Permission;
 import edu.harvard.iq.dataverse.engine.command.AbstractCommand;
 import edu.harvard.iq.dataverse.engine.command.CommandContext;
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.RequiredPermissions;
 import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
 import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
 import edu.harvard.iq.dataverse.license.License;
@@ -20,6 +22,7 @@
  *
  * @author stephenkraffmiller
  */
+@RequiredPermissions(Permission.EditDataverse)
 public class UpdateTemplateLicenseCommand extends AbstractCommand<Template>{
     
     private License license = null;
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index f1391bac31d..805840af471 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -12,6 +12,7 @@
 
 import io.restassured.response.Response;
 import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.Template;
 import edu.harvard.iq.dataverse.settings.SettingsServiceBean;
 import edu.harvard.iq.dataverse.util.BundleUtil;
 
@@ -2937,6 +2938,36 @@ public void testUpdateTemplates() throws JsonParseException  {
                               ]
                             }
                             """;
+        
+                String jsonStringForUpdateTerms = """
+                            {
+                              "name": "Dataverse template - edited - again",
+                              "fields": [
+                                {
+                                  "typeName": "author",
+                                  "value": [
+                                    {
+                                        "authorName": {
+                                            "typeName": "authorName",
+                                            "value": "Vrabel, Mike"
+                                        },
+                                        "authorAffiliation": {
+                                            "typeName": "authorIdentifierScheme",
+                                            "value": "ORCID"
+                                        }
+                                    }
+                                  ]
+                                }
+                              ],
+                              "instructions": [
+                                {
+                                    "instructionField": "title",
+                                    "instructionText": "A title for, you know, your thing"
+                                }
+                              ]
+                            }
+                            """;
+
 
         Response createTemplateResponse = UtilIT.createTemplate(
                 dataverseAlias,
@@ -2983,6 +3014,21 @@ public void testUpdateTemplates() throws JsonParseException  {
                 .body("data.instructions.size()", equalTo(1))
                 .body("data.dataverseAlias", equalTo(dataverseAlias));
         
+        
+        //Update Template License
+                // Test case 1: Update to a valid, predefined license (CC BY 4.0).
+        Response updateLicenseResponse = UtilIT.updateTemplateLicenseTerms(templateId.toString(), "{ \"name\": \"CC BY 4.0\" }", apiToken);
+        updateLicenseResponse.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.message", equalTo(BundleUtil.getStringFromBundle("dataverses.api.update.template.license.success")));
+
+        Response getTemplate  = UtilIT.getTemplate(templateId.toString(),  apiToken);
+        getTemplate.prettyPrint();
+        getTemplate.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.termsOfUseAndAccess.license.name", equalTo("CC BY 4.0"));
+
+        
         // back to super for cleanup
         
         UtilIT.setSuperuserStatus(username, true);
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
index 7c821027f89..250fa75ee09 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
@@ -5165,6 +5165,14 @@ public static Response updateTemplateMetadata(String templateId, String jsonStri
                 .put("/api/dataverses/" + templateId + "/editTemplateMetadata?replace=" + replaceData);
     }
     
+    public static Response updateTemplateLicenseTerms(String templateId, String jsonString, String apiToken) {
+        return given()
+                .contentType(ContentType.JSON)
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .body(jsonString)
+                .put("/api/dataverses/" + templateId + "/editTemplateTerms");
+    }
+    
     public static Response deleteTemplate(String id,  String apiToken) {
         return given()
                 .header(API_TOKEN_HTTP_HEADER, apiToken)

From d8b484f113e21f8607bd78d2c025f20bca7bcfaf Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Mon, 9 Feb 2026 16:23:30 -0500
Subject: [PATCH 09/18] #11912 update terms test

---
 .../iq/dataverse/api/DataversesIT.java        | 52 +++++++++----------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index 805840af471..d4b6c1fbb5d 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -2940,32 +2940,18 @@ public void testUpdateTemplates() throws JsonParseException  {
                             """;
         
                 String jsonStringForUpdateTerms = """
-                            {
-                              "name": "Dataverse template - edited - again",
-                              "fields": [
-                                {
-                                  "typeName": "author",
-                                  "value": [
-                                    {
-                                        "authorName": {
-                                            "typeName": "authorName",
-                                            "value": "Vrabel, Mike"
-                                        },
-                                        "authorAffiliation": {
-                                            "typeName": "authorIdentifierScheme",
-                                            "value": "ORCID"
-                                        }
-                                    }
-                                  ]
-                                }
-                              ],
-                              "instructions": [
-                                {
-                                    "instructionField": "title",
-                                    "instructionText": "A title for, you know, your thing"
-                                }
-                              ]
-                            }
+            {
+                   "customTerms": {
+                     "termsOfUse": "testTermsOfUse",
+                     "confidentialityDeclaration": "testConfidentialityDeclaration",
+                     "specialPermissions": "testSpecialPermissions",
+                     "restrictions": "testRestrictions",
+                     "citationRequirements": "testCitationRequirements",
+                     "depositorRequirements": "testDepositorRequirements",
+                     "conditions": "testConditions",
+                     "disclaimer": "testDisclaimer"
+                   }
+                 }
                             """;
 
 
@@ -3027,8 +3013,22 @@ public void testUpdateTemplates() throws JsonParseException  {
         getTemplate.then().assertThat()
                 .statusCode(OK.getStatusCode())
                 .body("data.termsOfUseAndAccess.license.name", equalTo("CC BY 4.0"));
+        
+        Response updateTermsResponse = UtilIT.updateTemplateLicenseTerms(templateId.toString(), jsonStringForUpdateTerms, apiToken);
+        updateTermsResponse.prettyPrint();
 
         
+
+        updateTermsResponse.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.message", equalTo(BundleUtil.getStringFromBundle("dataverses.api.update.template.license.success")));
+
+        getTemplate  = UtilIT.getTemplate(templateId.toString(),  apiToken);
+        getTemplate.prettyPrint();
+                getTemplate.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.termsOfUseAndAccess.termsOfUse", equalTo("testTermsOfUse"));
+
         // back to super for cleanup
         
         UtilIT.setSuperuserStatus(username, true);

From f40d44df993b607c364914af672a85bb19fe4737 Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Wed, 11 Feb 2026 10:12:03 -0500
Subject: [PATCH 10/18] #11912 simplify endpoint

---
 src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java   | 4 ++--
 src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java | 5 -----
 src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java       | 4 ++--
 3 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
index 01353423bf0..6b08ebb01d3 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -2034,7 +2034,7 @@ public Response createTemplate(@Context ContainerRequestContext crc, String body
     
     @PUT
     @AuthRequired
-    @Path("{templateId}/editTemplateMetadata")
+    @Path("{templateId}/templateMetadata")
     public Response updateTemplateMetadata(@Context ContainerRequestContext crc, String body, @PathParam("templateId") Long templateId, @QueryParam("replace") boolean replaceData) {
         try {
             Template template = findTemplateOrDie(templateId);
@@ -2076,7 +2076,7 @@ public Response updateTemplateMetadata(@Context ContainerRequestContext crc, Str
     
     @PUT
     @AuthRequired
-    @Path("{templateId}/editTemplateTerms")
+    @Path("{templateId}/templateTerms")
     public Response updateTemplateTerms(@Context ContainerRequestContext crc, LicenseUpdateRequest requestBody, @PathParam("templateId") Long templateId, @QueryParam("replace") boolean replaceData) {
         try {
             Template template = findTemplateOrDie(templateId);
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index d4b6c1fbb5d..a441bf6a4c1 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -2813,11 +2813,6 @@ public void testUpdateTemplates() throws JsonParseException  {
         String apiToken = UtilIT.getApiTokenFromResponse(createUserResponse);
         String username = UtilIT.getUsernameFromResponse(createUserResponse);
 
-        Response createSecondUserResponse = UtilIT.createRandomUser();
-        String secondApiToken = UtilIT.getApiTokenFromResponse(createSecondUserResponse);
-        String secondUsername = UtilIT.getUsernameFromResponse(createSecondUserResponse);
-
-        
         /*
         We need to make this a non-inherited metadatablocks so the get template will only get templates from current dv
          */
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
index 250fa75ee09..526a0b86d54 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
@@ -5162,7 +5162,7 @@ public static Response updateTemplateMetadata(String templateId, String jsonStri
                 .contentType(ContentType.JSON)
                 .header(API_TOKEN_HTTP_HEADER, apiToken)
                 .body(jsonString)
-                .put("/api/dataverses/" + templateId + "/editTemplateMetadata?replace=" + replaceData);
+                .put("/api/dataverses/" + templateId + "/templateMetadata?replace=" + replaceData);
     }
     
     public static Response updateTemplateLicenseTerms(String templateId, String jsonString, String apiToken) {
@@ -5170,7 +5170,7 @@ public static Response updateTemplateLicenseTerms(String templateId, String json
                 .contentType(ContentType.JSON)
                 .header(API_TOKEN_HTTP_HEADER, apiToken)
                 .body(jsonString)
-                .put("/api/dataverses/" + templateId + "/editTemplateTerms");
+                .put("/api/dataverses/" + templateId + "/templateTerms");
     }
     
     public static Response deleteTemplate(String id,  String apiToken) {

From 284098200393cc0c7eaa9d40e6b916ffc4683fbe Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Thu, 12 Feb 2026 09:18:47 -0500
Subject: [PATCH 11/18] #11912 add command for update access

---
 .../harvard/iq/dataverse/api/Dataverses.java  | 32 ++++++++++
 .../UpdateTemplateTermsOfAccessCommand.java   | 63 +++++++++++++++++++
 src/main/java/propertyFiles/Bundle.properties |  3 +
 .../iq/dataverse/api/DataversesIT.java        | 19 ++++++
 .../edu/harvard/iq/dataverse/api/UtilIT.java  |  9 +++
 5 files changed, 126 insertions(+)
 create mode 100644 src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommand.java

diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
index 6b08ebb01d3..b35aa37c546 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -73,6 +73,7 @@
 import jakarta.ws.rs.WebApplicationException;
 import jakarta.ws.rs.core.Context;
 import jakarta.ws.rs.core.HttpHeaders;
+import static jakarta.ws.rs.core.Response.Status.BAD_REQUEST;
 import jakarta.ws.rs.core.StreamingOutput;
 import org.glassfish.jersey.media.multipart.FormDataBodyPart;
 import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
@@ -2103,6 +2104,37 @@ public Response updateTemplateTerms(@Context ContainerRequestContext crc, Licens
             return e.getResponse();
         }
     }
+    
+    @PUT
+    @AuthRequired
+    @Path("{templateId}/access")
+    public Response editTemplateTermsOfAccess(@Context ContainerRequestContext crc, String jsonBody, @PathParam("templateId") Long templateId) {
+        try {
+
+            boolean publicInstall = settingsSvc.isTrueForKey(SettingsServiceBean.Key.PublicInstall, false);
+
+            Template template = findTemplateOrDie(templateId);
+
+            JsonObject json = JsonUtil.getJsonObject(jsonBody);
+
+            TermsOfUseAndAccess toua = jsonParser().parseTermsOfAccess(json);
+
+            if (publicInstall && (toua.isFileAccessRequest() || !toua.getTermsOfAccess().isEmpty())){
+                return error(BAD_REQUEST, "Setting File Access Request or Terms of Access is not permitted on a public installation.");
+            }
+
+            execCommand(new UpdateTemplateTermsOfAccessCommand(createDataverseRequest(getRequestUser(crc)), template, template.getDataverse(), toua ));
+
+            return ok(BundleUtil.getStringFromBundle("dataverses.api.update.template.access.success"));
+
+        } catch (JsonParseException ex) {
+            logger.log(Level.SEVERE, "Semantic error parsing template terms update Json: " + ex.getMessage(), ex);
+            return error(Response.Status.BAD_REQUEST, BundleUtil.getStringFromBundle("datasets.api.editMetadata.error.parseUpdate", List.of(ex.getMessage())));
+        } catch (WrappedResponse ex) {
+            logger.log(Level.SEVERE, "Update terms of access error: " + ex.getMessage(), ex);
+            return ex.getResponse();
+        }
+    }
 
     @POST
     @AuthRequired
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommand.java
new file mode 100644
index 00000000000..cb45629d9ee
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommand.java
@@ -0,0 +1,63 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.Template;
+import edu.harvard.iq.dataverse.TermsOfUseAndAccess;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.engine.command.AbstractCommand;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.RequiredPermissions;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+
+
+/**
+ *
+ * @author stephenkraffmiller
+ */
+@RequiredPermissions(Permission.EditDataverse)
+public class UpdateTemplateTermsOfAccessCommand extends AbstractCommand<Template> {
+    
+    private TermsOfUseAndAccess customTermsOfUseAndAccess = null;
+    private Template template;
+   
+    public UpdateTemplateTermsOfAccessCommand(DataverseRequest request, Template template, Dataverse dataverse, TermsOfUseAndAccess customTermsOfUseAndAccess) {
+        super(request, dataverse);
+        this.template = template;
+        this.customTermsOfUseAndAccess = customTermsOfUseAndAccess;
+    }
+
+    @Override
+    public Template execute(CommandContext ctxt) throws CommandException {
+        Template savedTemplate;
+
+        if (customTermsOfUseAndAccess == null) {
+            throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("updateDatasetLicenseCommand.errors.customTermsOfUseNotProvided"), this);
+        }
+
+        TermsOfUseAndAccess termsToUpdate = template.getTermsOfUseAndAccess();
+        applyCustomTerms(termsToUpdate, customTermsOfUseAndAccess);
+        template.setTermsOfUseAndAccess(termsToUpdate);
+        savedTemplate = ctxt.templates().save(template);
+
+        return savedTemplate;
+    }
+    
+    private void applyCustomTerms(TermsOfUseAndAccess target, TermsOfUseAndAccess source) {
+        target.setTermsOfUse(source.getTermsOfUse());
+        target.setConfidentialityDeclaration(source.getConfidentialityDeclaration());
+        target.setSpecialPermissions(source.getSpecialPermissions());
+        target.setRestrictions(source.getRestrictions());
+        target.setCitationRequirements(source.getCitationRequirements());
+        target.setDepositorRequirements(source.getDepositorRequirements());
+        target.setConditions(source.getConditions());
+        target.setDisclaimer(source.getDisclaimer());
+    }
+    
+}
diff --git a/src/main/java/propertyFiles/Bundle.properties b/src/main/java/propertyFiles/Bundle.properties
index 16a3943d1bb..dbf8c6a9b4d 100644
--- a/src/main/java/propertyFiles/Bundle.properties
+++ b/src/main/java/propertyFiles/Bundle.properties
@@ -2908,6 +2908,9 @@ dataverses.api.validate.json.failed=The Dataset JSON provided failed validation
 dataverses.api.validate.json.exception=Validation failed with following exception:
 dataverses.api.update.featured.items.error.onlyImageFilesAllowed=Invalid file type. Only image files are allowed.
 dataverses.api.update.template.license.success=Template license updated
+dataverses.api.update.template.terms.success=Template Terms of Use updated
+dataverses.api.update.template.access.success=Template Terms of Access updated
+dataverses.api.editMetadata.template.error.parseUpdate==Error parsing template update: {0}
 
 #Access.java
 access.api.allowRequests.failure.noDataset=Could not find Dataset with id: {0}
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index a441bf6a4c1..30fe033a12a 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -2948,6 +2948,22 @@ public void testUpdateTemplates() throws JsonParseException  {
                    }
                  }
                             """;
+                
+                String jsonStringForUpdateAccess = """
+            {
+                   "customTermsOfAccess": {
+                     "fileAccessRequest": false,                              
+                     "termsOfAccess": "termsOfAccess",
+                     "dataAccessPlace": "dataAccessPlace",
+                     "originalArchive": "originalArchive",
+                     "availabilityStatus": "availabilityStatus",
+                     "contactForAccess": "contactForAccess",
+                     "sizeOfCollection": "sizeOfCollection",
+                     "studyCompletion": "studyCompletion",
+                     "confidentialityDeclaration": "confidentialityDeclaration"
+                   }
+                 }
+                            """;
 
 
         Response createTemplateResponse = UtilIT.createTemplate(
@@ -3023,7 +3039,10 @@ public void testUpdateTemplates() throws JsonParseException  {
                 getTemplate.then().assertThat()
                 .statusCode(OK.getStatusCode())
                 .body("data.termsOfUseAndAccess.termsOfUse", equalTo("testTermsOfUse"));
+                
+        Response updateAccessResponse = UtilIT.updateTemplateAccessTerms(templateId.toString(), jsonStringForUpdateAccess, apiToken);
 
+        updateAccessResponse.prettyPrint();
         // back to super for cleanup
         
         UtilIT.setSuperuserStatus(username, true);
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
index 526a0b86d54..508846e51b6 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
@@ -5173,6 +5173,15 @@ public static Response updateTemplateLicenseTerms(String templateId, String json
                 .put("/api/dataverses/" + templateId + "/templateTerms");
     }
     
+        
+    public static Response updateTemplateAccessTerms(String templateId, String jsonString, String apiToken) {
+        return given()
+                .contentType(ContentType.JSON)
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .body(jsonString)
+                .put("/api/dataverses/" + templateId + "/access");
+    }
+    
     public static Response deleteTemplate(String id,  String apiToken) {
         return given()
                 .header(API_TOKEN_HTTP_HEADER, apiToken)

From 8ce04ec8a321aa37f584ee06b76db9476ff18c04 Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Thu, 12 Feb 2026 10:41:49 -0500
Subject: [PATCH 12/18] #11912 fix update and tests

---
 .../UpdateTemplateTermsOfAccessCommand.java     | 17 +++++++++--------
 .../harvard/iq/dataverse/api/DataversesIT.java  | 12 +++++++++++-
 2 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommand.java
index cb45629d9ee..a294257bfe1 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommand.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommand.java
@@ -50,14 +50,15 @@ public Template execute(CommandContext ctxt) throws CommandException {
     }
     
     private void applyCustomTerms(TermsOfUseAndAccess target, TermsOfUseAndAccess source) {
-        target.setTermsOfUse(source.getTermsOfUse());
-        target.setConfidentialityDeclaration(source.getConfidentialityDeclaration());
-        target.setSpecialPermissions(source.getSpecialPermissions());
-        target.setRestrictions(source.getRestrictions());
-        target.setCitationRequirements(source.getCitationRequirements());
-        target.setDepositorRequirements(source.getDepositorRequirements());
-        target.setConditions(source.getConditions());
-        target.setDisclaimer(source.getDisclaimer());
+        
+        target.setFileAccessRequest(source.isFileAccessRequest());
+        target.setTermsOfAccess(source.getTermsOfAccess());
+        target.setDataAccessPlace(source.getDataAccessPlace());
+        target.setOriginalArchive(source.getOriginalArchive());
+        target.setAvailabilityStatus(source.getAvailabilityStatus());
+        target.setContactForAccess(source.getContactForAccess());
+        target.setSizeOfCollection(source.getSizeOfCollection());
+        target.setStudyCompletion(source.getStudyCompletion());
     }
     
 }
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index 30fe033a12a..f23a991a8f9 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -2953,7 +2953,7 @@ public void testUpdateTemplates() throws JsonParseException  {
             {
                    "customTermsOfAccess": {
                      "fileAccessRequest": false,                              
-                     "termsOfAccess": "termsOfAccess",
+                     "termsOfAccess": "Here are the terms...",
                      "dataAccessPlace": "dataAccessPlace",
                      "originalArchive": "originalArchive",
                      "availabilityStatus": "availabilityStatus",
@@ -3043,6 +3043,16 @@ public void testUpdateTemplates() throws JsonParseException  {
         Response updateAccessResponse = UtilIT.updateTemplateAccessTerms(templateId.toString(), jsonStringForUpdateAccess, apiToken);
 
         updateAccessResponse.prettyPrint();
+                updateAccessResponse.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.message", equalTo(BundleUtil.getStringFromBundle("dataverses.api.update.template.access.success")));
+
+                
+        getTemplate  = UtilIT.getTemplate(templateId.toString(),  apiToken);
+        getTemplate.prettyPrint();
+                getTemplate.then().assertThat()
+                .statusCode(OK.getStatusCode())
+                .body("data.termsOfUseAndAccess.termsOfAccess", equalTo("Here are the terms..."));        
         // back to super for cleanup
         
         UtilIT.setSuperuserStatus(username, true);

From 38fba3cc84367700b4bd71f8ef4cdef0339c525d Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Thu, 12 Feb 2026 14:29:34 -0500
Subject: [PATCH 13/18] #11912 add unit tests

---
 .../impl/UpdateTemplateFieldsCommandTest.java | 181 ++++++++++++++++++
 .../UpdateTemplateLicenseCommandTest.java     | 102 ++++++++++
 ...pdateTemplateTermsOfAccessCommandTest.java |  86 +++++++++
 3 files changed, 369 insertions(+)
 create mode 100644 src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommandTest.java
 create mode 100644 src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommandTest.java
 create mode 100644 src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommandTest.java

diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommandTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommandTest.java
new file mode 100644
index 00000000000..ef24e4349e7
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateFieldsCommandTest.java
@@ -0,0 +1,181 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.DatasetField;
+import edu.harvard.iq.dataverse.DatasetFieldCompoundValue;
+import edu.harvard.iq.dataverse.DatasetFieldType;
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.Template;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.TemplateServiceBean;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+/**
+ *
+ * @author stephenkraffmiller
+ */
+@ExtendWith(MockitoExtension.class)
+public class UpdateTemplateFieldsCommandTest {
+
+    @Mock
+    private CommandContext ctxt;
+    @Mock
+    private TemplateServiceBean templateService;
+    @Mock
+    private DataverseRequest request;
+    @Mock
+    private Dataverse dataverse;
+
+    private Template template;
+    private List<DatasetField> updatedFields;
+    private Map<String, String> instructions;
+
+    @BeforeEach
+    void setUp() {
+        template = new Template();
+        template.setDatasetFields(new ArrayList<>());
+        updatedFields = new ArrayList<>();
+        instructions = new HashMap<>();
+
+        lenient().when(ctxt.templates()).thenReturn(templateService);
+        lenient().when(templateService.save(any(Template.class))).thenAnswer(i -> i.getArguments()[0]);
+    }
+
+    @Test
+    void testExecute_AddNewField() throws Exception {
+        // Arrange: Updated fields contains a field not in the template
+        DatasetField newField = createPrimitiveField("title", "New Template Title");
+        updatedFields.add(newField);
+
+        UpdateTemplateFieldsCommand cmd = new UpdateTemplateFieldsCommand(template, dataverse, updatedFields, instructions, false, request);
+
+        // Act
+        Template result = cmd.execute(ctxt);
+
+        // Assert
+        assertEquals(1, result.getDatasetFields().size());
+        assertEquals("New Template Title", result.getDatasetFields().get(0).getValue());
+    }
+
+    @Test
+    void testExecute_ReplaceExistingData() throws Exception {
+        // Arrange: Template has an existing field
+        DatasetField existingField = createPrimitiveField("description", "Old Description");
+ 
+        template.getDatasetFields().add(existingField);
+        existingField.setTemplate(template);
+
+        // New field with same type but different value
+        DatasetField newField = createPrimitiveField("description", "New Description");
+        updatedFields.add(newField);
+
+        // replaceData = true
+        UpdateTemplateFieldsCommand cmd = new UpdateTemplateFieldsCommand(template, dataverse, updatedFields, instructions, true, request);
+
+        // Act
+        cmd.execute(ctxt);
+
+        // Assert
+        assertEquals(1, template.getDatasetFields().size());
+        assertEquals("New Description", template.getDatasetFields().get(0).getValue());
+    }
+
+    @Test
+    void testUpdateInstructions_MergeLogic() throws Exception {
+        // Arrange
+        template.setInstructionsMap(new HashMap<>(Map.of("field1", "old instruction")));
+        instructions.put("field2", "new instruction");
+
+        // replaceData = false (Merge)
+        UpdateTemplateFieldsCommand cmd = new UpdateTemplateFieldsCommand(template, dataverse, updatedFields, instructions, false, request);
+
+        // Act
+        cmd.execute(ctxt);
+
+        // Assert
+        Map<String, String> resultInstructions = template.getInstructionsMap();
+        assertEquals(2, resultInstructions.size());
+        assertTrue(resultInstructions.containsKey("field1"));
+        assertTrue(resultInstructions.containsKey("field2"));
+    }
+
+    @Test
+
+    void testExecute_CompoundField_Logic() throws Exception {
+        // 1. Setup the Type
+        DatasetFieldType compoundType = new DatasetFieldType();
+        compoundType.setName("author");
+        // Since we can't setCompound, we add a child type to make isCompound() return true
+        DatasetFieldType childType = new DatasetFieldType();
+        childType.setName("authorName");
+        compoundType.setChildDatasetFieldTypes(List.of(childType));
+
+        // 2. Setup existing field in Template
+        DatasetField existingField = new DatasetField();
+        existingField.setDatasetFieldType(compoundType);
+
+        // Create an existing compound value
+        DatasetFieldCompoundValue existingValue = new DatasetFieldCompoundValue();
+        existingField.setDatasetFieldCompoundValues(new ArrayList<>(List.of(existingValue)));
+
+        template.getDatasetFields().add(existingField);
+
+        // 3. Setup the Update Command input
+        DatasetField updatedField = new DatasetField();
+        updatedField.setDatasetFieldType(compoundType);
+
+        DatasetFieldCompoundValue newValue = new DatasetFieldCompoundValue();
+        updatedField.setDatasetFieldCompoundValues(List.of(newValue));
+        updatedFields.add(updatedField);
+
+        // We need to spy or mock the display values because 
+        // real display value calculation requires deep child-field nesting
+        DatasetField spyExisting = spy(existingField);
+        DatasetField spyUpdated = spy(updatedField);
+
+        // Scenario: They are different, so newValue should be added
+        doReturn("Author 1").when(spyExisting).getCompoundDisplayValue();
+        doReturn("Author 2").when(spyUpdated).getCompoundDisplayValue();
+
+        // Re-inject the spy into the template fields list
+        template.getDatasetFields().clear();
+        template.getDatasetFields().add(spyExisting);
+
+        UpdateTemplateFieldsCommand cmd = new UpdateTemplateFieldsCommand(
+                template, dataverse, List.of(spyUpdated), instructions, false, request
+        );
+
+        // Act
+        cmd.execute(ctxt);
+
+        // Assert
+        assertEquals(2, spyExisting.getDatasetFieldCompoundValues().size(),
+                "Should have added the new compound value since display values differed");
+    }
+
+    // Helper to build DatasetFields for testing
+    private DatasetField createPrimitiveField(String typeName, String value) {
+        DatasetField f = new DatasetField();
+        DatasetFieldType type = new DatasetFieldType();
+        type.setChildDatasetFieldTypes(new ArrayList<>());
+        type.setName(typeName);
+        f.setDatasetFieldType(type);
+        f.setSingleValue(value);
+        return f;
+    }
+}
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommandTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommandTest.java
new file mode 100644
index 00000000000..b3260525816
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateLicenseCommandTest.java
@@ -0,0 +1,102 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.Template;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.TemplateServiceBean;
+import edu.harvard.iq.dataverse.TermsOfUseAndAccess;
+import edu.harvard.iq.dataverse.license.License;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+public class UpdateTemplateLicenseCommandTest {
+
+    private UpdateTemplateLicenseCommand cmd;
+
+    @Mock private CommandContext ctxt;
+    @Mock private TemplateServiceBean templateService;
+    @Mock private DataverseRequest request;
+    @Mock private Dataverse dataverse;
+    @Mock private Template template;
+    
+    // We use a real object for terms to verify field mapping easily
+    private TermsOfUseAndAccess existingTerms;
+
+    @BeforeEach
+    void setUp() {
+        existingTerms = new TermsOfUseAndAccess();
+        lenient().when(ctxt.templates()).thenReturn(templateService);
+        lenient().when(template.getTermsOfUseAndAccess()).thenReturn(existingTerms);
+    }
+
+    @Test
+    void testExecute_SuccessWithLicense() throws Exception {
+        // Arrange
+        License activeLicense = mock(License.class);
+        when(activeLicense.isActive()).thenReturn(true);
+        when(templateService.save(template)).thenReturn(template);
+        
+        cmd = new UpdateTemplateLicenseCommand(request, template, dataverse, activeLicense);
+
+        // Act
+        Template result = cmd.execute(ctxt);
+
+        // Assert
+        assertEquals(activeLicense, existingTerms.getLicense());
+        verify(templateService).save(template);
+        assertNotNull(result);
+    }
+
+    @Test
+    void testExecute_InactiveLicenseThrowsException() {
+        // Arrange
+        License inactiveLicense = mock(License.class);
+        when(inactiveLicense.isActive()).thenReturn(false);
+        when(inactiveLicense.getName()).thenReturn("CC BY-NC");
+        
+        cmd = new UpdateTemplateLicenseCommand(request, template, dataverse, inactiveLicense);
+
+        // Act & Assert
+        assertThrows(InvalidCommandArgumentsException.class, () -> cmd.execute(ctxt));
+    }
+
+    @Test
+    void testExecute_SuccessWithCustomTerms() throws Exception {
+        // Arrange
+        TermsOfUseAndAccess customTerms = new TermsOfUseAndAccess();
+        customTerms.setTermsOfUse("My Custom Rules");
+        customTerms.setConfidentialityDeclaration("Top Secret");
+        
+        when(templateService.save(template)).thenReturn(template);
+        
+        cmd = new UpdateTemplateLicenseCommand(request, template, dataverse, customTerms);
+
+        // Act
+        cmd.execute(ctxt);
+
+        // Assert
+        assertEquals("My Custom Rules", existingTerms.getTermsOfUse());
+        assertEquals("Top Secret", existingTerms.getConfidentialityDeclaration());
+        verify(templateService).save(template);
+    }
+
+    @Test
+    void testExecute_BlankCustomTermsThrowsException() {
+        // Arrange
+        TermsOfUseAndAccess blankTerms = new TermsOfUseAndAccess();
+        blankTerms.setTermsOfUse("   "); // Blank string
+        
+        cmd = new UpdateTemplateLicenseCommand(request, template, dataverse, blankTerms);
+
+        // Act & Assert
+        assertThrows(InvalidCommandArgumentsException.class, () -> cmd.execute(ctxt));
+    }
+}
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommandTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommandTest.java
new file mode 100644
index 00000000000..4a9763e7de9
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/UpdateTemplateTermsOfAccessCommandTest.java
@@ -0,0 +1,86 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+/**
+ *
+ * @author stephenkraffmiller
+ */
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.Template;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+
+import edu.harvard.iq.dataverse.TemplateServiceBean;
+import edu.harvard.iq.dataverse.TermsOfUseAndAccess;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+public class UpdateTemplateTermsOfAccessCommandTest {
+
+    private UpdateTemplateTermsOfAccessCommand cmd;
+
+    @Mock private CommandContext ctxt;
+    @Mock private TemplateServiceBean templateService;
+    @Mock private DataverseRequest request;
+    @Mock private Dataverse dataverse;
+    @Mock private Template template;
+
+    // We'll use real POJOs for the terms to verify the data transfer logic
+    private TermsOfUseAndAccess targetTerms;
+    private TermsOfUseAndAccess sourceTerms;
+
+    @BeforeEach
+    void setUp() {
+        targetTerms = new TermsOfUseAndAccess();
+        sourceTerms = new TermsOfUseAndAccess();
+        
+        // Setup the context to return our mocked service
+        lenient().when(ctxt.templates()).thenReturn(templateService);
+        // Setup the template to return our "target" terms object
+        lenient().when(template.getTermsOfUseAndAccess()).thenReturn(targetTerms);
+    }
+
+    @Test
+    void testExecute_Success() throws Exception {
+        // Arrange: Populate the source with data
+        sourceTerms.setFileAccessRequest(true);
+        sourceTerms.setTermsOfAccess("Special restricted access only.");
+        sourceTerms.setDataAccessPlace("Secure Data Lab");
+        
+        when(templateService.save(template)).thenReturn(template);
+        
+        cmd = new UpdateTemplateTermsOfAccessCommand(request, template, dataverse, sourceTerms);
+
+        // Act
+        Template result = cmd.execute(ctxt);
+
+        // Assert: Verify the target object was updated with source values
+        assertTrue(targetTerms.isFileAccessRequest());
+        assertEquals("Special restricted access only.", targetTerms.getTermsOfAccess());
+        assertEquals("Secure Data Lab", targetTerms.getDataAccessPlace());
+        
+        // Verify interaction
+        verify(templateService).save(template);
+        assertNotNull(result);
+    }
+
+    @Test
+    void testExecute_NullTermsThrowsException() {
+        // Arrange
+        cmd = new UpdateTemplateTermsOfAccessCommand(request, template, dataverse, null);
+
+        // Act & Assert
+        assertThrows(InvalidCommandArgumentsException.class, () -> cmd.execute(ctxt));
+    }
+}
\ No newline at end of file

From 977652434ffeea0bb099d1ef1ca308cdc0e4ca28 Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Thu, 12 Feb 2026 15:45:15 -0500
Subject: [PATCH 14/18] #11912 release notes and cleanup

---
 doc/release-notes/11912-edit-template-apis    | 23 +++++++++++++++++++
 .../harvard/iq/dataverse/api/Dataverses.java  |  8 +++----
 .../edu/harvard/iq/dataverse/api/UtilIT.java  |  4 ++--
 3 files changed, 29 insertions(+), 6 deletions(-)
 create mode 100644 doc/release-notes/11912-edit-template-apis

diff --git a/doc/release-notes/11912-edit-template-apis b/doc/release-notes/11912-edit-template-apis
new file mode 100644
index 00000000000..41cfc257526
--- /dev/null
+++ b/doc/release-notes/11912-edit-template-apis
@@ -0,0 +1,23 @@
+## New Endpoint: PUT `/dataverses/{templateId}/metadata`
+
+A new endpoint has been implemented to edit the metadata and field instructions for a given template.
+
+### Functionality
+- Updates the metadata and field instructions for a template based on a json file provided.
+- You must have edit dataverse permission in the collection in order to use this endpoint.
+
+## New Endpoint: PUT `/dataverses/{templateId}/licenseTerms`
+
+A new endpoint has been implemented to edit the license or custom terms of use for a given template.
+
+### Functionality
+- Updates the license or custom terms of use for a template based on a json file provided.
+- You must have edit dataverse permission in the collection in order to use this endpoint.
+
+## New Endpoint: PUT `/dataverses/{templateId}/access`
+
+A new endpoint has been implemented to edit terms of access for a given template.
+
+### Functionality
+- Updates the terms of access for a template based on a json file provided.
+- You must have edit dataverse permission in the collection in order to use this endpoint.
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
index b35aa37c546..b1a95a10282 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -2035,7 +2035,7 @@ public Response createTemplate(@Context ContainerRequestContext crc, String body
     
     @PUT
     @AuthRequired
-    @Path("{templateId}/templateMetadata")
+    @Path("{templateId}/metadata")
     public Response updateTemplateMetadata(@Context ContainerRequestContext crc, String body, @PathParam("templateId") Long templateId, @QueryParam("replace") boolean replaceData) {
         try {
             Template template = findTemplateOrDie(templateId);
@@ -2077,8 +2077,8 @@ public Response updateTemplateMetadata(@Context ContainerRequestContext crc, Str
     
     @PUT
     @AuthRequired
-    @Path("{templateId}/templateTerms")
-    public Response updateTemplateTerms(@Context ContainerRequestContext crc, LicenseUpdateRequest requestBody, @PathParam("templateId") Long templateId, @QueryParam("replace") boolean replaceData) {
+    @Path("{templateId}/licenseTerms")
+    public Response updateTemplateLicenseTerms(@Context ContainerRequestContext crc, LicenseUpdateRequest requestBody, @PathParam("templateId") Long templateId, @QueryParam("replace") boolean replaceData) {
         try {
             Template template = findTemplateOrDie(templateId);
             Dataverse dataverse = template.getDataverse();
@@ -2108,7 +2108,7 @@ public Response updateTemplateTerms(@Context ContainerRequestContext crc, Licens
     @PUT
     @AuthRequired
     @Path("{templateId}/access")
-    public Response editTemplateTermsOfAccess(@Context ContainerRequestContext crc, String jsonBody, @PathParam("templateId") Long templateId) {
+    public Response updateTemplateTermsOfAccess(@Context ContainerRequestContext crc, String jsonBody, @PathParam("templateId") Long templateId) {
         try {
 
             boolean publicInstall = settingsSvc.isTrueForKey(SettingsServiceBean.Key.PublicInstall, false);
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
index 508846e51b6..887c4040191 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
@@ -5162,7 +5162,7 @@ public static Response updateTemplateMetadata(String templateId, String jsonStri
                 .contentType(ContentType.JSON)
                 .header(API_TOKEN_HTTP_HEADER, apiToken)
                 .body(jsonString)
-                .put("/api/dataverses/" + templateId + "/templateMetadata?replace=" + replaceData);
+                .put("/api/dataverses/" + templateId + "/metadata?replace=" + replaceData);
     }
     
     public static Response updateTemplateLicenseTerms(String templateId, String jsonString, String apiToken) {
@@ -5170,7 +5170,7 @@ public static Response updateTemplateLicenseTerms(String templateId, String json
                 .contentType(ContentType.JSON)
                 .header(API_TOKEN_HTTP_HEADER, apiToken)
                 .body(jsonString)
-                .put("/api/dataverses/" + templateId + "/templateTerms");
+                .put("/api/dataverses/" + templateId + "/licenseTerms");
     }
     
         

From 0b7f7e5761a0f9fb4b88d6f3fcb9b23b617330fa Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Thu, 12 Feb 2026 15:46:36 -0500
Subject: [PATCH 15/18] #11912 typo

---
 doc/release-notes/11912-edit-template-apis | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/release-notes/11912-edit-template-apis b/doc/release-notes/11912-edit-template-apis
index 41cfc257526..91324f38330 100644
--- a/doc/release-notes/11912-edit-template-apis
+++ b/doc/release-notes/11912-edit-template-apis
@@ -16,7 +16,7 @@ A new endpoint has been implemented to edit the license or custom terms of use f
 
 ## New Endpoint: PUT `/dataverses/{templateId}/access`
 
-A new endpoint has been implemented to edit terms of access for a given template.
+A new endpoint has been implemented to edit the terms of access for a given template.
 
 ### Functionality
 - Updates the terms of access for a template based on a json file provided.

From 61d05941a3c01dd5b65571d6abf21f5b6cbc57b4 Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Thu, 12 Feb 2026 16:20:00 -0500
Subject: [PATCH 16/18] #11912 sample json for update template

---
 .../_static/api/template-update-access.json   | 13 ++++++++
 .../_static/api/template-update-license.json  |  1 +
 .../_static/api/template-update-metadata.json | 30 +++++++++++++++++++
 .../_static/api/template-update-terms.json    | 12 ++++++++
 4 files changed, 56 insertions(+)
 create mode 100644 doc/sphinx-guides/source/_static/api/template-update-access.json
 create mode 100644 doc/sphinx-guides/source/_static/api/template-update-license.json
 create mode 100644 doc/sphinx-guides/source/_static/api/template-update-metadata.json
 create mode 100644 doc/sphinx-guides/source/_static/api/template-update-terms.json

diff --git a/doc/sphinx-guides/source/_static/api/template-update-access.json b/doc/sphinx-guides/source/_static/api/template-update-access.json
new file mode 100644
index 00000000000..e2d86de3283
--- /dev/null
+++ b/doc/sphinx-guides/source/_static/api/template-update-access.json
@@ -0,0 +1,13 @@
+{
+    "customTermsOfAccess": {
+        "fileAccessRequest": false,                              
+        "termsOfAccess": "Here are the terms...",
+        "dataAccessPlace": "dataAccessPlace",
+        "originalArchive": "originalArchive",
+        "availabilityStatus": "availabilityStatus",
+        "contactForAccess": "contactForAccess",
+        "sizeOfCollection": "sizeOfCollection",
+        "studyCompletion": "studyCompletion",
+        "confidentialityDeclaration": "confidentialityDeclaration"
+    }
+}
diff --git a/doc/sphinx-guides/source/_static/api/template-update-license.json b/doc/sphinx-guides/source/_static/api/template-update-license.json
new file mode 100644
index 00000000000..455f4c9d9bd
--- /dev/null
+++ b/doc/sphinx-guides/source/_static/api/template-update-license.json
@@ -0,0 +1 @@
+{ "name": "CC BY 4.0" }
diff --git a/doc/sphinx-guides/source/_static/api/template-update-metadata.json b/doc/sphinx-guides/source/_static/api/template-update-metadata.json
new file mode 100644
index 00000000000..46e201a05f9
--- /dev/null
+++ b/doc/sphinx-guides/source/_static/api/template-update-metadata.json
@@ -0,0 +1,30 @@
+{
+    "name": "Dataverse template - edited",
+    "fields": [
+        {
+            "typeName": "author",
+            "value": [
+                {
+                    "authorName": {
+                        "typeName": "authorName",
+                        "value": "Brady, Tom"
+                    },
+                    "authorAffiliation": {
+                        "typeName": "authorIdentifierScheme",
+                        "value": "ORCID"
+                    }
+                }
+            ]
+        }
+    ],
+    "instructions": [
+        {
+            "instructionField": "author",
+            "instructionText": "The author data, edited"
+        },
+        {
+            "instructionField": "subtitle",
+            "instructionText": "Instructions for subtitle"
+        }
+    ]
+}
diff --git a/doc/sphinx-guides/source/_static/api/template-update-terms.json b/doc/sphinx-guides/source/_static/api/template-update-terms.json
new file mode 100644
index 00000000000..5cf166a83c4
--- /dev/null
+++ b/doc/sphinx-guides/source/_static/api/template-update-terms.json
@@ -0,0 +1,12 @@
+{
+    "customTerms": {
+        "termsOfUse": "testTermsOfUse",
+        "confidentialityDeclaration": "testConfidentialityDeclaration",
+        "specialPermissions": "testSpecialPermissions",
+        "restrictions": "testRestrictions",
+        "citationRequirements": "testCitationRequirements",
+        "depositorRequirements": "testDepositorRequirements",
+        "conditions": "testConditions",
+        "disclaimer": "testDisclaimer"
+    }
+}

From 92463aabb030837963a20f80115f47251cd8ab4b Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Thu, 12 Feb 2026 16:43:07 -0500
Subject: [PATCH 17/18] Update native-api.rst

---
 doc/sphinx-guides/source/api/native-api.rst | 63 +++++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/doc/sphinx-guides/source/api/native-api.rst b/doc/sphinx-guides/source/api/native-api.rst
index eab71f8623b..6be96c3f8a7 100644
--- a/doc/sphinx-guides/source/api/native-api.rst
+++ b/doc/sphinx-guides/source/api/native-api.rst
@@ -1639,6 +1639,69 @@ The fully expanded example above (without environment variables) looks like this
 
   curl -H "X-Dataverse-key: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X POST "https://demo.dataverse.org/api/dataverses/1/templates" --upload-file dataverse-template.json
 
+Update the Metadata and Instructions of a Template
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Updates the metadata and instructions of a template with a given ``id``.
+
+To update the template, you must send a JSON file. Your JSON file might look like :download:`template-update-metadata.json <../_static/api/template-update-metadata.json>` which you would send to the Dataverse installation like this:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=1
+
+  curl -H "X-Dataverse-key: $API_TOKEN" -X PUT "$SERVER_URL/api/dataverses/{ID}/metadata" --upload-file template-update-metadata.json
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X PUT "https://demo.dataverse.org/api/dataverses/1/metadata" --upload-file template-update-metadata.json
+
+Update the License or Terms Of Use of a Template
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Updates the license or custom terms of use of a template with a given ``id``.
+
+To update the template, you must send a JSON file containing either the name of an active license or custom terms of use. Your JSON file might look like :download:`template-update-license.json <../_static/api/template-update-license.json>`  or :download:`template-update-terms.json <../_static/api/template-update-terms.json>` which you would send to the Dataverse installation like this:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=1
+
+  curl -H "X-Dataverse-key: $API_TOKEN" -X PUT "$SERVER_URL/api/dataverses/{ID}/licenseTerms" --upload-file template-update-license.json
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X PUT "https://demo.dataverse.org/api/dataverses/1/licenseTerms" --upload-file template-update-license.json
+
+Update the Terms Of Access of a Template
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Updates the terms of access of a template with a given ``id``.
+
+To update the template, you must send a JSON file containing either the name of an active license or custom terms of use. Your JSON file might look like :download:`template-update-access.json <../_static/api/template-update-access.json>` which you would send to the Dataverse installation like this:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=1
+
+  curl -H "X-Dataverse-key: $API_TOKEN" -X PUT "$SERVER_URL/api/dataverses/{ID}/access" --upload-file template-update-access.json
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X PUT "https://demo.dataverse.org/api/dataverses/1/access" --upload-file template-update-access.json
+
 Set a Default Template for a Collection
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

From 2c2e6a84d0e281595b7624bad012b377e092001f Mon Sep 17 00:00:00 2001
From: Stephen Kraffmiller <skraffmiller@hmdc.harvard.edu>
Date: Thu, 12 Feb 2026 16:54:49 -0500
Subject: [PATCH 18/18] #11912 return test clean up

---
 .../edu/harvard/iq/dataverse/api/DataversesIT.java     | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index f23a991a8f9..874bb1f41fa 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -3056,19 +3056,15 @@ public void testUpdateTemplates() throws JsonParseException  {
         // back to super for cleanup
         
         UtilIT.setSuperuserStatus(username, true);
-        /*
+        
         Response deleteDataverse1Response = UtilIT.deleteDataverse(dataverseAlias, apiToken);
         deleteDataverse1Response.prettyPrint();
         assertEquals(200, deleteDataverse1Response.getStatusCode());
         
-        Response deleteUserResponse = UtilIT.deleteUser(secondUsername);
-        deleteUserResponse.prettyPrint();
-        assertEquals(200, deleteUserResponse.getStatusCode());
-        
-        deleteUserResponse = UtilIT.deleteUser(username);
+        Response deleteUserResponse = UtilIT.deleteUser(username);
         deleteUserResponse.prettyPrint();
         assertEquals(200, deleteUserResponse.getStatusCode()); 
-*/
+
 
     }