Added censor, deleter and lookup for Dmp entity

dmp-backend/core/src/main/java/eu/eudat/authorization/Permission.java

@@ -28,6 +28,11 @@ public final class Permission {
 	public static String EditDescriptionTemplateType = "EditDescriptionTemplateType";
 	public static String DeleteDescriptionTemplateType = "DeleteDescriptionTemplateType";
 
+	//Dmp
+	public static String BrowseDmp = "BrowseDmp";
+	public static String EditDmp = "EditDmp";
+	public static String DeleteDmp = "DeleteDmp";
+
 	//DmpBlueprint
 	public static String BrowseDmpBlueprint = "BrowseDmpBlueprint";
 	public static String EditDmpBlueprint = "EditDmpBlueprint";

dmp-backend/core/src/main/java/eu/eudat/data/DmpEntity.java

@@ -87,13 +87,13 @@ public class DmpEntity {
 
     public static final String _isActive = "isActive";
 
-    @Column(name = "\"FinalizedAt\"")
+    @Column(name = "\"finalized_at\"")
     @Convert(converter = DateToUTCConverter.class)
     private Instant finalizedAt;
 
     public static final String _finalizedAt = "finalizedAt";
 
-    @Column(name = "\"PublishedAt\"")
+    @Column(name = "\"published_at\"")
     @Convert(converter = DateToUTCConverter.class)
     private Instant publishedAt;
 

dmp-backend/core/src/main/java/eu/eudat/model/censorship/DmpCensor.java

@@ -1,5 +1,42 @@
 package eu.eudat.model.censorship;
 
-public class DmpCensor {
+import eu.eudat.authorization.Permission;
+import eu.eudat.convention.ConventionService;
+import gr.cite.commons.web.authz.service.AuthorizationService;
+import gr.cite.tools.data.censor.CensorFactory;
+import gr.cite.tools.fieldset.FieldSet;
+import gr.cite.tools.logging.DataLogEntry;
+import gr.cite.tools.logging.LoggerService;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.context.annotation.Scope;
+import org.springframework.stereotype.Component;
+
+import java.util.UUID;
+
+@Component
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+public class DmpCensor extends BaseCensor {
+
+    private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DmpCensor.class));
+
+    protected final AuthorizationService authService;
+    protected final CensorFactory censorFactory;
+
+    public DmpCensor(ConventionService conventionService,
+                              AuthorizationService authService,
+                              CensorFactory censorFactory) {
+        super(conventionService);
+        this.authService = authService;
+        this.censorFactory = censorFactory;
+    }
+
+    public void censor(FieldSet fields, UUID userId) {
+        logger.debug(new DataLogEntry("censoring fields", fields));
+        if (fields.isEmpty())
+            return;
+
+        this.authService.authorizeForce(Permission.BrowseDmp);
+    }
 
 }

dmp-backend/core/src/main/java/eu/eudat/model/deleter/DmpDeleter.java

@@ -1,5 +1,79 @@
 package eu.eudat.model.deleter;
 
-public class DmpDeleter {
+import eu.eudat.commons.enums.IsActive;
+import eu.eudat.data.DmpEntity;
+import eu.eudat.query.DmpQuery;
+import gr.cite.tools.data.deleter.Deleter;
+import gr.cite.tools.data.deleter.DeleterFactory;
+import gr.cite.tools.data.query.QueryFactory;
+import gr.cite.tools.logging.LoggerService;
+import gr.cite.tools.logging.MapLogEntry;
+import jakarta.persistence.EntityManager;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.context.annotation.Scope;
+import org.springframework.stereotype.Component;
+
+import javax.management.InvalidApplicationException;
+import java.time.Instant;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+@Component
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+public class DmpDeleter implements Deleter {
+
+    private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DmpDeleter.class));
+
+    private final EntityManager entityManager;
+
+    protected final QueryFactory queryFactory;
+
+    protected final DeleterFactory deleterFactory;
+
+    @Autowired
+    public DmpDeleter(
+            EntityManager entityManager,
+            QueryFactory queryFactory,
+            DeleterFactory deleterFactory
+    ) {
+        this.entityManager = entityManager;
+        this.queryFactory = queryFactory;
+        this.deleterFactory = deleterFactory;
+    }
+
+    public void deleteAndSaveByIds(List<UUID> ids) throws InvalidApplicationException {
+        logger.debug(new MapLogEntry("collecting to delete").And("count", Optional.ofNullable(ids).map(List::size).orElse(0)).And("ids", ids));
+        List<DmpEntity> data = this.queryFactory.query(DmpQuery.class).ids(ids).collect();
+        logger.trace("retrieved {} items", Optional.ofNullable(data).map(List::size).orElse(0));
+        this.deleteAndSave(data);
+    }
+
+    public void deleteAndSave(List<DmpEntity> data) throws InvalidApplicationException {
+        logger.debug("will delete {} items", Optional.ofNullable(data).map(List::size).orElse(0));
+        this.delete(data);
+        logger.trace("saving changes");
+        this.entityManager.flush();
+        logger.trace("changes saved");
+    }
+
+    public void delete(List<DmpEntity> data) throws InvalidApplicationException {
+        logger.debug("will delete {} items", Optional.ofNullable(data).map(List::size).orElse(0));
+        if (data == null || data.isEmpty())
+            return;
+
+        Instant now = Instant.now();
+
+        for (DmpEntity item : data) {
+            logger.trace("deleting item {}", item.getId());
+            item.setIsActive(IsActive.Inactive);
+            item.setUpdatedAt(now);
+            logger.trace("updating item");
+            this.entityManager.merge(item);
+            logger.trace("updated item");
+        }
+    }
 
 }

