Merge branch 'release/4.5.0' into main

gradle.properties

@@ -1,5 +1,5 @@
 # Core Info
-version=4.4.1
+version=4.5.0
 group=uk.ac.ox.softeng.maurodatamapper
 # Gradle
 gradleVersion=6.7.1

mdm-common/src/main/groovy/uk/ac/ox/softeng/maurodatamapper/util/Utils.groovy

@@ -84,7 +84,7 @@ class Utils {
         }
     }
 
-    static boolean parentClassIsAssignableFromChild(Class parentClass, Class childClass) {
+    static boolean parentClassIsAssignableFromChild(Class<? extends Object> parentClass, Class<? extends Object> childClass) {
         childClass.classLoader.loadClass(parentClass.name).isAssignableFrom(childClass)
     }
 

mdm-core/grails-app/conf/db/migration/core/V2_8_0__rename_catalogue_item_to_multi_facet.sql

@@ -0,0 +1,33 @@
+ALTER TABLE core.annotation
+    RENAME COLUMN catalogue_item_domain_type TO multi_facet_aware_item_domain_type;
+ALTER TABLE core.annotation
+    RENAME COLUMN catalogue_item_id TO multi_facet_aware_item_id;
+
+ALTER TABLE core.metadata
+    RENAME COLUMN catalogue_item_domain_type TO multi_facet_aware_item_domain_type;
+ALTER TABLE core.metadata
+    RENAME COLUMN catalogue_item_id TO multi_facet_aware_item_id;
+
+ALTER TABLE core.reference_file
+    RENAME COLUMN catalogue_item_domain_type TO multi_facet_aware_item_domain_type;
+ALTER TABLE core.reference_file
+    RENAME COLUMN catalogue_item_id TO multi_facet_aware_item_id;
+
+ALTER TABLE core.rule
+    RENAME COLUMN catalogue_item_domain_type TO multi_facet_aware_item_domain_type;
+ALTER TABLE core.rule
+    RENAME COLUMN catalogue_item_id TO multi_facet_aware_item_id;
+
+ALTER TABLE core.semantic_link
+    RENAME COLUMN catalogue_item_domain_type TO multi_facet_aware_item_domain_type;
+ALTER TABLE core.semantic_link
+    RENAME COLUMN catalogue_item_id TO multi_facet_aware_item_id;
+ALTER TABLE core.semantic_link
+    RENAME COLUMN target_catalogue_item_domain_type TO target_multi_facet_aware_item_domain_type;
+ALTER TABLE core.semantic_link
+    RENAME COLUMN target_catalogue_item_id TO target_multi_facet_aware_item_id;
+
+ALTER TABLE core.version_link
+    RENAME COLUMN catalogue_item_domain_type TO multi_facet_aware_item_domain_type;
+ALTER TABLE core.version_link
+    RENAME COLUMN catalogue_item_id TO multi_facet_aware_item_id;

mdm-core/grails-app/conf/db/migration/core/V2_8_1__containers_add_facets.sql

@@ -0,0 +1,44 @@
+CREATE TABLE core.join_classifier_to_facet (
+    classifier_id     UUID NOT NULL,
+    annotation_id     UUID,
+    rule_id           UUID,
+    semantic_link_id  UUID,
+    reference_file_id UUID,
+    metadata_id       UUID
+);
+
+CREATE TABLE core.join_folder_to_facet (
+    folder_id         UUID NOT NULL,
+    annotation_id     UUID,
+    rule_id           UUID,
+    semantic_link_id  UUID,
+    reference_file_id UUID,
+    metadata_id       UUID
+);
+
+ALTER TABLE IF EXISTS core.join_classifier_to_facet
+    ADD CONSTRAINT FK3h1hax9omk9o62119jsc45m35 FOREIGN KEY (annotation_id) REFERENCES core.annotation;
+ALTER TABLE IF EXISTS core.join_classifier_to_facet
+    ADD CONSTRAINT FK54j6lhkhnneag9rqsnchk9rwf FOREIGN KEY (classifier_id) REFERENCES core.classifier;
+ALTER TABLE IF EXISTS core.join_classifier_to_facet
+    ADD CONSTRAINT FK1yihq7q1hhwm3f7jn4g7isg5k FOREIGN KEY (rule_id) REFERENCES core.rule;
+ALTER TABLE IF EXISTS core.join_classifier_to_facet
+    ADD CONSTRAINT FKs9xsugq08k5ejrfha2540ups0 FOREIGN KEY (semantic_link_id) REFERENCES core.semantic_link;
+ALTER TABLE IF EXISTS core.join_classifier_to_facet
+    ADD CONSTRAINT FK5owmrlff8c3f3bf2e7om5xkfj FOREIGN KEY (reference_file_id) REFERENCES core.reference_file;
+ALTER TABLE IF EXISTS core.join_classifier_to_facet
+    ADD CONSTRAINT FK6531dcod746lwh2v7k4fatx7b FOREIGN KEY (metadata_id) REFERENCES core.metadata;
+
+
+ALTER TABLE IF EXISTS core.join_folder_to_facet
+    ADD CONSTRAINT FKohkkmadsw0xtk5qs2mx0y0npo FOREIGN KEY (annotation_id) REFERENCES core.annotation;
+ALTER TABLE IF EXISTS core.join_folder_to_facet
+    ADD CONSTRAINT FKibq4i08l0b0nkbopm8wjrdfd9 FOREIGN KEY (folder_id) REFERENCES core.folder;
+ALTER TABLE IF EXISTS core.join_folder_to_facet
+    ADD CONSTRAINT FKml4kb6cf0wr79sopbu6fglets FOREIGN KEY (rule_id) REFERENCES core.rule;
+ALTER TABLE IF EXISTS core.join_folder_to_facet
+    ADD CONSTRAINT FKsuj7eo7stfn56f1b0ci16uqc4 FOREIGN KEY (semantic_link_id) REFERENCES core.semantic_link;
+ALTER TABLE IF EXISTS core.join_folder_to_facet
+    ADD CONSTRAINT FK6bgvwj5n9a92tkoky84uaktlm FOREIGN KEY (reference_file_id) REFERENCES core.reference_file;
+ALTER TABLE IF EXISTS core.join_folder_to_facet
+    ADD CONSTRAINT FK14o06qtiem74ycw6896javux7 FOREIGN KEY (metadata_id) REFERENCES core.metadata;

mdm-core/grails-app/conf/db/migration/core/V2_8_2__remove_model_import_export.sql

@@ -0,0 +1,18 @@
+DO
+$$
+    DECLARE
+        datamodel_schema_exists BOOLEAN := (SELECT TO_REGCLASS('datamodel.flyway_schema_history') IS NOT NULL);
+
+    BEGIN
+        -- If no datamodel schema then we can drop the tables at this point
+        -- If datamodel schema then we will need to affect these changes in the datamodel migration
+        IF datamodel_schema_exists = FALSE
+        THEN
+            DROP TABLE core.model_extend CASCADE;
+            DROP TABLE core.model_import CASCADE;
+        END IF;
+
+
+    END;
+$$;
+;

mdm-core/grails-app/conf/db/migration/core/V2_9_0__add_version_links_to_versioned_folder.sql

@@ -0,0 +1,8 @@
+CREATE TABLE core.join_versionedfolder_to_facet (
+    versionedfolder_id UUID NOT NULL,
+    version_link_id    UUID
+);
+ALTER TABLE IF EXISTS core.join_versionedfolder_to_facet
+    ADD CONSTRAINT FKcdu99gvtth7g6q2glm329u7uu FOREIGN KEY (version_link_id) REFERENCES core.version_link;
+ALTER TABLE IF EXISTS core.join_versionedfolder_to_facet
+    ADD CONSTRAINT FKsltt9c209xswibf8ocho4l8ly FOREIGN KEY (versionedfolder_id) REFERENCES core.folder;

mdm-core/grails-app/controllers/uk/ac/ox/softeng/maurodatamapper/core/UrlMappings.groovy

@@ -91,6 +91,11 @@ class UrlMappings {
                 '/folders'(resources: 'folder', excludes: DEFAULT_EXCLUDES)
                 '/versionedFolders'(resources: 'versionedFolder', excludes: DEFAULT_EXCLUDES)
 
+                put '/finalise'(controller: 'versionedFolder', action: 'finalise')
+                put '/newBranchModelVersion'(controller: 'versionedFolder', action: 'newBranchModelVersion')
+                put '/newDocumentationVersion'(controller: 'versionedFolder', action: 'newDocumentationVersion')
+                put '/newForkModel'(controller: 'versionedFolder', action: 'newForkModel')
+
                 put '/readByEveryone'(controller: 'versionedFolder', action: 'readByEveryone')
                 delete '/readByEveryone'(controller: 'versionedFolder', action: 'readByEveryone')
                 put '/readByAuthenticated'(controller: 'versionedFolder', action: 'readByAuthenticated')
@@ -149,24 +154,52 @@ class UrlMappings {
                 }
 
                 /*
-                Model Imports
+                Reference Files
                  */
-                '/modelImports'(resources: 'modelImport', excludes: DEFAULT_EXCLUDES_AND_NO_UPDATE)
+                '/referenceFiles'(resources: 'referenceFile', excludes: DEFAULT_EXCLUDES)
 
                 /*
-                Model Extends
+                Get Catalogue Item by path where is ID of top Catalogue Item is provided
                  */
-                '/modelExtends'(resources: 'modelExtend', excludes: DEFAULT_EXCLUDES_AND_NO_UPDATE)
+                get "/path/$path"(controller: 'path', action: 'show')
 
                 /*
-                Reference Files
+                Rules
+                */
+                '/rules'(resources: 'rule', excludes: DEFAULT_EXCLUDES) {
+                    '/representations'(resources: 'ruleRepresentation', excludes: DEFAULT_EXCLUDES)
+                }
+            }
+
+            /*
+         Container accessible resources
+          All new URLs
+           */
+            group "/$containerDomainType/$containerId", {
+
+                /*
+                Metadata
+                */
+                '/metadata'(resources: 'metadata', excludes: DEFAULT_EXCLUDES)
+
+                /*
+                Annotations
                  */
-                '/referenceFiles'(resources: 'referenceFile', excludes: DEFAULT_EXCLUDES)
+                '/annotations'(resources: 'annotation', excludes: DEFAULT_EXCLUDES_AND_NO_UPDATE) {
+                    '/annotations'(resources: 'annotation', excludes: DEFAULT_EXCLUDES_AND_NO_UPDATE)
+                }
 
                 /*
-                Get Catalogue Item by path where is ID of top Catalogue Item is provided
+                Semantic Links
                  */
-                get "/path/$path"(controller: 'path', action: 'show')
+                '/semanticLinks'(resources: 'semanticLink', excludes: DEFAULT_EXCLUDES) {
+                    put '/confirm'(controller: 'semanticLink', action: 'confirm')
+                }
+
+                /*
+                Reference Files
+                 */
+                '/referenceFiles'(resources: 'referenceFile', excludes: DEFAULT_EXCLUDES)
 
                 /*
                 Rules

mdm-core/grails-app/controllers/uk/ac/ox/softeng/maurodatamapper/core/admin/ApiPropertyController.groovy

@@ -43,6 +43,13 @@ class ApiPropertyController extends EditLoggingController<ApiProperty> {
         respond res, [model: [userSecurityPolicyManager: currentUserSecurityPolicyManager], view: 'index']
     }
 
+    @Override
+    protected ApiProperty saveResource(ApiProperty resource) {
+        ApiProperty apiProperty = super.saveResource(resource)
+        apiPropertyService.updateLinkGeneratorWithSiteUrl(apiProperty)
+        apiProperty
+    }
+
     @Override
     protected void serviceDeleteResource(ApiProperty resource) {
         apiPropertyService.delete(resource)

mdm-core/grails-app/controllers/uk/ac/ox/softeng/maurodatamapper/core/container/VersionedFolderController.groovy

@@ -19,15 +19,22 @@ package uk.ac.ox.softeng.maurodatamapper.core.container
 
 import uk.ac.ox.softeng.maurodatamapper.core.authority.AuthorityService
 import uk.ac.ox.softeng.maurodatamapper.core.controller.EditLoggingController
+import uk.ac.ox.softeng.maurodatamapper.core.gorm.constraint.callable.VersionAwareConstraints
 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.ModelService
+import uk.ac.ox.softeng.maurodatamapper.core.rest.transport.model.CreateNewVersionData
+import uk.ac.ox.softeng.maurodatamapper.core.rest.transport.model.FinaliseData
 import uk.ac.ox.softeng.maurodatamapper.core.rest.transport.search.SearchParams
 import uk.ac.ox.softeng.maurodatamapper.core.search.SearchService
 import uk.ac.ox.softeng.maurodatamapper.search.PaginatedLuceneResult
+import uk.ac.ox.softeng.maurodatamapper.security.SecurableResource
 import uk.ac.ox.softeng.maurodatamapper.security.SecurityPolicyManagerService
 
 import grails.gorm.transactions.Transactional
 import org.springframework.beans.factory.annotation.Autowired
 
+import static org.springframework.http.HttpStatus.METHOD_NOT_ALLOWED
 import static org.springframework.http.HttpStatus.NO_CONTENT
 
 class VersionedFolderController extends EditLoggingController<VersionedFolder> {
@@ -38,6 +45,9 @@ class VersionedFolderController extends EditLoggingController<VersionedFolder> {
     VersionedFolderService versionedFolderService
     SearchService mdmCoreSearchService
 
+    @Autowired(required = false)
+    List<ModelService> modelServices
+
     @Autowired(required = false)
     SecurityPolicyManagerService securityPolicyManagerService
 
@@ -122,6 +132,118 @@ class VersionedFolderController extends EditLoggingController<VersionedFolder> {
         updateResponse(instance)
     }
 
+    @Transactional
+    def finalise(FinaliseData finaliseData) {
+
+        if (!finaliseData.validate()) {
+            respond finaliseData.errors
+            return
+        }
+
+        VersionedFolder instance = queryForResource(params.versionedFolderId)
+
+        if (!instance) return notFound(params.versionedFolderId)
+
+        if (instance.branchName != VersionAwareConstraints.DEFAULT_BRANCH_NAME) return METHOD_NOT_ALLOWED
+
+        instance = versionedFolderService.finaliseFolder(instance, currentUser,
+                                                         finaliseData.version,
+                                                         finaliseData.versionChangeType,
+                                                         finaliseData.getVersionTag())
+
+        if (!validateResource(instance, 'update')) return
+
+        if (finaliseData.changeNotice) {
+            instance.addChangeNoticeEdit(currentUser, finaliseData.changeNotice)
+        }
+
+        Set<String> changedProperties = instance.getDirtyPropertyNames()
+
+        updateResource(instance)
+        updateSecurity(instance, changedProperties)
+        updateResponse(instance)
+    }
+
+    @Transactional
+    def newBranchModelVersion(CreateNewVersionData createNewVersionData) {
+
+        createNewVersionData.label = 'newBranchModelVersion'
+
+        if (!createNewVersionData.validate()) {
+            respond createNewVersionData.errors
+            return
+        }
+
+        VersionedFolder instance = queryForResource(params.versionedFolderId)
+
+        if (!instance) return notFound(params.versionedFolderId)
+
+        VersionedFolder copy = versionedFolderService.createNewBranchModelVersion(createNewVersionData.branchName, instance, currentUser,
+                                                                                  createNewVersionData.copyPermissions,
+                                                                                  currentUserSecurityPolicyManager)
+
+        if (!validateResource(copy, 'create')) return
+
+        saveResource(copy)
+
+        saveResponse(copy)
+    }
+
+    @Transactional
+    def newForkModel(CreateNewVersionData createNewVersionData) {
+
+        if (createNewVersionData.hasErrors()) {
+            respond createNewVersionData.errors
+            return
+        }
+
+        VersionedFolder instance = queryForResource(params.versionedFolderId)
+
+        if (!instance) return notFound(params.versionedFolderId)
+
+        if (!currentUserSecurityPolicyManager.userCanCreateSecuredResourceId(resource, params.versionedFolderId)) {
+            createNewVersionData.copyPermissions = false
+        }
+
+        VersionedFolder copy = versionedFolderService.createNewForkModel(createNewVersionData.label,
+                                                                         instance,
+                                                                         currentUser,
+                                                                         createNewVersionData.copyPermissions,
+                                                                         currentUserSecurityPolicyManager) as VersionedFolder
+
+        if (!validateResource(copy, 'create')) return
+
+        saveResource(copy)
+
+        saveResponse(copy)
+    }
+
+    @Transactional
+    def newDocumentationVersion(CreateNewVersionData createNewVersionData) {
+
+        createNewVersionData.label = 'newDocumentationVersion'
+
+        if (!createNewVersionData.validate()) {
+            respond createNewVersionData.errors
+            return
+        }
+
+        VersionedFolder instance = queryForResource(params.versionedFolderId)
+
+        if (!instance) return notFound(params.versionedFolderId)
+
+        VersionedFolder copy = versionedFolderService.createNewDocumentationVersion(instance, currentUser, createNewVersionData.copyPermissions,
+                                                                                    currentUserSecurityPolicyManager)
+
+        if (!validateResource(copy, 'create')) return
+
+        if (!validateResource(copy, 'create')) return
+
+        saveResource(copy)
+
+        saveResponse(copy)
+    }
+
     @Override
     protected VersionedFolder queryForResource(Serializable id) {
         versionedFolderService.get(id)
@@ -171,7 +293,8 @@ class VersionedFolderController extends EditLoggingController<VersionedFolder> {
             return versionedFolderService.findAllByParentId(params.versionedFolderId, params)
         }
 
-        versionedFolderService.findAllByUser(currentUserSecurityPolicyManager, params)
+        def r = versionedFolderService.findAllByUser(currentUserSecurityPolicyManager, params)
+        r
     }
 
     @Override
@@ -181,4 +304,19 @@ class VersionedFolderController extends EditLoggingController<VersionedFolder> {
         }
         versionedFolderService.delete(resource)
     }
+
+    protected VersionedFolder updateSecurity(VersionedFolder instance, Set<String> changedProperties) {
+        modelServices.each { service ->
+            Collection<Model> modelsInFolder = service.findAllByFolderId(instance.id)
+            modelsInFolder.each { model ->
+                if (securityPolicyManagerService) {
+                    currentUserSecurityPolicyManager = securityPolicyManagerService.updateSecurityForSecurableResource(model as SecurableResource,
+                                                                                                                       changedProperties,
+                                                                                                                       currentUser)
+                }
+            }
+        }
+        instance
+    }
+
 }