DisplayOnCreate Fixes

src/main/java/edu/harvard/iq/dataverse/DatasetFieldServiceBean.java

@@ -944,7 +944,7 @@ private Predicate buildFieldPresentInDataversePredicate(Dataverse dataverse, boo
         // Predicate for displayOnCreate in input level
         Predicate displayOnCreateInputLevelPredicate = criteriaBuilder.and(
             criteriaBuilder.equal(datasetFieldTypeRoot, datasetFieldTypeInputLevelJoin.get("datasetFieldType")),
-            criteriaBuilder.isTrue(datasetFieldTypeInputLevelJoin.get("displayOnCreate"))
+            criteriaBuilder.equal(datasetFieldTypeInputLevelJoin.get("displayOnCreate"), Boolean.TRUE)
         );
 
         // Create a subquery to check for the absence of a specific DataverseFieldTypeInputLevel.
@@ -953,7 +953,8 @@ private Predicate buildFieldPresentInDataversePredicate(Dataverse dataverse, boo
         subquery.select(criteriaBuilder.literal(1L))
                 .where(
                         criteriaBuilder.equal(subqueryRoot.get("dataverse"), dataverseRoot),
-                        criteriaBuilder.equal(subqueryRoot.get("datasetFieldType"), datasetFieldTypeRoot)
+                        criteriaBuilder.equal(subqueryRoot.get("datasetFieldType"), datasetFieldTypeRoot),
+                        criteriaBuilder.isNotNull(subqueryRoot.get("displayOnCreate"))
                 );
 
         // Define a predicate to exclude DatasetFieldTypes that have no associated input level (i.e., the subquery does not return a result).

src/main/java/edu/harvard/iq/dataverse/DatasetFieldType.java

@@ -273,21 +273,35 @@ public void setValidationFormat(String validationFormat) {
      * Determines whether this field type is displayed in the form when creating
      * the Dataset (or only later when editing after the initial creation).
      */
-    @Column(name = "displayoncreate", nullable = true)
-    private Boolean displayOnCreate;
+    private boolean displayOnCreate;
 
-    public Boolean isDisplayOnCreate() {
+    public boolean isDisplayOnCreate() {
         return displayOnCreate;
     }
 
-    public Boolean getDisplayOnCreate() {
-        return displayOnCreate;
+    public void setDisplayOnCreate(boolean displayOnCreate) {
+        this.displayOnCreate = displayOnCreate;
     }
 
-    public void setDisplayOnCreate(Boolean displayOnCreate) {
-        this.displayOnCreate = displayOnCreate;
+    /**
+     * Determines whether this field type is displayed in the form when creating
+     * the Dataset (or only later when editing after the initial creation).
+     */
+    @Transient
+    private Boolean localDisplayOnCreate;
+
+    public Boolean getLocalDisplayOnCreate() {
+        return localDisplayOnCreate;
+    }
+
+    public void setLocalDisplayOnCreate(Boolean localDisplayOnCreate) {
+        this.localDisplayOnCreate = localDisplayOnCreate;
     }
 
+    public boolean shouldDisplayOnCreate() {
+        return (localDisplayOnCreate == null) ? displayOnCreate : localDisplayOnCreate;
+    }
+
     public boolean isControlledVocabulary() {
         return allowControlledVocabulary;
     }

src/main/java/edu/harvard/iq/dataverse/DatasetPage.java

@@ -1856,7 +1856,10 @@ private void updateDatasetFieldInputLevels() {
                 if (dsf != null){
                     // Yes, call "setInclude"
                     dsf.setInclude(oneDSFieldTypeInputLevel.isInclude());
-                    dsf.getDatasetFieldType().setDisplayOnCreate(oneDSFieldTypeInputLevel.isDisplayOnCreate());
+                    Boolean displayOnCreate = oneDSFieldTypeInputLevel.getDisplayOnCreate();
+                    if (displayOnCreate!= null) {
+                        dsf.getDatasetFieldType().setLocalDisplayOnCreate(displayOnCreate);
+                    }
                     // remove from hash
                     mapDatasetFields.remove(oneDSFieldTypeInputLevel.getDatasetFieldType().getId());
                 }

src/main/java/edu/harvard/iq/dataverse/Dataverse.java

@@ -438,10 +438,17 @@ public boolean isDatasetFieldTypeInInputLevels(Long datasetFieldTypeId) {
                 .anyMatch(inputLevel -> inputLevel.getDatasetFieldType().getId().equals(datasetFieldTypeId));
     }
 
+    public DataverseFieldTypeInputLevel getDatasetFieldTypeInInputLevels(Long datasetFieldTypeId) {
+        return dataverseFieldTypeInputLevels.stream()
+                .filter(inputLevel -> inputLevel.getDatasetFieldType().getId().equals(datasetFieldTypeId))
+                .findFirst()
+                .orElse(null);
+    }
+
     public boolean isDatasetFieldTypeDisplayOnCreateAsInputLevel(Long datasetFieldTypeId) {
         return dataverseFieldTypeInputLevels.stream()
                 .anyMatch(inputLevel -> inputLevel.getDatasetFieldType().getId().equals(datasetFieldTypeId) 
-                         && inputLevel.isDisplayOnCreate());
+                         && Boolean.TRUE.equals(inputLevel.getDisplayOnCreate()));
     }
 
     public Template getDefaultTemplate() {

src/main/java/edu/harvard/iq/dataverse/DataverseFieldTypeInputLevel.java

@@ -6,6 +6,8 @@
 package edu.harvard.iq.dataverse;
 
 import java.io.Serializable;
+
+import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
@@ -58,11 +60,14 @@ public class DataverseFieldTypeInputLevel implements Serializable {
     private DatasetFieldType datasetFieldType;
     private boolean include;
     private boolean required;
-    private boolean displayOnCreate;
+
+
+    @Column(nullable = true)
+    private Boolean displayOnCreate;
 
     public DataverseFieldTypeInputLevel () {}
 
-    public DataverseFieldTypeInputLevel (DatasetFieldType fieldType, Dataverse dataverse, boolean required, boolean include, boolean displayOnCreate) {
+    public DataverseFieldTypeInputLevel (DatasetFieldType fieldType, Dataverse dataverse, boolean required, boolean include, Boolean displayOnCreate) {
         this.datasetFieldType = fieldType;
         this.dataverse = dataverse;
         this.required = required;
@@ -117,11 +122,11 @@ public void setRequired(boolean required) {
         this.required = required;
     }
 
-    public boolean isDisplayOnCreate() {
+    public Boolean getDisplayOnCreate() {
         return displayOnCreate;
     }
 
-    public void setDisplayOnCreate(boolean displayOnCreate) {
+    public void setDisplayOnCreate(Boolean displayOnCreate) {
         this.displayOnCreate = displayOnCreate;
     }
 

src/main/java/edu/harvard/iq/dataverse/DataversePage.java

@@ -1025,12 +1025,11 @@ private void loadInputLevels(DatasetFieldType dsft, Long dataverseIdForInputLeve
         if (dsfIl != null) {
             dsft.setRequiredDV(dsfIl.isRequired());
             dsft.setInclude(dsfIl.isInclude());
-            dsft.setDisplayOnCreate(dsfIl.isDisplayOnCreate());
+            dsft.setLocalDisplayOnCreate(dsfIl.getDisplayOnCreate());
         } else {
             // If there is no input level, use the default values
             dsft.setRequiredDV(dsft.isRequired());
             dsft.setInclude(true);
-            dsft.setDisplayOnCreate(false);
         }
     }
 
@@ -1317,7 +1316,7 @@ public void updateDisplayOnCreate(Long mdbId, Long dsftId, boolean currentValue)
                 for (DatasetFieldType dsft : mdb.getDatasetFieldTypes()) {
                     if (dsft.getId().equals(dsftId)) {
                         // Update value in memory
-                        dsft.setDisplayOnCreate(!currentValue);
+                        dsft.setLocalDisplayOnCreate(!currentValue);
 
                         // Update or create input level
                         DataverseFieldTypeInputLevel existingLevel = dataverseFieldTypeInputLevelService
@@ -1348,18 +1347,18 @@ private void saveInputLevels(List<DataverseFieldTypeInputLevel> listDFTIL, Datas
             .findByDataverseIdDatasetFieldTypeId(dataverse.getId(), dsft.getId());
 
         if (existingLevel != null) {
-            existingLevel.setDisplayOnCreate(dsft.isDisplayOnCreate());
+            existingLevel.setDisplayOnCreate(dsft.getLocalDisplayOnCreate());
             existingLevel.setInclude(dsft.isInclude());
             existingLevel.setRequired(dsft.isRequiredDV());
             listDFTIL.add(existingLevel);
-        } else if (dsft.isInclude() || dsft.isDisplayOnCreate() || dsft.isRequiredDV()) {
+        } else if (dsft.isInclude() || (dsft.getLocalDisplayOnCreate()!=null) || dsft.isRequiredDV()) {
             // Only create new input level if there is any specific configuration
             listDFTIL.add(new DataverseFieldTypeInputLevel(
                 dsft, 
                 dataverse, 
                 dsft.isRequiredDV(), 
                 dsft.isInclude(), 
-                dsft.isDisplayOnCreate()
+                dsft.getLocalDisplayOnCreate()
             ));
         }
     }

src/main/java/edu/harvard/iq/dataverse/DataverseServiceBean.java

@@ -961,13 +961,13 @@ public  String getCollectionDatasetSchema(String dataverseAlias, Map<String, Map
                     if (dsfIl != null) {
                         dsft.setRequiredDV(dsfIl.isRequired());
                         dsft.setInclude(dsfIl.isInclude());
-                        dsft.setDisplayOnCreate(dsfIl.isDisplayOnCreate());
+                        dsft.setLocalDisplayOnCreate(dsfIl.getDisplayOnCreate());
                     } else {
                         dsft.setRequiredDV(dsft.isRequired());
                         dsft.setInclude(true);
+                        // Default displayOnCreate to true for required fields
+                        dsft.setLocalDisplayOnCreate(dsft.isRequired());
                     }
-
-                    // Process child fields if any
                     List<String> childrenRequired = new ArrayList<>();
                     List<String> childrenAllowed = new ArrayList<>();
                     if (dsft.isHasChildren()) {
@@ -976,10 +976,12 @@ public  String getCollectionDatasetSchema(String dataverseAlias, Map<String, Map
                             if (dsfIlChild != null) {
                                 child.setRequiredDV(dsfIlChild.isRequired());
                                 child.setInclude(dsfIlChild.isInclude());
-                                child.setDisplayOnCreate(dsfIlChild.isDisplayOnCreate());
+                                child.setLocalDisplayOnCreate(dsfIlChild.getDisplayOnCreate());
                             } else {
                                 child.setRequiredDV(child.isRequired() && dsft.isRequired());
                                 child.setInclude(true);
+                                // Default displayOnCreate to true for required child fields
+                                child.setLocalDisplayOnCreate(child.isRequired());
                             }
                             if (child.isRequired()) {
                                 childrenRequired.add(child.getName());

src/main/java/edu/harvard/iq/dataverse/MetadataBlock.java

@@ -102,8 +102,8 @@ public void setDatasetFieldTypes(List<DatasetFieldType> datasetFieldTypes) {
 
     public boolean isDisplayOnCreate() {
         for (DatasetFieldType dsfType : datasetFieldTypes) {
-            Boolean displayOnCreate = dsfType.isDisplayOnCreate();
-            if (displayOnCreate != null && displayOnCreate) {
+            boolean shouldDisplayOnCreate = dsfType.shouldDisplayOnCreate();
+            if (shouldDisplayOnCreate) {
                 return true;
             }
         }

src/main/java/edu/harvard/iq/dataverse/MetadataBlockServiceBean.java

@@ -80,13 +80,22 @@ public List<MetadataBlock> listMetadataBlocksDisplayedOnCreate(Dataverse ownerDa
                 datasetFieldTypeInputLevelJoin.get("datasetFieldType").in(metadataBlockRoot.get("datasetFieldTypes")),
                 criteriaBuilder.isTrue(datasetFieldTypeInputLevelJoin.get("required")));
 
-            // Predicate for default displayOnCreate (when there is no input level)
-            Predicate defaultDisplayOnCreatePredicate = criteriaBuilder.and(
-                criteriaBuilder.not(criteriaBuilder.exists(inputLevelSubquery)),
-                criteriaBuilder.or(
-                    criteriaBuilder.isTrue(datasetFieldTypeJoin.get("displayOnCreate")),
+            // Predicate for default displayOnCreate (when there is no input level or when input level exists but doesn't have displayOnCreate set)
+            Predicate defaultDisplayOnCreatePredicate = criteriaBuilder.or(
+                // Case 1: No input level and required is true
+                criteriaBuilder.and(
+                    criteriaBuilder.not(criteriaBuilder.exists(inputLevelSubquery)),
                     criteriaBuilder.isTrue(datasetFieldTypeJoin.get("required"))
-                ));
+                ),
+                // Case 2: (No input level OR input level exists but displayOnCreate is null) AND displayOnCreate is true in datasetFieldType
+                criteriaBuilder.and(
+                    criteriaBuilder.or(
+                        criteriaBuilder.not(criteriaBuilder.exists(inputLevelSubquery)),
+                        criteriaBuilder.isNull(datasetFieldTypeInputLevelJoin.get("displayOnCreate"))
+                    ),
+                    criteriaBuilder.isTrue(datasetFieldTypeJoin.get("displayOnCreate"))
+                )
+            );
 
             Predicate unionPredicate = criteriaBuilder.or(
                 displayOnCreateInputLevelPredicate,
@@ -113,7 +122,8 @@ public List<MetadataBlock> listMetadataBlocksDisplayedOnCreate(Dataverse ownerDa
             criteriaQuery.where(linkedFieldsPredicate);
         }
 
-        criteriaQuery.select(metadataBlockRoot).distinct(true);
+        criteriaQuery.select(metadataBlockRoot).distinct(true)
+                .orderBy(criteriaBuilder.desc(metadataBlockRoot.get("id")));
         return em.createQuery(criteriaQuery).getResultList();
     }
 }

src/main/java/edu/harvard/iq/dataverse/TemplatePage.java

@@ -172,10 +172,9 @@ private void updateDatasetFieldInputLevels(){
            );
            if (dsfIl != null) {
                dsf.setInclude(dsfIl.isInclude());
-               dsf.getDatasetFieldType().setDisplayOnCreate(dsfIl.isDisplayOnCreate());
+               dsf.getDatasetFieldType().setLocalDisplayOnCreate(dsfIl.getDisplayOnCreate());
            } else {
                dsf.setInclude(true);
-               dsf.getDatasetFieldType().setDisplayOnCreate(false);
            } 
         }
     }

src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java

@@ -803,7 +803,10 @@ private List<DataverseFieldTypeInputLevel> parseInputLevels(JsonArray inputLevel
 
             boolean required = inputLevel.getBoolean("required");
             boolean include = inputLevel.getBoolean("include");
-            boolean displayOnCreate = inputLevel.getBoolean("displayOnCreate", false);
+            Boolean displayOnCreate = null;
+            if(inputLevel.containsKey("displayOnCreate")) {
+                displayOnCreate = inputLevel.getBoolean("displayOnCreate", false);
+            }
 
             if (required && !include) {
                 String errorMessage = MessageFormat.format(BundleUtil.getStringFromBundle("dataverse.inputlevels.error.cannotberequiredifnotincluded"), datasetFieldTypeName);

src/main/java/edu/harvard/iq/dataverse/util/json/BriefJsonPrinter.java

@@ -25,10 +25,10 @@ public JsonObjectBuilder json( DatasetVersion dsv ) {
 
     public JsonObjectBuilder json( MetadataBlock blk ) {
         if (blk == null) return null;
-        Boolean displayOnCreate = blk.isDisplayOnCreate();
+        boolean displayOnCreate = blk.isDisplayOnCreate();
         return jsonObjectBuilder().add("id", blk.getId())
                     .add("displayName", blk.getDisplayName())
-                    .add("displayOnCreate", displayOnCreate == null ? false : displayOnCreate)
+                    .add("displayOnCreate", displayOnCreate)
                     .add("name", blk.getName())
                     ;
     }