dmp-backend/core/src/main/java/eu/eudat/query/lookup/DmpLookup.java

@@ -1,5 +1,77 @@
 package eu.eudat.query.lookup;
 
-public class DmpLookup {
+import eu.eudat.commons.enums.DmpStatus;
+import eu.eudat.commons.enums.IsActive;
+import eu.eudat.query.DmpQuery;
+import gr.cite.tools.data.query.Lookup;
+import gr.cite.tools.data.query.QueryFactory;
+
+import java.util.List;
+import java.util.UUID;
+
+public class DmpLookup extends Lookup {
+
+    private String like;
+
+    private List<IsActive> isActive;
+
+    private List<DmpStatus> statuses;
+
+    private List<UUID> ids;
+
+    private List<UUID> excludedIds;
+
+    public String getLike() {
+        return like;
+    }
+
+    public void setLike(String like) {
+        this.like = like;
+    }
+
+    public List<IsActive> getIsActive() {
+        return isActive;
+    }
+
+    public void setIsActive(List<IsActive> isActive) {
+        this.isActive = isActive;
+    }
+
+    public List<DmpStatus> getStatuses() {
+        return statuses;
+    }
+
+    public void setStatuses(List<DmpStatus> statuses) {
+        this.statuses = statuses;
+    }
+
+    public List<UUID> getIds() {
+        return ids;
+    }
+
+    public void setIds(List<UUID> ids) {
+        this.ids = ids;
+    }
+
+    public List<UUID> getExcludedIds() {
+        return excludedIds;
+    }
+
+    public void setExcludedIds(List<UUID> excludedIds) {
+        this.excludedIds = excludedIds;
+    }
+
+    public DmpQuery enrich(QueryFactory queryFactory) {
+        DmpQuery query = queryFactory.query(DmpQuery.class);
+        if (this.like != null) query.like(this.like);
+        if (this.isActive != null) query.isActive(this.isActive);
+        if (this.statuses != null) query.statuses(this.statuses);
+        if (this.ids != null) query.ids(this.ids);
+        if (this.excludedIds != null) query.excludedIds(this.excludedIds);
+
+        this.enrichCommon(query);
+
+        return query;
+    }
 
 }