Copy index order with ModelItems

mdm-core/grails-app/utils/uk/ac/ox/softeng/maurodatamapper/core/rest/transport/model/CopyInformation.groovy

@@ -26,6 +26,7 @@ import groovy.util.logging.Slf4j
 class CopyInformation implements Validateable {
 
     String copyLabel
+    boolean copyIndex = false
 
     Map<String, TreeMap<UUID, List<MultiFacetItemAware>>> preloadedFacets = [:]
 

mdm-core/src/main/groovy/uk/ac/ox/softeng/maurodatamapper/core/model/ModelItemService.groovy

@@ -20,6 +20,8 @@ package uk.ac.ox.softeng.maurodatamapper.core.model
 import uk.ac.ox.softeng.maurodatamapper.api.exception.ApiNotYetImplementedException
 import uk.ac.ox.softeng.maurodatamapper.core.container.Classifier
 import uk.ac.ox.softeng.maurodatamapper.core.facet.Metadata
+import uk.ac.ox.softeng.maurodatamapper.core.rest.transport.model.CopyInformation
+import uk.ac.ox.softeng.maurodatamapper.security.User
 import uk.ac.ox.softeng.maurodatamapper.security.UserSecurityPolicyManager
 import uk.ac.ox.softeng.maurodatamapper.util.Utils
 
@@ -50,6 +52,15 @@ abstract class ModelItemService<K extends ModelItem> extends CatalogueItemServic
         throw new ApiNotYetImplementedException('MIS03', "copy [for ModelItem ${getDomainClass().simpleName}]")
     }
 
+    K copyModelItemInformation(K original, K copy, User copier, UserSecurityPolicyManager userSecurityPolicyManager,
+                               CopyInformation copyInformation = null) {
+        copy = super.copyCatalogueItemInformation(original, copy, copier, userSecurityPolicyManager, copyInformation)
+        if (copyInformation?.copyIndex) {
+            copy.idx = original.idx
+        }
+        copy
+    }
+
     boolean isModelItemInSameModelOrInFinalisedModel(K modelItem, K otherModelItem) {
         otherModelItem.model.id == modelItem.model.id || modelItem.model.finalised
     }

mdm-core/src/main/groovy/uk/ac/ox/softeng/maurodatamapper/core/traits/domain/IndexedSiblingAware.groovy

@@ -123,7 +123,7 @@ trait IndexedSiblingAware {
             if (mi.hasChanged('idx') && mi.id) {
                 mi.save(flush: false, validate: false)
             }
-            log.trace('After >> EV {} has idx {} (Dirty: {})', mi.label, mi.idx, mi.isDirty())
+            log.trace('After >> MI {} has idx {} (Dirty: {})', mi.label, mi.idx, mi.isDirty())
         }
     }
 

mdm-plugin-datamodel/grails-app/services/uk/ac/ox/softeng/maurodatamapper/datamodel/DataModelService.groovy

@@ -735,16 +735,16 @@ class DataModelService extends ModelService<DataModel> implements SummaryMetadat
 
         List<DataType> dataTypes = DataType.byDataModelId(original.id).join('classifiers').list()
         List<DataClass> rootDataClasses = DataClass.byRootDataClassOfDataModelId(original.id).join('classifiers').list()
-        CopyInformation dataClassCache = cacheFacetInformationForCopy(rootDataClasses.collect {it.id})
-        CopyInformation dataTypeCache = cacheFacetInformationForCopy(dataTypes.collect {it.id})
+        CopyInformation dataClassCache = cacheFacetInformationForCopy(rootDataClasses.collect {it.id}, new CopyInformation(copyIndex: true))
+        CopyInformation dataTypeCache = cacheFacetInformationForCopy(dataTypes.collect {it.id}, new CopyInformation(copyIndex: true))
 
         // Copy all the datatypes
