From e3536285aaa097a2aeed146ddd1644295311dad1 Mon Sep 17 00:00:00 2001 From: Thomas Georgios Giannos Date: Tue, 24 Oct 2023 12:47:48 +0300 Subject: [PATCH 1/6] Adding 'description' entity (former 'dataset' entity) --- .../eu/eudat/authorization/Permission.java | 5 + .../commons/enums/DescriptionStatus.java | 31 +++ .../java/eu/eudat/data/DescriptionEntity.java | 219 ++++++++++++++++++ .../enums/DescriptionStatusConverter.java | 11 + .../eudat/event/DescriptionTouchedEvent.java | 24 ++ .../main/java/eu/eudat/model/Description.java | 191 +++++++++++++++ .../model/censorship/DescriptionCensor.java | 37 +++ .../model/persist/DescriptionPersist.java | 121 ++++++++++ 8 files changed, 639 insertions(+) create mode 100644 dmp-backend/core/src/main/java/eu/eudat/commons/enums/DescriptionStatus.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/data/DescriptionEntity.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/data/converters/enums/DescriptionStatusConverter.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/event/DescriptionTouchedEvent.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/Description.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionCensor.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionPersist.java diff --git a/dmp-backend/core/src/main/java/eu/eudat/authorization/Permission.java b/dmp-backend/core/src/main/java/eu/eudat/authorization/Permission.java index f679d1660..5b53ac0ac 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/authorization/Permission.java +++ b/dmp-backend/core/src/main/java/eu/eudat/authorization/Permission.java @@ -38,6 +38,11 @@ public final class Permission { public static String EditDmpBlueprint = "EditDmpBlueprint"; public static String DeleteDmpBlueprint = "DeleteDmpBlueprint"; + //Description + public static String BrowseDescription = "BrowseDescription"; + public static String EditDescription = "EditDescription"; + public static String DeleteDescription = "DeleteDescription"; + //DescriptionTemplateType public static String BrowseEntityDoi = "BrowseEntityDoi"; public static String EditEntityDoi = "EditEntityDoi"; diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/enums/DescriptionStatus.java b/dmp-backend/core/src/main/java/eu/eudat/commons/enums/DescriptionStatus.java new file mode 100644 index 000000000..6a01dcecb --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/enums/DescriptionStatus.java @@ -0,0 +1,31 @@ +package eu.eudat.commons.enums; + +import com.fasterxml.jackson.annotation.JsonValue; +import eu.eudat.data.converters.enums.DatabaseEnum; + +import java.util.Map; + +public enum DescriptionStatus implements DatabaseEnum { + + Saved((short) 0), + Finalized((short) 1), + Canceled((short) 2); + + private final Short value; + + DescriptionStatus(Short value) { + this.value = value; + } + + @JsonValue + public Short getValue() { + return value; + } + + private static final Map map = EnumUtils.getEnumValueMap(DescriptionStatus.class); + + public static DescriptionStatus of(Short i) { + return map.get(i); + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/DescriptionEntity.java b/dmp-backend/core/src/main/java/eu/eudat/data/DescriptionEntity.java new file mode 100644 index 000000000..8147de2de --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/data/DescriptionEntity.java @@ -0,0 +1,219 @@ +package eu.eudat.data; + +import eu.eudat.commons.enums.DescriptionStatus; +import eu.eudat.commons.enums.IsActive; +import eu.eudat.data.converters.DateToUTCConverter; +import eu.eudat.data.converters.enums.DescriptionStatusConverter; +import eu.eudat.data.converters.enums.IsActiveConverter; +import jakarta.persistence.Column; +import jakarta.persistence.Convert; +import jakarta.persistence.Id; + +import java.time.Instant; +import java.util.UUID; + +//@Entity +//@Table(name = "\"Description\"") +public class DescriptionEntity { + + @Id + @Column(name = "id", columnDefinition = "uuid", updatable = false, nullable = false) + private UUID id; + + public static final String _id = "id"; + + @Column(name = "label", length = 250, nullable = false) + private String label; + + public static final String _label = "label"; + + @Column(name = "dmp", columnDefinition = "uuid") + private UUID dmp; + + public static final String _dmp = "dmp"; + + @Column(name = "uri", length = 250) + private String uri; + + public static final String _uri = "uri"; + + @Column(name = "properties") + private String properties; + + public static final String _properties = "properties"; + + //TODO: (thgiannos) Previously 'DescriptionTemplate' + @Column(name = "profile", columnDefinition = "uuid") + private UUID profile; + + public static final String _profile = "profile"; + + @Column(name = "reference") + private String reference; + + public static final String _reference = "reference"; + + @Column(name = "status", nullable = false) + @Convert(converter = DescriptionStatusConverter.class) + private DescriptionStatus status; + + public static final String _status = "status"; + + @Column(name = "description") + private String description; + + public static final String _description = "description"; + + @Column(name = "dmp_section_index", nullable = false) + private Integer dmpSectionIndex; + + public static final String _dmpSectionIndex = "dmpSectionIndex"; + + @Column(name = "creator", columnDefinition = "uuid") + private UUID creator; + + public static final String _creator = "creator"; + + @Column(name = "created_at", nullable = false) + private Instant createdAt; + + public static final String _createdAt = "createdAt"; + + @Column(name = "updated_at", nullable = false) + private Instant updatedAt; + + public static final String _updatedAt = "updatedAt"; + + @Column(name = "is_active", nullable = false) + @Convert(converter = IsActiveConverter.class) + private IsActive isActive; + + public static final String _isActive = "isActive"; + + @Column(name = "\"finalized_at\"") + @Convert(converter = DateToUTCConverter.class) + private Instant finalizedAt; + + public static final String _finalizedAt = "finalizedAt"; + + public UUID getId() { + return id; + } + + public void setId(UUID id) { + this.id = id; + } + + public String getLabel() { + return label; + } + + public void setLabel(String label) { + this.label = label; + } + + public UUID getDmp() { + return dmp; + } + + public void setDmp(UUID dmp) { + this.dmp = dmp; + } + + public String getUri() { + return uri; + } + + public void setUri(String uri) { + this.uri = uri; + } + + public String getProperties() { + return properties; + } + + public void setProperties(String properties) { + this.properties = properties; + } + + public UUID getProfile() { + return profile; + } + + public void setProfile(UUID profile) { + this.profile = profile; + } + + public String getReference() { + return reference; + } + + public void setReference(String reference) { + this.reference = reference; + } + + public DescriptionStatus getStatus() { + return status; + } + + public void setStatus(DescriptionStatus status) { + this.status = status; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public Integer getDmpSectionIndex() { + return dmpSectionIndex; + } + + public void setDmpSectionIndex(Integer dmpSectionIndex) { + this.dmpSectionIndex = dmpSectionIndex; + } + + public UUID getCreator() { + return creator; + } + + public void setCreator(UUID creator) { + this.creator = creator; + } + + public Instant getCreatedAt() { + return createdAt; + } + + public void setCreatedAt(Instant createdAt) { + this.createdAt = createdAt; + } + + public Instant getUpdatedAt() { + return updatedAt; + } + + public void setUpdatedAt(Instant updatedAt) { + this.updatedAt = updatedAt; + } + + public IsActive getIsActive() { + return isActive; + } + + public void setIsActive(IsActive isActive) { + this.isActive = isActive; + } + + public Instant getFinalizedAt() { + return finalizedAt; + } + + public void setFinalizedAt(Instant finalizedAt) { + this.finalizedAt = finalizedAt; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/converters/enums/DescriptionStatusConverter.java b/dmp-backend/core/src/main/java/eu/eudat/data/converters/enums/DescriptionStatusConverter.java new file mode 100644 index 000000000..1f759f165 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/data/converters/enums/DescriptionStatusConverter.java @@ -0,0 +1,11 @@ +package eu.eudat.data.converters.enums; + +import eu.eudat.commons.enums.DescriptionStatus; +import jakarta.persistence.Converter; + +@Converter +public class DescriptionStatusConverter extends DatabaseEnumConverter{ + protected DescriptionStatus of(Short i) { + return DescriptionStatus.of(i); + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/event/DescriptionTouchedEvent.java b/dmp-backend/core/src/main/java/eu/eudat/event/DescriptionTouchedEvent.java new file mode 100644 index 000000000..e6485126c --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/event/DescriptionTouchedEvent.java @@ -0,0 +1,24 @@ +package eu.eudat.event; + +import java.util.UUID; + +public class DescriptionTouchedEvent { + + public DescriptionTouchedEvent() { + } + + public DescriptionTouchedEvent(UUID id) { + this.id = id; + } + + private UUID id; + + public UUID getId() { + return id; + } + + public void setId(UUID id) { + this.id = id; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/Description.java b/dmp-backend/core/src/main/java/eu/eudat/model/Description.java new file mode 100644 index 000000000..c0abc05f2 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/Description.java @@ -0,0 +1,191 @@ +package eu.eudat.model; + +import eu.eudat.commons.enums.DescriptionStatus; +import eu.eudat.commons.enums.IsActive; + +import java.time.Instant; +import java.util.UUID; + +public class Description { + + private UUID id; + + public static final String _id = "id"; + + private String label; + + public static final String _label = "label"; + + private UUID dmp; + + public static final String _dmp = "dmp"; + + private String uri; + + public static final String _uri = "uri"; + + private String properties; + + public static final String _properties = "properties"; + + private UUID profile; + + public static final String _profile = "profile"; + + private String reference; + + public static final String _reference = "reference"; + + private DescriptionStatus status; + + public static final String _status = "status"; + + private String description; + + public static final String _description = "description"; + + private Integer dmpSectionIndex; + + public static final String _dmpSectionIndex = "dmpSectionIndex"; + + private UUID creator; + + public static final String _creator = "creator"; + + private Instant createdAt; + + public static final String _createdAt = "createdAt"; + + private Instant updatedAt; + + public static final String _updatedAt = "updatedAt"; + + private IsActive isActive; + + public static final String _isActive = "isActive"; + + private Instant finalizedAt; + + public static final String _finalizedAt = "finalizedAt"; + + public UUID getId() { + return id; + } + + public void setId(UUID id) { + this.id = id; + } + + public String getLabel() { + return label; + } + + public void setLabel(String label) { + this.label = label; + } + + public UUID getDmp() { + return dmp; + } + + public void setDmp(UUID dmp) { + this.dmp = dmp; + } + + public String getUri() { + return uri; + } + + public void setUri(String uri) { + this.uri = uri; + } + + public String getProperties() { + return properties; + } + + public void setProperties(String properties) { + this.properties = properties; + } + + public UUID getProfile() { + return profile; + } + + public void setProfile(UUID profile) { + this.profile = profile; + } + + public String getReference() { + return reference; + } + + public void setReference(String reference) { + this.reference = reference; + } + + public DescriptionStatus getStatus() { + return status; + } + + public void setStatus(DescriptionStatus status) { + this.status = status; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public Integer getDmpSectionIndex() { + return dmpSectionIndex; + } + + public void setDmpSectionIndex(Integer dmpSectionIndex) { + this.dmpSectionIndex = dmpSectionIndex; + } + + public UUID getCreator() { + return creator; + } + + public void setCreator(UUID creator) { + this.creator = creator; + } + + public Instant getCreatedAt() { + return createdAt; + } + + public void setCreatedAt(Instant createdAt) { + this.createdAt = createdAt; + } + + public Instant getUpdatedAt() { + return updatedAt; + } + + public void setUpdatedAt(Instant updatedAt) { + this.updatedAt = updatedAt; + } + + public IsActive getIsActive() { + return isActive; + } + + public void setIsActive(IsActive isActive) { + this.isActive = isActive; + } + + public Instant getFinalizedAt() { + return finalizedAt; + } + + public void setFinalizedAt(Instant finalizedAt) { + this.finalizedAt = finalizedAt; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionCensor.java b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionCensor.java new file mode 100644 index 000000000..3b1bb2a92 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionCensor.java @@ -0,0 +1,37 @@ +package eu.eudat.model.censorship; + +import eu.eudat.authorization.Permission; +import eu.eudat.convention.ConventionService; +import gr.cite.commons.web.authz.service.AuthorizationService; +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 DescriptionCensor extends BaseCensor { + + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionCensor.class)); + + protected final AuthorizationService authService; + + public DescriptionCensor(ConventionService conventionService, AuthorizationService authService) { + super(conventionService); + this.authService = authService; + } + + public void censor(FieldSet fields, UUID userId) { + logger.debug(new DataLogEntry("censoring fields", fields)); + if (fields == null || fields.isEmpty()) + return; + + this.authService.authorizeForce(Permission.BrowseDescription); + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionPersist.java new file mode 100644 index 000000000..fc4e885e0 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionPersist.java @@ -0,0 +1,121 @@ +package eu.eudat.model.persist; + +import eu.eudat.commons.enums.DescriptionStatus; +import eu.eudat.commons.enums.IsActive; +import eu.eudat.commons.validation.ValidId; + +import java.util.UUID; + +public class DescriptionPersist { + + @ValidId(message = "{validation.invalidid}") + private UUID id; + + private String label; + + private UUID dmp; + + private String uri; + + private String properties; + + private UUID profile; + + private String reference; + + private DescriptionStatus status; + + private String description; + + private Integer dmpSectionIndex; + + private IsActive isActive; + + public UUID getId() { + return id; + } + + public void setId(UUID id) { + this.id = id; + } + + public String getLabel() { + return label; + } + + public void setLabel(String label) { + this.label = label; + } + + public UUID getDmp() { + return dmp; + } + + public void setDmp(UUID dmp) { + this.dmp = dmp; + } + + public String getUri() { + return uri; + } + + public void setUri(String uri) { + this.uri = uri; + } + + public String getProperties() { + return properties; + } + + public void setProperties(String properties) { + this.properties = properties; + } + + public UUID getProfile() { + return profile; + } + + public void setProfile(UUID profile) { + this.profile = profile; + } + + public String getReference() { + return reference; + } + + public void setReference(String reference) { + this.reference = reference; + } + + public DescriptionStatus getStatus() { + return status; + } + + public void setStatus(DescriptionStatus status) { + this.status = status; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public Integer getDmpSectionIndex() { + return dmpSectionIndex; + } + + public void setDmpSectionIndex(Integer dmpSectionIndex) { + this.dmpSectionIndex = dmpSectionIndex; + } + + public IsActive getIsActive() { + return isActive; + } + + public void setIsActive(IsActive isActive) { + this.isActive = isActive; + } +} From 485f7311cd88715d4a1f5875883d341f35d81b54 Mon Sep 17 00:00:00 2001 From: Thomas Georgios Giannos Date: Tue, 24 Oct 2023 13:50:53 +0300 Subject: [PATCH 2/6] Adding builder and query for 'description' entity --- .../main/java/eu/eudat/model/Description.java | 11 + .../model/builder/DescriptionBuilder.java | 84 +++++++ .../java/eu/eudat/query/DescriptionQuery.java | 206 ++++++++++++++++++ .../eudat/query/lookup/DescriptionLookup.java | 78 +++++++ 4 files changed, 379 insertions(+) create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionBuilder.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/query/DescriptionQuery.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/query/lookup/DescriptionLookup.java diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/Description.java b/dmp-backend/core/src/main/java/eu/eudat/model/Description.java index c0abc05f2..ea9d73a56 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/Description.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/Description.java @@ -68,6 +68,10 @@ public class Description { public static final String _finalizedAt = "finalizedAt"; + private String hash; + + public static final String _hash = "hash"; + public UUID getId() { return id; } @@ -188,4 +192,11 @@ public class Description { this.finalizedAt = finalizedAt; } + public String getHash() { + return hash; + } + + public void setHash(String hash) { + this.hash = hash; + } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionBuilder.java new file mode 100644 index 000000000..0d015d357 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionBuilder.java @@ -0,0 +1,84 @@ +package eu.eudat.model.builder; + +import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.convention.ConventionService; +import eu.eudat.data.DescriptionEntity; +import eu.eudat.model.Description; +import gr.cite.tools.exception.MyApplicationException; +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.annotation.Autowired; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.annotation.Scope; +import org.springframework.stereotype.Component; + +import java.util.*; + +@Component +@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) +public class DescriptionBuilder extends BaseBuilder { + + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); + + @Autowired + public DescriptionBuilder( + ConventionService conventionService) { + super(conventionService, new LoggerService(LoggerFactory.getLogger(DescriptionBuilder.class))); + } + + public DescriptionBuilder authorize(EnumSet values) { + this.authorize = values; + return this; + } + + @Override + public List build(FieldSet fields, List data) throws MyApplicationException { + this.logger.debug("building for {} items requesting {} fields", Optional.ofNullable(data).map(List::size).orElse(0), Optional.ofNullable(fields).map(FieldSet::getFields).map(Set::size).orElse(0)); + this.logger.trace(new DataLogEntry("requested fields", fields)); + if (fields == null || data == null || fields.isEmpty()) + return new ArrayList<>(); + + List models = new ArrayList<>(); + for (DescriptionEntity d : data) { + Description m = new Description(); + if (fields.hasField(this.asIndexer(Description._id))) + m.setId(d.getId()); + if (fields.hasField(this.asIndexer(Description._label))) + m.setLabel(d.getLabel()); + if (fields.hasField(this.asIndexer(Description._dmp))) + m.setDmp(d.getDmp()); + if (fields.hasField(this.asIndexer(Description._uri))) + m.setUri(d.getUri()); + if (fields.hasField(this.asIndexer(Description._properties))) + m.setProperties(d.getProperties()); + if (fields.hasField(this.asIndexer(Description._profile))) + m.setProfile(d.getProfile()); + if (fields.hasField(this.asIndexer(Description._reference))) + m.setReference(d.getReference()); + if (fields.hasField(this.asIndexer(Description._status))) + m.setStatus(d.getStatus()); + if (fields.hasField(this.asIndexer(Description._description))) + m.setDescription(d.getDescription()); + if (fields.hasField(this.asIndexer(Description._creator))) + m.setCreator(d.getCreator()); + if (fields.hasField(this.asIndexer(Description._dmpSectionIndex))) + m.setDmpSectionIndex(d.getDmpSectionIndex()); + if (fields.hasField(this.asIndexer(Description._createdAt))) + m.setCreatedAt(d.getCreatedAt()); + if (fields.hasField(this.asIndexer(Description._updatedAt))) + m.setUpdatedAt(d.getUpdatedAt()); + if (fields.hasField(this.asIndexer(Description._isActive))) + m.setIsActive(d.getIsActive()); + if (fields.hasField(this.asIndexer(Description._finalizedAt))) + m.setFinalizedAt(d.getFinalizedAt()); + if (fields.hasField(this.asIndexer(Description._hash))) + m.setHash(this.hashValue(d.getUpdatedAt())); + models.add(m); + } + this.logger.debug("build {} items", Optional.of(models).map(List::size).orElse(0)); + return models; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionQuery.java b/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionQuery.java new file mode 100644 index 000000000..cec8f41cc --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionQuery.java @@ -0,0 +1,206 @@ +package eu.eudat.query; + +import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.commons.enums.DescriptionStatus; +import eu.eudat.commons.enums.IsActive; +import eu.eudat.commons.scope.user.UserScope; +import eu.eudat.data.DescriptionEntity; +import eu.eudat.model.Description; +import gr.cite.commons.web.authz.service.AuthorizationService; +import gr.cite.tools.data.query.FieldResolver; +import gr.cite.tools.data.query.QueryBase; +import gr.cite.tools.data.query.QueryContext; +import jakarta.persistence.Tuple; +import jakarta.persistence.criteria.CriteriaBuilder; +import jakarta.persistence.criteria.Predicate; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.annotation.Scope; +import org.springframework.stereotype.Component; + +import java.time.Instant; +import java.util.*; + +@Component +@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) +public class DescriptionQuery extends QueryBase { + + private String like; + + private Collection ids; + + private Collection excludedIds; + + private Collection isActives; + + private Collection statuses; + + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); + + private final UserScope userScope; + + private final AuthorizationService authService; + + public DescriptionQuery(UserScope userScope, AuthorizationService authService) { + this.userScope = userScope; + this.authService = authService; + } + + public DescriptionQuery like(String value) { + this.like = value; + return this; + } + + public DescriptionQuery ids(UUID value) { + this.ids = List.of(value); + return this; + } + + public DescriptionQuery ids(UUID... value) { + this.ids = Arrays.asList(value); + return this; + } + + public DescriptionQuery ids(Collection values) { + this.ids = values; + return this; + } + + public DescriptionQuery excludedIds(Collection values) { + this.excludedIds = values; + return this; + } + + public DescriptionQuery excludedIds(UUID value) { + this.excludedIds = List.of(value); + return this; + } + + public DescriptionQuery excludedIds(UUID... value) { + this.excludedIds = Arrays.asList(value); + return this; + } + + public DescriptionQuery isActive(IsActive value) { + this.isActives = List.of(value); + return this; + } + + public DescriptionQuery isActive(IsActive... value) { + this.isActives = Arrays.asList(value); + return this; + } + + public DescriptionQuery isActive(Collection values) { + this.isActives = values; + return this; + } + + public DescriptionQuery statuses(DescriptionStatus value) { + this.statuses = List.of(value); + return this; + } + + public DescriptionQuery statuses(DescriptionStatus... value) { + this.statuses = Arrays.asList(value); + return this; + } + + public DescriptionQuery statuses(Collection values) { + this.statuses = values; + return this; + } + + public DescriptionQuery authorize(EnumSet values) { + this.authorize = values; + return this; + } + + @Override + protected Boolean isFalseQuery() { + return this.isEmpty(this.ids) || this.isEmpty(this.isActives) || this.isEmpty(this.excludedIds) || this.isEmpty(this.statuses); + } + + @Override + protected Class entityClass() { + return DescriptionEntity.class; + } + + @Override + protected Predicate applyFilters(QueryContext queryContext) { + List predicates = new ArrayList<>(); + if (this.like != null && !this.like.isEmpty()) { + predicates.add(queryContext.CriteriaBuilder.like(queryContext.Root.get(DescriptionEntity._label), this.like)); + } + if (this.ids != null) { + CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(DescriptionEntity._id)); + for (UUID item : this.ids) + inClause.value(item); + predicates.add(inClause); + }if (this.excludedIds != null) { + CriteriaBuilder.In notInClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(DescriptionEntity._id)); + for (UUID item : this.excludedIds) + notInClause.value(item); + predicates.add(notInClause.not()); + } + if (this.isActives != null) { + CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(DescriptionEntity._isActive)); + for (IsActive item : this.isActives) + inClause.value(item); + predicates.add(inClause); + } + if (this.statuses != null) { + CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(DescriptionEntity._status)); + for (DescriptionStatus item : this.statuses) + inClause.value(item); + predicates.add(inClause); + } + if (!predicates.isEmpty()) { + Predicate[] predicatesArray = predicates.toArray(new Predicate[0]); + return queryContext.CriteriaBuilder.and(predicatesArray); + } else { + return null; + } + } + + @Override + protected String fieldNameOf(FieldResolver item) { + if (item.match(Description._id)) return DescriptionEntity._id; + else if (item.match(Description._label)) return DescriptionEntity._label; + else if (item.match(Description._dmp)) return DescriptionEntity._dmp; + else if (item.match(Description._uri)) return DescriptionEntity._uri; + else if (item.match(Description._properties)) return DescriptionEntity._properties; + else if (item.match(Description._profile)) return DescriptionEntity._profile; + else if (item.match(Description._reference)) return DescriptionEntity._reference; + else if (item.match(Description._status)) return DescriptionEntity._status; + else if (item.match(Description._description)) return DescriptionEntity._description; + else if (item.match(Description._dmpSectionIndex)) return DescriptionEntity._dmpSectionIndex; + else if (item.match(Description._creator)) return DescriptionEntity._creator; + else if (item.match(Description._createdAt)) return DescriptionEntity._createdAt; + else if (item.match(Description._updatedAt)) return DescriptionEntity._updatedAt; + else if (item.match(Description._isActive)) return DescriptionEntity._isActive; + else if (item.match(Description._finalizedAt)) return DescriptionEntity._finalizedAt; + else return null; + } + + @Override + protected DescriptionEntity convert(Tuple tuple, Set columns) { + DescriptionEntity item = new DescriptionEntity(); + item.setId(QueryBase.convertSafe(tuple, columns, DescriptionEntity._id, UUID.class)); + item.setLabel(QueryBase.convertSafe(tuple, columns, DescriptionEntity._label, String.class)); + item.setDmp(QueryBase.convertSafe(tuple, columns, DescriptionEntity._dmp, UUID.class)); + item.setUri(QueryBase.convertSafe(tuple, columns, DescriptionEntity._uri, String.class)); + item.setProperties(QueryBase.convertSafe(tuple, columns, DescriptionEntity._properties, String.class)); + item.setProfile(QueryBase.convertSafe(tuple, columns, DescriptionEntity._profile, UUID.class)); + item.setReference(QueryBase.convertSafe(tuple, columns, DescriptionEntity._reference, String.class)); + item.setStatus(QueryBase.convertSafe(tuple, columns, DescriptionEntity._status, DescriptionStatus.class)); + item.setDescription(QueryBase.convertSafe(tuple, columns, DescriptionEntity._description, String.class)); + item.setDmpSectionIndex(QueryBase.convertSafe(tuple, columns, DescriptionEntity._dmpSectionIndex, Integer.class)); + item.setCreator(QueryBase.convertSafe(tuple, columns, DescriptionEntity._creator, UUID.class)); + item.setCreatedAt(QueryBase.convertSafe(tuple, columns, DescriptionEntity._createdAt, Instant.class)); + item.setUpdatedAt(QueryBase.convertSafe(tuple, columns, DescriptionEntity._updatedAt, Instant.class)); + item.setIsActive(QueryBase.convertSafe(tuple, columns, DescriptionEntity._isActive, IsActive.class)); + item.setFinalizedAt(QueryBase.convertSafe(tuple, columns, DescriptionEntity._finalizedAt, Instant.class)); + return item; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/query/lookup/DescriptionLookup.java b/dmp-backend/core/src/main/java/eu/eudat/query/lookup/DescriptionLookup.java new file mode 100644 index 000000000..4352207cf --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/query/lookup/DescriptionLookup.java @@ -0,0 +1,78 @@ +package eu.eudat.query.lookup; + +import eu.eudat.commons.enums.DescriptionStatus; +import eu.eudat.commons.enums.IsActive; +import eu.eudat.query.DescriptionQuery; +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 DescriptionLookup extends Lookup { + + private String like; + + private List ids; + + private List excludedIds; + + private List isActive; + + private List statuses; + + public String getLike() { + return like; + } + + public void setLike(String like) { + this.like = like; + } + + public List getIds() { + return ids; + } + + public void setIds(List ids) { + this.ids = ids; + } + + public List getExcludedIds() { + return excludedIds; + } + + public void setExcludedIds(List excludedIds) { + this.excludedIds = excludedIds; + } + + public List getIsActive() { + return isActive; + } + + public void setIsActive(List isActive) { + this.isActive = isActive; + } + + public List getStatuses() { + return statuses; + } + + public void setStatuses(List statuses) { + this.statuses = statuses; + } + + public DescriptionQuery enrich(QueryFactory queryFactory) { + DescriptionQuery query = queryFactory.query(DescriptionQuery.class); + if (this.like != null) query.like(this.like); + if (this.ids != null) query.ids(this.ids); + if (this.excludedIds != null) query.excludedIds(this.excludedIds); + if (this.isActive != null) query.isActive(this.isActive); + if (this.statuses != null) query.statuses(this.statuses); + + this.enrichCommon(query); + + return query; + } + +} From e27468b596a59eb3d0433f2ba8f903642b7aa027 Mon Sep 17 00:00:00 2001 From: Thomas Georgios Giannos Date: Tue, 24 Oct 2023 15:38:15 +0300 Subject: [PATCH 3/6] Adding basic service for 'description' entity --- .../main/java/eu/eudat/event/EventBroker.java | 4 + .../model/deleter/DescriptionDeleter.java | 81 ++++++++++ .../description/DescriptionService.java | 20 +++ .../description/DescriptionServiceImpl.java | 144 ++++++++++++++++++ 4 files changed, 249 insertions(+) create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionDeleter.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionService.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionServiceImpl.java diff --git a/dmp-backend/core/src/main/java/eu/eudat/event/EventBroker.java b/dmp-backend/core/src/main/java/eu/eudat/event/EventBroker.java index b58a00333..75ffc150d 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/event/EventBroker.java +++ b/dmp-backend/core/src/main/java/eu/eudat/event/EventBroker.java @@ -34,6 +34,10 @@ public class EventBroker { this.applicationEventPublisher.publishEvent(event); } + public void emit(DescriptionTouchedEvent event) { + this.applicationEventPublisher.publishEvent(event); + } + public void emit(DescriptionTemplateTypeTouchedEvent event) { this.applicationEventPublisher.publishEvent(event); } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionDeleter.java b/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionDeleter.java new file mode 100644 index 000000000..174647c71 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionDeleter.java @@ -0,0 +1,81 @@ +package eu.eudat.model.deleter; + +import eu.eudat.commons.enums.IsActive; +import eu.eudat.data.DescriptionEntity; +import eu.eudat.data.DescriptionTemplateTypeEntity; +import eu.eudat.query.DescriptionQuery; +import eu.eudat.query.DescriptionTemplateTypeQuery; +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 DescriptionDeleter implements Deleter { + + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionDeleter.class)); + + private final EntityManager entityManager; + + protected final QueryFactory queryFactory; + + protected final DeleterFactory deleterFactory; + + @Autowired + public DescriptionDeleter( + EntityManager entityManager, + QueryFactory queryFactory, + DeleterFactory deleterFactory + ) { + this.entityManager = entityManager; + this.queryFactory = queryFactory; + this.deleterFactory = deleterFactory; + } + + public void deleteAndSaveByIds(List ids) throws InvalidApplicationException { + logger.debug(new MapLogEntry("collecting to delete").And("count", Optional.ofNullable(ids).map(List::size).orElse(0)).And("ids", ids)); + List data = this.queryFactory.query(DescriptionQuery.class).ids(ids).collect(); + logger.trace("retrieved {} items", Optional.ofNullable(data).map(List::size).orElse(0)); + this.deleteAndSave(data); + } + + public void deleteAndSave(List 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 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 (DescriptionEntity 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"); + } + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionService.java b/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionService.java new file mode 100644 index 000000000..32c05a2e0 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionService.java @@ -0,0 +1,20 @@ +package eu.eudat.service.description; + +import eu.eudat.model.Description; +import eu.eudat.model.persist.DescriptionPersist; +import gr.cite.tools.exception.MyApplicationException; +import gr.cite.tools.exception.MyForbiddenException; +import gr.cite.tools.exception.MyNotFoundException; +import gr.cite.tools.exception.MyValidationException; +import gr.cite.tools.fieldset.FieldSet; + +import javax.management.InvalidApplicationException; +import java.util.UUID; + +public interface DescriptionService { + + Description persist(DescriptionPersist model, FieldSet fields) throws MyForbiddenException, MyValidationException, MyApplicationException, MyNotFoundException, InvalidApplicationException; + + void deleteAndSave(UUID id) throws MyForbiddenException, InvalidApplicationException; + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionServiceImpl.java b/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionServiceImpl.java new file mode 100644 index 000000000..9577d1795 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionServiceImpl.java @@ -0,0 +1,144 @@ +package eu.eudat.service.description; + +import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.authorization.Permission; +import eu.eudat.commons.JsonHandlingService; +import eu.eudat.commons.enums.IsActive; +import eu.eudat.convention.ConventionService; +import eu.eudat.data.DescriptionEntity; +import eu.eudat.data.DmpEntity; +import eu.eudat.errorcode.ErrorThesaurusProperties; +import eu.eudat.event.DescriptionTouchedEvent; +import eu.eudat.event.DmpTouchedEvent; +import eu.eudat.event.EventBroker; +import eu.eudat.model.Description; +import eu.eudat.model.Dmp; +import eu.eudat.model.builder.DescriptionBuilder; +import eu.eudat.model.builder.DmpBuilder; +import eu.eudat.model.deleter.DescriptionDeleter; +import eu.eudat.model.deleter.DmpDeleter; +import eu.eudat.model.persist.DescriptionPersist; +import eu.eudat.service.dmp.DmpServiceImpl; +import gr.cite.commons.web.authz.service.AuthorizationService; +import gr.cite.tools.data.builder.BuilderFactory; +import gr.cite.tools.data.deleter.DeleterFactory; +import gr.cite.tools.data.query.QueryFactory; +import gr.cite.tools.exception.MyApplicationException; +import gr.cite.tools.exception.MyForbiddenException; +import gr.cite.tools.exception.MyNotFoundException; +import gr.cite.tools.exception.MyValidationException; +import gr.cite.tools.fieldset.BaseFieldSet; +import gr.cite.tools.fieldset.FieldSet; +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.context.MessageSource; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Service; + +import javax.management.InvalidApplicationException; +import java.time.Instant; +import java.util.List; +import java.util.UUID; + +@Service +public class DescriptionServiceImpl implements DescriptionService { + + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionServiceImpl.class)); + + private final EntityManager entityManager; + + private final AuthorizationService authorizationService; + + private final DeleterFactory deleterFactory; + + private final BuilderFactory builderFactory; + + private final ConventionService conventionService; + + private final ErrorThesaurusProperties errors; + + private final MessageSource messageSource; + + private final EventBroker eventBroker; + + private final QueryFactory queryFactory; + + private final JsonHandlingService jsonHandlingService; + + @Autowired + public DescriptionServiceImpl( + EntityManager entityManager, + AuthorizationService authorizationService, + DeleterFactory deleterFactory, + BuilderFactory builderFactory, + ConventionService conventionService, + ErrorThesaurusProperties errors, + MessageSource messageSource, + EventBroker eventBroker, + QueryFactory queryFactory, + JsonHandlingService jsonHandlingService) { + this.entityManager = entityManager; + this.authorizationService = authorizationService; + this.deleterFactory = deleterFactory; + this.builderFactory = builderFactory; + this.conventionService = conventionService; + this.errors = errors; + this.messageSource = messageSource; + this.eventBroker = eventBroker; + this.queryFactory = queryFactory; + this.jsonHandlingService = jsonHandlingService; + } + + @Override + public Description persist(DescriptionPersist model, FieldSet fields) throws MyForbiddenException, MyValidationException, MyApplicationException, MyNotFoundException, InvalidApplicationException { + logger.debug(new MapLogEntry("persisting data dmp").And("model", model).And("fields", fields)); + + this.authorizationService.authorizeForce(Permission.EditDescription); + + Boolean isUpdate = this.conventionService.isValidGuid(model.getId()); + + DescriptionEntity data; + if (isUpdate) { + data = this.entityManager.find(DescriptionEntity.class, model.getId()); + if (data == null) + throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{model.getId(), Description.class.getSimpleName()}, LocaleContextHolder.getLocale())); + } else { + data = new DescriptionEntity(); + data.setId(UUID.randomUUID()); + data.setIsActive(IsActive.Active); + data.setCreatedAt(Instant.now()); + } + + data.setLabel(model.getLabel()); + data.setDmp(model.getDmp()); + data.setUri(model.getUri()); + data.setProperties(model.getProperties()); + data.setProfile(model.getProfile()); + data.setReference(model.getReference()); + data.setStatus(model.getStatus()); + data.setDescription(model.getDescription()); + data.setDmpSectionIndex(model.getDmpSectionIndex()); + data.setUpdatedAt(Instant.now()); + if (isUpdate) + this.entityManager.merge(data); + else + this.entityManager.persist(data); + + this.entityManager.flush(); + + this.eventBroker.emit(new DescriptionTouchedEvent(data.getId())); + return this.builderFactory.builder(DescriptionBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(BaseFieldSet.build(fields, Description._id), data); + } + + @Override + public void deleteAndSave(UUID id) throws MyForbiddenException, InvalidApplicationException { + logger.debug("deleting description: {}", id); + + this.authorizationService.authorizeForce(Permission.DeleteDescription); + + this.deleterFactory.deleter(DescriptionDeleter.class).deleteAndSaveByIds(List.of(id)); + } +} From 3e7b9ca90b4dc610c579fed0b2e44780959d6029 Mon Sep 17 00:00:00 2001 From: Thomas Georgios Giannos Date: Tue, 24 Oct 2023 15:39:11 +0300 Subject: [PATCH 4/6] Optimize imports --- .../java/eu/eudat/model/deleter/DescriptionDeleter.java | 2 -- .../eudat/service/description/DescriptionServiceImpl.java | 6 ------ .../src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java | 7 ------- 3 files changed, 15 deletions(-) diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionDeleter.java b/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionDeleter.java index 174647c71..fc98bd167 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionDeleter.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionDeleter.java @@ -2,9 +2,7 @@ package eu.eudat.model.deleter; import eu.eudat.commons.enums.IsActive; import eu.eudat.data.DescriptionEntity; -import eu.eudat.data.DescriptionTemplateTypeEntity; import eu.eudat.query.DescriptionQuery; -import eu.eudat.query.DescriptionTemplateTypeQuery; import gr.cite.tools.data.deleter.Deleter; import gr.cite.tools.data.deleter.DeleterFactory; import gr.cite.tools.data.query.QueryFactory; diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionServiceImpl.java b/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionServiceImpl.java index 9577d1795..ed576e6c3 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionServiceImpl.java +++ b/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionServiceImpl.java @@ -6,19 +6,13 @@ import eu.eudat.commons.JsonHandlingService; import eu.eudat.commons.enums.IsActive; import eu.eudat.convention.ConventionService; import eu.eudat.data.DescriptionEntity; -import eu.eudat.data.DmpEntity; import eu.eudat.errorcode.ErrorThesaurusProperties; import eu.eudat.event.DescriptionTouchedEvent; -import eu.eudat.event.DmpTouchedEvent; import eu.eudat.event.EventBroker; import eu.eudat.model.Description; -import eu.eudat.model.Dmp; import eu.eudat.model.builder.DescriptionBuilder; -import eu.eudat.model.builder.DmpBuilder; import eu.eudat.model.deleter.DescriptionDeleter; -import eu.eudat.model.deleter.DmpDeleter; import eu.eudat.model.persist.DescriptionPersist; -import eu.eudat.service.dmp.DmpServiceImpl; import gr.cite.commons.web.authz.service.AuthorizationService; import gr.cite.tools.data.builder.BuilderFactory; import gr.cite.tools.data.deleter.DeleterFactory; diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java b/dmp-backend/core/src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java index 78c3edfef..cc1d12ec6 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java +++ b/dmp-backend/core/src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java @@ -5,21 +5,14 @@ import eu.eudat.authorization.Permission; import eu.eudat.commons.JsonHandlingService; import eu.eudat.commons.enums.IsActive; import eu.eudat.convention.ConventionService; -import eu.eudat.data.DescriptionTemplateTypeEntity; import eu.eudat.data.DmpEntity; import eu.eudat.errorcode.ErrorThesaurusProperties; -import eu.eudat.event.DescriptionTemplateTypeTouchedEvent; import eu.eudat.event.DmpTouchedEvent; import eu.eudat.event.EventBroker; -import eu.eudat.model.DescriptionTemplateType; import eu.eudat.model.Dmp; -import eu.eudat.model.builder.DescriptionTemplateTypeBuilder; import eu.eudat.model.builder.DmpBuilder; -import eu.eudat.model.deleter.DescriptionTemplateTypeDeleter; import eu.eudat.model.deleter.DmpDeleter; -import eu.eudat.model.persist.DescriptionTemplateTypePersist; import eu.eudat.model.persist.DmpPersist; -import eu.eudat.service.descriptiontemplatetype.DescriptionTemplateTypeServiceImpl; import gr.cite.commons.web.authz.service.AuthorizationService; import gr.cite.tools.data.builder.BuilderFactory; import gr.cite.tools.data.deleter.DeleterFactory; From 1e733cf704235a5637b198da8a2254bb116b7f90 Mon Sep 17 00:00:00 2001 From: Thomas Georgios Giannos Date: Tue, 24 Oct 2023 17:07:28 +0300 Subject: [PATCH 5/6] Connecting 'dmp' entity with 'description' entity (description builder populating dmp data) --- .../main/java/eu/eudat/model/Description.java | 6 +- .../model/builder/DescriptionBuilder.java | 55 ++++++++++++++++++- 2 files changed, 55 insertions(+), 6 deletions(-) diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/Description.java b/dmp-backend/core/src/main/java/eu/eudat/model/Description.java index ea9d73a56..bf4e68d76 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/Description.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/Description.java @@ -16,7 +16,7 @@ public class Description { public static final String _label = "label"; - private UUID dmp; + private Dmp dmp; public static final String _dmp = "dmp"; @@ -88,11 +88,11 @@ public class Description { this.label = label; } - public UUID getDmp() { + public Dmp getDmp() { return dmp; } - public void setDmp(UUID dmp) { + public void setDmp(Dmp dmp) { this.dmp = dmp; } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionBuilder.java index 0d015d357..9ef64a834 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionBuilder.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionBuilder.java @@ -4,7 +4,12 @@ import eu.eudat.authorization.AuthorizationFlags; import eu.eudat.convention.ConventionService; import eu.eudat.data.DescriptionEntity; import eu.eudat.model.Description; +import eu.eudat.model.Dmp; +import eu.eudat.query.DmpQuery; +import gr.cite.tools.data.builder.BuilderFactory; +import gr.cite.tools.data.query.QueryFactory; import gr.cite.tools.exception.MyApplicationException; +import gr.cite.tools.fieldset.BaseFieldSet; import gr.cite.tools.fieldset.FieldSet; import gr.cite.tools.logging.DataLogEntry; import gr.cite.tools.logging.LoggerService; @@ -15,17 +20,26 @@ import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Component; import java.util.*; +import java.util.stream.Collectors; @Component @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) public class DescriptionBuilder extends BaseBuilder { + private final QueryFactory queryFactory; + + private final BuilderFactory builderFactory; + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); @Autowired public DescriptionBuilder( - ConventionService conventionService) { + ConventionService conventionService, + QueryFactory queryFactory, + BuilderFactory builderFactory) { super(conventionService, new LoggerService(LoggerFactory.getLogger(DescriptionBuilder.class))); + this.queryFactory = queryFactory; + this.builderFactory = builderFactory; } public DescriptionBuilder authorize(EnumSet values) { @@ -40,6 +54,9 @@ public class DescriptionBuilder extends BaseBuilder(); + FieldSet dmpFields = fields.extractPrefixed(this.asPrefix(Description._dmp)); + Map dmpItemsMap = this.collectDmps(dmpFields, data); + List models = new ArrayList<>(); for (DescriptionEntity d : data) { Description m = new Description(); @@ -47,8 +64,6 @@ public class DescriptionBuilder extends BaseBuilder collectDmps(FieldSet fields, List data) throws MyApplicationException { + if (fields.isEmpty() || data.isEmpty()) + return null; + this.logger.debug("checking related - {}", Dmp.class.getSimpleName()); + + Map itemMap; + if (!fields.hasOtherField(this.asIndexer(Dmp._id))) { + itemMap = this.asEmpty( + data.stream().map(DescriptionEntity::getDmp).distinct().collect(Collectors.toList()), + x -> { + Dmp item = new Dmp(); + item.setId(x); + return item; + }, + Dmp::getId); + } else { + FieldSet clone = new BaseFieldSet(fields.getFields()).ensure(Dmp._id); + DmpQuery q = this.queryFactory.query(DmpQuery.class).authorize(this.authorize).ids(data.stream().map(DescriptionEntity::getDmp).distinct().collect(Collectors.toList())); + itemMap = this.builderFactory.builder(DmpBuilder.class).authorize(this.authorize).asForeignKey(q, clone, Dmp::getId); + } + if (!fields.hasField(Dmp._id)) { + itemMap.forEach((id, item) -> { + if (item != null) + item.setId(null); + }); + } + + return itemMap; + } + } From e149b61b58fffebe2d89e5af1f05b28e0b10bcc1 Mon Sep 17 00:00:00 2001 From: Thomas Georgios Giannos Date: Tue, 24 Oct 2023 17:24:51 +0300 Subject: [PATCH 6/6] Adding 'dmp' query option on 'description' query --- .../java/eu/eudat/query/DescriptionQuery.java | 83 +++++++++++++++---- .../eudat/query/lookup/DescriptionLookup.java | 11 +++ 2 files changed, 76 insertions(+), 18 deletions(-) diff --git a/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionQuery.java b/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionQuery.java index cec8f41cc..4362d39b7 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionQuery.java +++ b/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionQuery.java @@ -34,6 +34,8 @@ public class DescriptionQuery extends QueryBase { private Collection statuses; + private Collection dmpIds; + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); private final UserScope userScope; @@ -110,6 +112,21 @@ public class DescriptionQuery extends QueryBase { return this; } + public DescriptionQuery dmpIds(UUID value) { + this.dmpIds = List.of(value); + return this; + } + + public DescriptionQuery dmpIds(UUID... value) { + this.dmpIds = Arrays.asList(value); + return this; + } + + public DescriptionQuery dmpIds(Collection values) { + this.dmpIds = values; + return this; + } + public DescriptionQuery authorize(EnumSet values) { this.authorize = values; return this; @@ -117,7 +134,12 @@ public class DescriptionQuery extends QueryBase { @Override protected Boolean isFalseQuery() { - return this.isEmpty(this.ids) || this.isEmpty(this.isActives) || this.isEmpty(this.excludedIds) || this.isEmpty(this.statuses); + return + this.isEmpty(this.ids) || + this.isEmpty(this.isActives) || + this.isEmpty(this.excludedIds) || + this.isEmpty(this.statuses) || + this.isEmpty(this.dmpIds); } @Override @@ -136,7 +158,8 @@ public class DescriptionQuery extends QueryBase { for (UUID item : this.ids) inClause.value(item); predicates.add(inClause); - }if (this.excludedIds != null) { + } + if (this.excludedIds != null) { CriteriaBuilder.In notInClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(DescriptionEntity._id)); for (UUID item : this.excludedIds) notInClause.value(item); @@ -154,6 +177,12 @@ public class DescriptionQuery extends QueryBase { inClause.value(item); predicates.add(inClause); } + if (this.dmpIds != null) { + CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(DescriptionEntity._dmp)); + for (UUID item : this.dmpIds) + inClause.value(item); + predicates.add(inClause); + } if (!predicates.isEmpty()) { Predicate[] predicatesArray = predicates.toArray(new Predicate[0]); return queryContext.CriteriaBuilder.and(predicatesArray); @@ -164,22 +193,40 @@ public class DescriptionQuery extends QueryBase { @Override protected String fieldNameOf(FieldResolver item) { - if (item.match(Description._id)) return DescriptionEntity._id; - else if (item.match(Description._label)) return DescriptionEntity._label; - else if (item.match(Description._dmp)) return DescriptionEntity._dmp; - else if (item.match(Description._uri)) return DescriptionEntity._uri; - else if (item.match(Description._properties)) return DescriptionEntity._properties; - else if (item.match(Description._profile)) return DescriptionEntity._profile; - else if (item.match(Description._reference)) return DescriptionEntity._reference; - else if (item.match(Description._status)) return DescriptionEntity._status; - else if (item.match(Description._description)) return DescriptionEntity._description; - else if (item.match(Description._dmpSectionIndex)) return DescriptionEntity._dmpSectionIndex; - else if (item.match(Description._creator)) return DescriptionEntity._creator; - else if (item.match(Description._createdAt)) return DescriptionEntity._createdAt; - else if (item.match(Description._updatedAt)) return DescriptionEntity._updatedAt; - else if (item.match(Description._isActive)) return DescriptionEntity._isActive; - else if (item.match(Description._finalizedAt)) return DescriptionEntity._finalizedAt; - else return null; + if (item.match(Description._id)) + return DescriptionEntity._id; + else if (item.match(Description._label)) + return DescriptionEntity._label; + else if (item.prefix(Description._dmp)) + return DescriptionEntity._dmp; + else if (item.match(Description._dmp)) + return DescriptionEntity._dmp; + else if (item.match(Description._uri)) + return DescriptionEntity._uri; + else if (item.match(Description._properties)) + return DescriptionEntity._properties; + else if (item.match(Description._profile)) + return DescriptionEntity._profile; + else if (item.match(Description._reference)) + return DescriptionEntity._reference; + else if (item.match(Description._status)) + return DescriptionEntity._status; + else if (item.match(Description._description)) + return DescriptionEntity._description; + else if (item.match(Description._dmpSectionIndex)) + return DescriptionEntity._dmpSectionIndex; + else if (item.match(Description._creator)) + return DescriptionEntity._creator; + else if (item.match(Description._createdAt)) + return DescriptionEntity._createdAt; + else if (item.match(Description._updatedAt)) + return DescriptionEntity._updatedAt; + else if (item.match(Description._isActive)) + return DescriptionEntity._isActive; + else if (item.match(Description._finalizedAt)) + return DescriptionEntity._finalizedAt; + else + return null; } @Override diff --git a/dmp-backend/core/src/main/java/eu/eudat/query/lookup/DescriptionLookup.java b/dmp-backend/core/src/main/java/eu/eudat/query/lookup/DescriptionLookup.java index 4352207cf..627abccb0 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/query/lookup/DescriptionLookup.java +++ b/dmp-backend/core/src/main/java/eu/eudat/query/lookup/DescriptionLookup.java @@ -22,6 +22,8 @@ public class DescriptionLookup extends Lookup { private List statuses; + private List dmpIds; + public String getLike() { return like; } @@ -62,6 +64,14 @@ public class DescriptionLookup extends Lookup { this.statuses = statuses; } + public List getDmpIds() { + return dmpIds; + } + + public void setDmpIds(List dmpIds) { + this.dmpIds = dmpIds; + } + public DescriptionQuery enrich(QueryFactory queryFactory) { DescriptionQuery query = queryFactory.query(DescriptionQuery.class); if (this.like != null) query.like(this.like); @@ -69,6 +79,7 @@ public class DescriptionLookup extends Lookup { if (this.excludedIds != null) query.excludedIds(this.excludedIds); if (this.isActive != null) query.isActive(this.isActive); if (this.statuses != null) query.statuses(this.statuses); + if (this.dmpIds != null) query.dmpIds(this.dmpIds); this.enrichCommon(query);