Deleting content section (if empty) works now

Former-commit-id: 98c00fd677

ccm-cms/src/main/java/org/librecms/contentsection/ContentSectionManager.java

@@ -54,11 +54,14 @@ import java.util.Optional;
 import org.librecms.contentsection.privileges.TypePrivileges;
 import org.librecms.dispatcher.ItemResolver;
 
+import java.util.Collections;
 import java.util.Objects;
-import java.util.logging.Level;
+import java.util.stream.Collectors;
-import java.util.logging.Logger;
 
 import javax.enterprise.inject.Instance;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaDelete;
+import javax.persistence.criteria.Root;
 
 import static org.librecms.contentsection.ContentSection.*;
 
@@ -675,33 +678,88 @@ public class ContentSectionManager {
     public void deleteContentSection(final ContentSection section) {
         Objects.requireNonNull(section);
 
-         try {
+        final CriteriaBuilder criteriaBuilder = entityManager
-            for (final ContentType type : section.getContentTypes()) {
+            .getCriteriaBuilder();
-                @SuppressWarnings("unchecked")
+
-                final Class<? extends ContentItem> clazz
+        if (!section.getContentTypes().isEmpty()) {
-                    = (Class<? extends ContentItem>) Class.forName(
+            final CriteriaDelete<ContentType> contentTypeDelete
-                        type.getContentItemClass()
+                = criteriaBuilder
+                    .createCriteriaDelete(ContentType.class);
+            final Root<ContentType> contentTypeRoot = contentTypeDelete.from(
+                ContentType.class
             );
-                removeContentTypeFromSection(clazz, section);
+            contentTypeDelete.where(
-            }
+                criteriaBuilder.equal(
-        } catch (ClassNotFoundException ex) {
+                    contentTypeRoot.get("contentSection"),
-            throw new UnexpectedErrorException(ex);
+                    section
-        }
+                )
-         for (final LifecycleDefinition lifecycle : section
-            .getLifecycleDefinitions()) {
-            removeLifecycleDefinitionFromContentSection(
-                lifecycle, section
             );
-        }
+            entityManager.createQuery(contentTypeDelete).executeUpdate();
-        for (final Role role : section.getRoles()) {
-            removeRoleFromContentSection(section, role);
-        }
-        for (final Workflow workflow : section.getWorkflowTemplates()) {
-            removeWorkflowTemplateFromContentSection(workflow, section);
         }
 
-        folderRepository.delete(section.getRootAssetsFolder());
+        if (!section.getLifecycleDefinitions().isEmpty()) {
-        folderRepository.delete(section.getRootDocumentsFolder());
+            final CriteriaDelete<LifecycleDefinition> lifecycleDelete
+                = criteriaBuilder
+                    .createCriteriaDelete(LifecycleDefinition.class);
+            final Root<LifecycleDefinition> lifecycleRoot = lifecycleDelete
+                .from(LifecycleDefinition.class);
+            lifecycleDelete.where(
+                criteriaBuilder
+                    .in(lifecycleRoot.get("definitionId"))
+                    .value(
+                        section
+                            .getLifecycleDefinitions()
+                            .stream()
+                            .map(LifecycleDefinition::getDefinitionId)
+                            .collect(Collectors.toSet())
+                    )
+            );
+            entityManager.createQuery(lifecycleDelete).executeUpdate();
+        }
+
+        section.setRoles(Collections.emptyList());
+        sectionRepo.save(section);
+
+        if (!section.getWorkflowTemplates().isEmpty()) {
+            final CriteriaDelete<Workflow> workflowDelete = criteriaBuilder
+                .createCriteriaDelete(Workflow.class);
+            final Root<Workflow> workflowRoot = workflowDelete.from(
+                Workflow.class);
+            workflowDelete.where(
+                criteriaBuilder
+                    .in(workflowRoot.get("workflowId"))
+                    .value(
+                        section
+                            .getWorkflowTemplates()
+                            .stream()
+                            .map(Workflow::getWorkflowId)
+                            .collect(Collectors.toSet())
+                    )
+            );
+            entityManager.createQuery(workflowDelete).executeUpdate();
+        }
+
+        final Folder rootAssetsFolder = section.getRootAssetsFolder();
+        final Folder rootDocumentsFolder = section.getRootDocumentsFolder();
+
+        section.setRootAssetsFolder(null);
+        section.setRootDocumentFolder(null);
+        sectionRepo.save(section);
+
+        folderRepository.delete(rootAssetsFolder);
+        folderRepository.delete(rootDocumentsFolder);
+
+        if (!section.getPermissions().isEmpty()) {
+            final CriteriaDelete<Permission> permissionsDelete = criteriaBuilder
+                .createCriteriaDelete(Permission.class);
+            final Root<Permission> permissionRoot = permissionsDelete.from(
+                Permission.class
+            );
+            permissionsDelete.where(
+                criteriaBuilder.equal(permissionRoot.get("object"), section)
+            );
+            entityManager.createQuery(permissionsDelete).executeUpdate();
+        }
 
         sectionRepo.delete(section);
     }

ccm-cms/src/main/java/org/librecms/contentsection/FolderRepository.java

@@ -23,6 +23,7 @@ import org.apache.logging.log4j.Logger;
 import org.libreccm.categorization.Category;
 import org.libreccm.core.AbstractEntityRepository;
 import org.libreccm.security.AuthorizationRequired;
+import org.libreccm.security.Permission;
 import org.libreccm.security.RequiresPrivilege;
 import org.librecms.contentsection.privileges.ItemPrivileges;
 
@@ -30,10 +31,14 @@ import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 import javax.enterprise.context.RequestScoped;
 import javax.inject.Inject;
 import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaDelete;
+import javax.persistence.criteria.Root;
 import javax.transaction.Transactional;
 
 /**
@@ -225,8 +230,8 @@ public class FolderRepository extends AbstractEntityRepository<Long, Folder> {
     @Override
     public void save(
         @RequiresPrivilege(ItemPrivileges.CREATE_NEW)
-        final Folder folder) {
+        final Folder folder
-
+    ) {
         super.save(folder);
     }
 
@@ -235,7 +240,30 @@ public class FolderRepository extends AbstractEntityRepository<Long, Folder> {
     @Override
     public void delete(
         @RequiresPrivilege(ItemPrivileges.CREATE_NEW)
-        final Folder folder) {
+        final Folder folder
+    ) {
+        final CriteriaBuilder criteriaBuilder = getEntityManager()
+            .getCriteriaBuilder();
+        final CriteriaDelete<Permission> permissionsDelete = criteriaBuilder
+            .createCriteriaDelete(Permission.class);
+        final Root<Permission> permissionRoot = permissionsDelete.from(
+            Permission.class
+        );
+        permissionsDelete.where(
+            criteriaBuilder.equal(permissionRoot.get("object"), folder)
+        );
+//        permissionsDelete.where(
+//            criteriaBuilder
+//                .in(permissionRoot.get("permissionId"))
+//                .value(
+//                    folder
+//                        .getPermissions()
+//                        .stream()
+//                        .map(Permission::getPermissionId)
+//                        .collect(Collectors.toSet())
+//                )
+//        );
+        getEntityManager().createQuery(permissionsDelete).executeUpdate();
 
         super.delete(folder);
     }