-        dataTypes.each {dt ->
+        dataTypes.sort().each {dt ->
             dataTypeService.copyDataType(copy, dt, copier, userSecurityPolicyManager, copySummaryMetadata, dataTypeCache)
         }
 
         // Copy all the dataclasses (this will also match up the reference types)
-        rootDataClasses.each {dc ->
+        rootDataClasses.sort().each {dc ->
             dataClassService.copyDataClass(copy, dc, copier, userSecurityPolicyManager, null, copySummaryMetadata, dataClassCache)
         }
         log.debug('Copy of datamodel took {}', Utils.timeTaken(start))

mdm-plugin-datamodel/grails-app/services/uk/ac/ox/softeng/maurodatamapper/datamodel/item/DataElementService.groovy

@@ -380,7 +380,7 @@ WHERE (de.dataClass.id = :dataClassId OR idc.id = :dataClassId)''', 'de', filter
         DataElement copy = new DataElement(minMultiplicity: original.minMultiplicity,
                                            maxMultiplicity: original.maxMultiplicity)
 
-        copy = copyCatalogueItemInformation(original, copy, copier, userSecurityPolicyManager, copySummaryMetadata, copyInformation)
+        copy = copyModelItemInformation(original, copy, copier, userSecurityPolicyManager, copySummaryMetadata, copyInformation)
         setCatalogueItemRefinesCatalogueItem(copy, original, copier)
 
         DataType dataType = copiedDataModel.findDataTypeByLabel(original.dataType.label)
@@ -396,26 +396,26 @@ WHERE (de.dataClass.id = :dataClassId OR idc.id = :dataClassId)''', 'de', filter
         copy
     }
 
-    DataElement copyCatalogueItemInformation(DataElement original,
+    DataElement copyModelItemInformation(DataElement original,
                                              DataElement copy,
                                              User copier,
                                              UserSecurityPolicyManager userSecurityPolicyManager,
                                              boolean copySummaryMetadata,
                                              CopyInformation copyInformation) {
-        copy = super.copyCatalogueItemInformation(original, copy, copier, userSecurityPolicyManager, copyInformation)
+        copy = super.copyModelItemInformation(original, copy, copier, userSecurityPolicyManager, copyInformation)
         if (copySummaryMetadata) {
             copySummaryMetadataFromOriginal(original, copy, copier, copyInformation)
         }
         copy
     }
 
     @Override
-    DataElement copyCatalogueItemInformation(DataElement original,
+    DataElement copyModelItemInformation(DataElement original,
                                              DataElement copy,
                                              User copier,
                                              UserSecurityPolicyManager userSecurityPolicyManager,
                                              CopyInformation copyInformation) {
-        copyCatalogueItemInformation(original, copy, copier, userSecurityPolicyManager, false, copyInformation)
+        copyModelItemInformation(original, copy, copier, userSecurityPolicyManager, false, copyInformation)
     }
 
     DataElementSimilarityResult findAllSimilarDataElementsInDataModel(DataModel dataModelToSearch, DataElement dataElementToCompare, maxResults = 5) {

mdm-plugin-datamodel/grails-app/services/uk/ac/ox/softeng/maurodatamapper/datamodel/item/datatype/DataTypeService.groovy

@@ -97,7 +97,7 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
         dataType.breadcrumbTree.removeFromParent()
 
         List<DataElement> dataElements = dataElementService.findAllByDataType(dataType)
-        dataElements.each { dataElementService.delete(it) }
+        dataElements.each {dataElementService.delete(it)}
 
         switch (dataType.domainType) {
             case DataType.PRIMITIVE_DOMAIN_TYPE:
@@ -189,13 +189,13 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
             enumerationTypeService.propagateContentsInformation(catalogueItem as EnumerationType, previousVersionCatalogueItem as EnumerationType)
         }
 
-        previousVersionCatalogueItem.summaryMetadata.each { previousSummaryMetadata ->
-            if (catalogueItem.summaryMetadata.any { it.label == previousSummaryMetadata.label }) return
+        previousVersionCatalogueItem.summaryMetadata.each {previousSummaryMetadata ->
+            if (catalogueItem.summaryMetadata.any {it.label == previousSummaryMetadata.label}) return
             SummaryMetadata summaryMetadata = new SummaryMetadata(label: previousSummaryMetadata.label,
                                                                   description: previousSummaryMetadata.description,
                                                                   summaryMetadataType: previousSummaryMetadata.summaryMetadataType)
 
-            previousSummaryMetadata.summaryMetadataReports.each { previousSummaryMetadataReport ->
+            previousSummaryMetadata.summaryMetadataReports.each {previousSummaryMetadataReport ->
                 summaryMetadata.addToSummaryMetadataReports(reportDate: previousSummaryMetadataReport.reportDate,
                                                             reportValue: previousSummaryMetadataReport.reportValue,
                                                             createdBy: previousSummaryMetadataReport.createdBy
@@ -234,7 +234,7 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
             new PrimitiveType(label: 'Timestamp', description: 'A timestamp'),
             new PrimitiveType(label: 'Boolean', description: 'A true or false value'),
             new PrimitiveType(label: 'Duration', description: 'A time period in arbitrary units')
-        ].collect { new DefaultDataType(it) }
+        ].collect {new DefaultDataType(it)}
     }
 
     @Override
@@ -273,7 +273,7 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
         super.checkBreadcrumbTreeAfterSavingCatalogueItem(dataType)
 
         if (dataType.instanceOf(EnumerationType)) {
-            dataType.enumerationValues.each { enumerationValue ->
+            dataType.enumerationValues.each {enumerationValue ->
                 super.checkBreadcrumbTreeAfterSavingCatalogueItem(enumerationValue)
             }
         }
@@ -282,16 +282,16 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
     @Override
     void checkBreadcrumbTreeAfterSavingCatalogueItems(Collection<DataType> dataTypes) {
         super.checkBreadcrumbTreeAfterSavingCatalogueItems(dataTypes)
-        super.checkBreadcrumbTreeAfterSavingCatalogueItems(dataTypes.findAll{it.instanceOf(EnumerationType)}.collectMany {it.enumerationValues})
+        super.checkBreadcrumbTreeAfterSavingCatalogueItems(dataTypes.findAll {it.instanceOf(EnumerationType)}.collectMany {it.enumerationValues})
     }
 
     @Override
     DataType checkFacetsAfterImportingCatalogueItem(DataType catalogueItem) {
         if (catalogueItem.summaryMetadata) {
-            catalogueItem.summaryMetadata.each { sm ->
+            catalogueItem.summaryMetadata.each {sm ->
                 sm.multiFacetAwareItemId = catalogueItem.id
                 sm.createdBy = sm.createdBy ?: catalogueItem.createdBy
-                sm.summaryMetadataReports.each { smr ->
+                sm.summaryMetadataReports.each {smr ->
                     smr.createdBy = catalogueItem.createdBy
                 }
             }
@@ -314,7 +314,7 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
         if (dataType.instanceOf(EnumerationType)) {
             EnumerationType enumerationType = (dataType as EnumerationType)
             enumerationType.fullSortOfChildren(enumerationType.enumerationValues)
-            enumerationType.enumerationValues.each { ev ->
+            enumerationType.enumerationValues.each {ev ->
                 ev.createdBy = importingUser.emailAddress
                 ev.checkPath()
             }
@@ -339,8 +339,8 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
     }
 
     void matchReferenceClasses(DataModel dataModel, Collection<ReferenceType> referenceTypes, Collection<Map> bindingMaps = []) {
-        referenceTypes.sort { it.label }.each { rdt ->
-            Map dataTypeBindingMap = bindingMaps.find { it.label == rdt.label } ?: [:]
+        referenceTypes.sort {it.label}.each {rdt ->
+            Map dataTypeBindingMap = bindingMaps.find {it.label == rdt.label} ?: [:]
             Map refClassBindingMap = dataTypeBindingMap.referenceClass ?: [:]
             matchReferenceClass(dataModel, rdt, refClassBindingMap)
         }
@@ -359,7 +359,7 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
             else {
                 log.
                     trace('No referenceClass could be found to match label tree for {}, attempting no label tree', referenceType.referenceClass.label)
-                def possibles = dataModel.dataClasses.findAll { it.label == referenceType.referenceClass.label }
+                def possibles = dataModel.dataClasses.findAll {it.label == referenceType.referenceClass.label}
                 if (possibles.size() == 1) {
                     log.trace('Single possible referenceClass found, safely using')
                     possibles.first().addToReferenceTypes(referenceType)
@@ -373,7 +373,7 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
             }
         } else {
             log.trace('Making best guess for matching reference class as no path nor bound class')
-            DataClass dataClass = dataModel.dataClasses.find { it.label == bindingMap.referenceClass.label }
+            DataClass dataClass = dataModel.dataClasses.find {it.label == bindingMap.referenceClass.label}
             if (dataClass) dataClass.addToReferenceTypes(referenceType)
         }
     }
@@ -386,17 +386,17 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
     DataType copyDataType(DataModel copiedDataModel, DataType original, User copier, UserSecurityPolicyManager userSecurityPolicyManager,
                           boolean copySummaryMetadata = false, CopyInformation copyInformation = new CopyInformation()) {
 
-        DataType copy = createNewDataTypeFromOriginal(original)
+        DataType copy = createNewDataTypeFromOriginal(copiedDataModel, original, userSecurityPolicyManager)
 
-        copy = copyCatalogueItemInformation(original, copy, copier, userSecurityPolicyManager, copySummaryMetadata, copyInformation)
+        copy = copyModelItemInformation(original, copy, copier, userSecurityPolicyManager, copySummaryMetadata, copyInformation)
         setCatalogueItemRefinesCatalogueItem(copy, original, copier)
 
         copiedDataModel.addToDataTypes(copy)
 
         copy
     }
 
-    DataType createNewDataTypeFromOriginal(DataType original) {
+    DataType createNewDataTypeFromOriginal(DataModel copiedDataModel, DataType original, UserSecurityPolicyManager userSecurityPolicyManager) {
         DataType copy
 
         String domainType = original.domainType
@@ -406,8 +406,10 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
                 break
             case DataType.ENUMERATION_DOMAIN_TYPE:
                 copy = new EnumerationType()
-                original.enumerationValues.each { ev ->
-                    copy.addToEnumerationValues(key: ev.key, value: ev.value, category: ev.category)
+                CopyInformation copyInformation = new CopyInformation(copyIndex: true)
+                original.enumerationValues.sort().each {ev ->
+                    copy.addToEnumerationValues(
+                        enumerationValueService.copyEnumerationValue(copiedDataModel, ev, copy, userSecurityPolicyManager.user, userSecurityPolicyManager, copyInformation))
                 }
                 break
             case DataType.REFERENCE_DOMAIN_TYPE:
@@ -424,25 +426,25 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
         copy
     }
 
-    DataType copyCatalogueItemInformation(DataType original,
-                                          DataType copy,
-                                          User copier,
-                                          UserSecurityPolicyManager userSecurityPolicyManager,
-                                          boolean copySummaryMetadata,
-                                          copyInformation) {
-        copy = super.copyCatalogueItemInformation(original, copy, copier, userSecurityPolicyManager, copyInformation)
+    DataType copyModelItemInformation(DataType original,
+                                      DataType copy,
+                                      User copier,
+                                      UserSecurityPolicyManager userSecurityPolicyManager,
+                                      boolean copySummaryMetadata,
+                                      copyInformation) {
+        copy = super.copyModelItemInformation(original, copy, copier, userSecurityPolicyManager, copyInformation)
         if (copySummaryMetadata) {
             copy = copySummaryMetadataFromOriginal(original, copy, copier, copyInformation)
         }
         copy
     }
 
     @Override
-    DataType copyCatalogueItemInformation(DataType original,
-                                          DataType copy,
-                                          User copier,
-                                          UserSecurityPolicyManager userSecurityPolicyManager, CopyInformation copyInformation) {
-        copyCatalogueItemInformation(original, copy, copier, userSecurityPolicyManager, false, copyInformation)
+    DataType copyModelItemInformation(DataType original,
+                                      DataType copy,
+                                      User copier,
+                                      UserSecurityPolicyManager userSecurityPolicyManager, CopyInformation copyInformation) {
+        copyModelItemInformation(original, copy, copier, userSecurityPolicyManager, false, copyInformation)
     }
 
     DataModel addDefaultListOfDataTypesToDataModel(DataModel dataModel, List<DefaultDataType> defaultDataTypes) {
@@ -479,7 +481,7 @@ class DataTypeService extends ModelItemService<DataType> implements DefaultDataT
     }
 
     void mergeDataTypes(DataType keep, DataType replace) {
-        replace.dataElements?.each { de ->
+        replace.dataElements?.each {de ->
             keep.addToDataElements(de)
         }
         List<Metadata> mds = []

mdm-plugin-datamodel/grails-app/services/uk/ac/ox/softeng/maurodatamapper/datamodel/item/datatype/enumeration/EnumerationValueService.groovy

@@ -21,6 +21,7 @@ import uk.ac.ox.softeng.maurodatamapper.core.container.Classifier
 import uk.ac.ox.softeng.maurodatamapper.core.model.CatalogueItem
 import uk.ac.ox.softeng.maurodatamapper.core.model.Model
 import uk.ac.ox.softeng.maurodatamapper.core.model.ModelItemService
+import uk.ac.ox.softeng.maurodatamapper.core.rest.transport.model.CopyInformation
 import uk.ac.ox.softeng.maurodatamapper.datamodel.DataModel
 import uk.ac.ox.softeng.maurodatamapper.datamodel.DataModelService
 import uk.ac.ox.softeng.maurodatamapper.datamodel.facet.SummaryMetadataService
@@ -181,18 +182,15 @@ class EnumerationValueService extends ModelItemService<EnumerationValue> impleme
     }
 
     EnumerationValue copyEnumerationValue(DataModel copiedDataModel, EnumerationValue original, EnumerationType enumerationTypeToCopyInto,
-                                          User copier,
-                                          UserSecurityPolicyManager userSecurityPolicyManager) {
-        EnumerationValue copy = new EnumerationValue(key: original.key,
-                                                     value: original.value)
+                                          User copier, UserSecurityPolicyManager userSecurityPolicyManager, CopyInformation copyInformation = null) {
+        EnumerationValue copy = new EnumerationValue(key: original.key, value: original.value, category: original.category)
 
-        copy = copyCatalogueItemInformation(original, copy, copier, userSecurityPolicyManager)
+        copy = copyModelItemInformation(original, copy, copier, userSecurityPolicyManager, copyInformation)
         setCatalogueItemRefinesCatalogueItem(copy, original, copier)
 
         EnumerationType enumerationType = enumerationTypeToCopyInto ?: copiedDataModel.findEnumerationTypeByLabel(original.enumerationType.label)
         enumerationType.addToEnumerationValues(copy)
         copy
-
     }
 
     List<EnumerationValue> findAllByDataModelId(Serializable dataModelId) {