From a38342e534fc29643224a139d62bbd830f2fcb89 Mon Sep 17 00:00:00 2001 From: Thomas Georgios Giannos Date: Wed, 18 Oct 2023 17:58:36 +0300 Subject: [PATCH] Removed EntityDao logic, added template stack, controller not yet implemented, db script not yet run --- .../eu/eudat/authorization/Permission.java | 5 + .../eu/eudat/commons/enums/EntityType.java | 26 ++- .../java/eu/eudat/data/CredentialEntity.java | 2 +- .../data/DescriptionTemplateTypeEntity.java | 17 +- .../java/eu/eudat/data/EntityDoiEntity.java | 127 ++++++++++ .../converters/enums/EntityTypeConverter.java | 14 ++ .../eu/eudat/data/helpers/EntityBinder.java | 15 -- .../src/main/java/eu/eudat/data/old/DMP.java | 7 +- .../java/eu/eudat/data/old/EntityDoi.java | 119 ---------- .../eu/eudat/event/EntityDoiTouchedEvent.java | 24 ++ .../main/java/eu/eudat/event/EventBroker.java | 4 + .../main/java/eu/eudat/model/EntityDoi.java | 119 ++++++++++ .../DescriptionTemplateTypeBuilder.java | 35 +-- .../eudat/model/builder/EntityDoiBuilder.java | 72 ++++++ .../DescriptionTemplateTypeCensor.java | 7 +- .../model/censorship/EntityDoiCensor.java | 36 +++ .../DescriptionTemplateTypeDeleter.java | 5 +- .../eudat/model/deleter/EntityDoiDeleter.java | 79 +++++++ .../eudat/model/persist/EntityDoiPersist.java | 61 +++++ .../query/DescriptionTemplateTypeQuery.java | 41 +++- .../java/eu/eudat/query/EntityDoiQuery.java | 218 ++++++++++++++++++ .../lookup/DescriptionTemplateTypeLookup.java | 19 +- .../eudat/query/lookup/EntityDoiLookup.java | 43 ++++ .../DescriptionTemplateTypeService.java | 2 + .../DescriptionTemplateTypeServiceImpl.java | 20 +- .../eu/eudat/service/EntityDoiService.java | 22 ++ .../eudat/service/EntityDoiServiceImpl.java | 138 +++++++++++ .../eudat/data/dao/entities/EntityDoiDao.java | 10 - .../data/dao/entities/EntityDoiDaoImpl.java | 56 ----- .../managers/DataManagementPlanManager.java | 20 +- .../operations/DatabaseRepository.java | 4 +- .../operations/DatabaseRepositoryImpl.java | 41 ++-- .../java/eu/eudat/models/data/doi/Doi.java | 21 +- .../models/data/rda/DmpRDAExportModel.java | 4 +- .../eudat/models/rda/mapper/DmpRDAMapper.java | 8 +- .../publicapi/models/doi/DoiPublicModel.java | 13 +- .../00.01.002_Align_Entity_Doi_table.sql | 23 ++ 37 files changed, 1176 insertions(+), 301 deletions(-) create mode 100644 dmp-backend/core/src/main/java/eu/eudat/data/EntityDoiEntity.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/data/converters/enums/EntityTypeConverter.java delete mode 100644 dmp-backend/core/src/main/java/eu/eudat/data/helpers/EntityBinder.java delete mode 100644 dmp-backend/core/src/main/java/eu/eudat/data/old/EntityDoi.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/event/EntityDoiTouchedEvent.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/EntityDoi.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/builder/EntityDoiBuilder.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/censorship/EntityDoiCensor.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/deleter/EntityDoiDeleter.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/persist/EntityDoiPersist.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/query/EntityDoiQuery.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/query/lookup/EntityDoiLookup.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/service/EntityDoiService.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/service/EntityDoiServiceImpl.java delete mode 100644 dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/EntityDoiDao.java delete mode 100644 dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/EntityDoiDaoImpl.java create mode 100644 dmp-db-scema/updates/00.01.002_Align_Entity_Doi_table.sql 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 947de0f03..a2cbd35de 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 @@ -15,6 +15,11 @@ public final class Permission { public static String EditDescriptionTemplateType = "EditDescriptionTemplateType"; public static String DeleteDescriptionTemplateType = "DeleteDescriptionTemplateType"; + //DescriptionTemplateType + public static String BrowseEntityDoi = "BrowseEntityDoi"; + public static String EditEntityDoi = "EditEntityDoi"; + public static String DeleteEntityDoi = "DeleteEntityDoi"; + // UI Pages public static String ViewDescriptionTemplateTypePage = "ViewDescriptionTemplateTypePage"; diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/enums/EntityType.java b/dmp-backend/core/src/main/java/eu/eudat/commons/enums/EntityType.java index c5c56dbbd..79002fcd7 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/commons/enums/EntityType.java +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/enums/EntityType.java @@ -1,4 +1,28 @@ package eu.eudat.commons.enums; -public enum EntityType { +import eu.eudat.data.converters.enums.DatabaseEnum; + +import java.util.Map; + +public enum EntityType implements DatabaseEnum { + + DMP((short) 0); + + private final Short value; + + EntityType(Short value) { + this.value = value; + } + + @Override + public Short getValue() { + return value; + } + + private static final Map map = EnumUtils.getEnumValueMap(EntityType.class); + + public static EntityType of(Short i) { + return map.get(i); + } + } diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/CredentialEntity.java b/dmp-backend/core/src/main/java/eu/eudat/data/CredentialEntity.java index 8c7686853..a95d73200 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/data/CredentialEntity.java +++ b/dmp-backend/core/src/main/java/eu/eudat/data/CredentialEntity.java @@ -6,7 +6,7 @@ import eu.eudat.data.converters.DateToUTCConverter; import eu.eudat.data.converters.enums.ProviderTypeConverter; import eu.eudat.data.converters.enums.IsActiveConverter; -import eu.eudat.data.helpers.EntityBinder; +import eu.eudat.data.old.helpers.EntityBinder; import eu.eudat.queryable.queryableentity.DataEntity; import jakarta.persistence.*; import java.util.Date; diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/DescriptionTemplateTypeEntity.java b/dmp-backend/core/src/main/java/eu/eudat/data/DescriptionTemplateTypeEntity.java index bf584c74d..487f07775 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/data/DescriptionTemplateTypeEntity.java +++ b/dmp-backend/core/src/main/java/eu/eudat/data/DescriptionTemplateTypeEntity.java @@ -16,30 +16,35 @@ public class DescriptionTemplateTypeEntity { @Id @Column(name = "id", columnDefinition = "uuid", updatable = false, nullable = false) private UUID id; - public final static String _id = "id"; + + public static final String _id = "id"; @Column(name = "name", length = 500, nullable = false) private String name; - public final static String _name = "name"; + + public static final String _name = "name"; @Column(name = "created_at", nullable = false) private Instant createdAt; - public final static String _createdAt = "createdAt"; + + public static final String _createdAt = "createdAt"; @Column(name = "updated_at", nullable = false) private Instant updatedAt; - public final static String _updatedAt = "updatedAt"; + + public static final String _updatedAt = "updatedAt"; @Column(name = "is_active", nullable = false) @Convert(converter = IsActiveConverter.class) private IsActive isActive; - public final static String _isActive = "isActive"; + + public static final String _isActive = "isActive"; @Column(name = "status", nullable = false) @Convert(converter = DescriptionTemplateTypeStatusConverter.class) private DescriptionTemplateTypeStatus status; - public final static String _status = "status"; + public static final String _status = "status"; public UUID getId() { return id; diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/EntityDoiEntity.java b/dmp-backend/core/src/main/java/eu/eudat/data/EntityDoiEntity.java new file mode 100644 index 000000000..edb31da6c --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/data/EntityDoiEntity.java @@ -0,0 +1,127 @@ +package eu.eudat.data; + +import eu.eudat.commons.enums.EntityType; +import eu.eudat.commons.enums.IsActive; +import eu.eudat.data.converters.DateToUTCConverter; +import eu.eudat.data.converters.enums.IsActiveConverter; +import jakarta.persistence.*; + +import java.time.Instant; +import java.util.Date; +import java.util.UUID; + +@Entity +@Table(name = "\"EntityDoi\"") +public class EntityDoiEntity { + + @Id + @Column(name = "id", updatable = false, nullable = false, columnDefinition = "BINARY(16)") + private UUID id; + + public static final String _id = "id"; + + @Enumerated(EnumType.STRING) + @Column(name = "entity_type", nullable = false) + private EntityType entityType; + + public static final String _entityType = "entityType"; + + @Column(name = "repository_id", nullable = false) + private String repositoryId; + + public static final String _repositoryId = "repositoryId"; + + @Column(name = "doi", nullable = false) + private String doi; + + public static final String _doi = "doi"; + + @Column(name = "created_at", nullable = false) + @Convert(converter = DateToUTCConverter.class) + private Instant createdAt; + + public static final String _createdAt = "createdAt"; + + @Column(name = "updated_at", nullable = false) + @Convert(converter = DateToUTCConverter.class) + 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"; + + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "entity_id", nullable = false) + private UUID entityId; + + public static final String _entityId = "entityId"; + + public UUID getId() { + return id; + } + + public void setId(UUID id) { + this.id = id; + } + + public EntityType getEntityType() { + return entityType; + } + + public void setEntityType(EntityType entityType) { + this.entityType = entityType; + } + + public String getRepositoryId() { + return repositoryId; + } + + public void setRepositoryId(String repositoryId) { + this.repositoryId = repositoryId; + } + + public String getDoi() { + return doi; + } + + public void setDoi(String doi) { + this.doi = doi; + } + + 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 UUID getEntityId() { + return entityId; + } + + public void setEntityId(UUID entityId) { + this.entityId = entityId; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/converters/enums/EntityTypeConverter.java b/dmp-backend/core/src/main/java/eu/eudat/data/converters/enums/EntityTypeConverter.java new file mode 100644 index 000000000..c6814bdea --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/data/converters/enums/EntityTypeConverter.java @@ -0,0 +1,14 @@ +package eu.eudat.data.converters.enums; + +import eu.eudat.commons.enums.EntityType; +import jakarta.persistence.Converter; + +@Converter +public class EntityTypeConverter extends DatabaseEnumConverter{ + + @Override + protected EntityType of(Short i) { + return EntityType.of(i); + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/helpers/EntityBinder.java b/dmp-backend/core/src/main/java/eu/eudat/data/helpers/EntityBinder.java deleted file mode 100644 index 39c921317..000000000 --- a/dmp-backend/core/src/main/java/eu/eudat/data/helpers/EntityBinder.java +++ /dev/null @@ -1,15 +0,0 @@ -package eu.eudat.data.helpers; - -import jakarta.persistence.Tuple; - -import java.util.List; - -public class EntityBinder { - public static T fromTuple(List tuple, String path) { - try { - return (T) tuple.get(0).get(path); - }catch (IllegalArgumentException illegalArgument){ - return null; - } - } -} diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/old/DMP.java b/dmp-backend/core/src/main/java/eu/eudat/data/old/DMP.java index 1fb54000a..f11b96f13 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/data/old/DMP.java +++ b/dmp-backend/core/src/main/java/eu/eudat/data/old/DMP.java @@ -1,6 +1,7 @@ package eu.eudat.data.old; +import eu.eudat.data.EntityDoiEntity; import eu.eudat.data.converters.DateToUTCConverter; import eu.eudat.queryable.queryableentity.DataEntity; import org.hibernate.annotations.GenericGenerator; @@ -183,7 +184,7 @@ public class DMP implements DataEntity { private Date publishedAt; @OneToMany(mappedBy = "entityId", fetch = FetchType.LAZY) - private Set dois; + private Set dois; @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "\"Project\"") @@ -340,10 +341,10 @@ public class DMP implements DataEntity { this.publishedAt = publishedAt; } - public Set getDois() { + public Set getDois() { return dois; } - public void setDois(Set dois) { + public void setDois(Set dois) { this.dois = dois; } diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/old/EntityDoi.java b/dmp-backend/core/src/main/java/eu/eudat/data/old/EntityDoi.java deleted file mode 100644 index f0df55771..000000000 --- a/dmp-backend/core/src/main/java/eu/eudat/data/old/EntityDoi.java +++ /dev/null @@ -1,119 +0,0 @@ -package eu.eudat.data.old; - -import eu.eudat.data.converters.DateToUTCConverter; -import eu.eudat.data.old.helpers.EntityBinder; -import eu.eudat.queryable.queryableentity.DataEntity; - -import jakarta.persistence.*; -import java.util.Arrays; -import java.util.Date; -import java.util.List; -import java.util.UUID; -import java.util.stream.Collectors; - -@Entity -@Table(name = "\"EntityDoi\"") -public class EntityDoi implements DataEntity { - public enum EntityType { - DMP - } - - @Id - @Column(name = "\"ID\"", updatable = false, nullable = false, columnDefinition = "BINARY(16)") - private UUID id; - - @Enumerated(EnumType.STRING) - @Column(name = "\"EntityType\"", nullable = false) - private EntityType entityType; - - @Column(name = "\"RepositoryId\"", nullable = false) - private String repositoryId; - - @Column(name = "\"Doi\"", nullable = false) - private String doi; - - @Column(name = "\"CreatedAt\"", nullable = false) - @Convert(converter = DateToUTCConverter.class) - private Date createdAt; - - @Column(name = "\"UpdatedAt\"", nullable = false) - @Convert(converter = DateToUTCConverter.class) - private Date updatedAt; - - @ManyToOne(fetch = FetchType.LAZY) - @JoinColumn(name = "\"EntityId\"", nullable = false) - private DMP entityId; - - public UUID getId() { - return id; - } - public void setId(UUID id) { - this.id = id; - } - - public EntityType getEntityType() { - return entityType; - } - public void setEntityType(EntityType entityType) { - this.entityType = entityType; - } - - public String getRepositoryId() { - return repositoryId; - } - public void setRepositoryId(String repositoryId) { - this.repositoryId = repositoryId; - } - - public String getDoi() { - return doi; - } - public void setDoi(String doi) { - this.doi = doi; - } - - public Date getCreatedAt() { - return createdAt; - } - public void setCreatedAt(Date createdAt) { - this.createdAt = createdAt; - } - - public Date getUpdatedAt() { - return updatedAt; - } - public void setUpdatedAt(Date updatedAt) { - this.updatedAt = updatedAt; - } - - public DMP getEntityId() { - return entityId; - } - public void setEntityId(DMP entityId) { - this.entityId = entityId; - } - - @Override - public void update(EntityDoi doi) { - this.entityType = doi.getEntityType(); - this.repositoryId = doi.getRepositoryId(); - this.doi = doi.getDoi(); - this.createdAt = doi.getCreatedAt(); - this.updatedAt = doi.getUpdatedAt(); - this.entityId = doi.getEntityId(); - } - - @Override - public UUID getKeys() { - return this.id; - } - - @Override - public EntityDoi buildFromTuple(List tuple, List fields, String base) { - String currentBase = base.isEmpty() ? "" : base + "."; - if (fields.contains(currentBase + "id")) this.id = EntityBinder.fromTuple(tuple, currentBase + "id"); - if (fields.contains(currentBase + "entityId")) - this.entityId = tuple.stream().map(x -> new DMP().buildFromTuple(Arrays.asList(x), fields , base.isEmpty() ? "entityId" : base + "." + "entityId")).collect(Collectors.toList()).get(0); - return this; - } -} diff --git a/dmp-backend/core/src/main/java/eu/eudat/event/EntityDoiTouchedEvent.java b/dmp-backend/core/src/main/java/eu/eudat/event/EntityDoiTouchedEvent.java new file mode 100644 index 000000000..f211d7dbc --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/event/EntityDoiTouchedEvent.java @@ -0,0 +1,24 @@ +package eu.eudat.event; + +import java.util.UUID; + +public class EntityDoiTouchedEvent { + + public EntityDoiTouchedEvent() { + } + + public EntityDoiTouchedEvent(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/event/EventBroker.java b/dmp-backend/core/src/main/java/eu/eudat/event/EventBroker.java index c8fca7df1..f3c40355e 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 @@ -37,4 +37,8 @@ public class EventBroker { public void emit(DescriptionTemplateTypeTouchedEvent event) { this.applicationEventPublisher.publishEvent(event); } + + public void emit(EntityDoiTouchedEvent event) { + this.applicationEventPublisher.publishEvent(event); + } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/EntityDoi.java b/dmp-backend/core/src/main/java/eu/eudat/model/EntityDoi.java new file mode 100644 index 000000000..9c6be1c80 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/EntityDoi.java @@ -0,0 +1,119 @@ +package eu.eudat.model; + +import eu.eudat.commons.enums.EntityType; +import eu.eudat.commons.enums.IsActive; + +import java.time.Instant; +import java.util.Date; +import java.util.UUID; + +public class EntityDoi { + + private UUID id; + + public static final String _id = "id"; + + private EntityType entityType; + + public static final String _entityType = "entityType"; + + private String repositoryId; + + public static final String _repositoryId = "repositoryId"; + + private String doi; + + public static final String _doi = "doi"; + + 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 UUID entityId; + + public static final String _entityId = "entityId"; + + private String hash; + + public static final String _hash = "hash"; + + public UUID getId() { + return id; + } + + public void setId(UUID id) { + this.id = id; + } + + public EntityType getEntityType() { + return entityType; + } + + public void setEntityType(EntityType entityType) { + this.entityType = entityType; + } + + public String getRepositoryId() { + return repositoryId; + } + + public void setRepositoryId(String repositoryId) { + this.repositoryId = repositoryId; + } + + public String getDoi() { + return doi; + } + + public void setDoi(String doi) { + this.doi = doi; + } + + 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 UUID getEntityId() { + return entityId; + } + + public void setEntityId(UUID entityId) { + this.entityId = entityId; + } + + 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/DescriptionTemplateTypeBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionTemplateTypeBuilder.java index 044703435..83053e81e 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionTemplateTypeBuilder.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionTemplateTypeBuilder.java @@ -1,14 +1,10 @@ package eu.eudat.model.builder; import eu.eudat.authorization.AuthorizationFlags; -import eu.eudat.commons.JsonHandlingService; import eu.eudat.convention.ConventionService; import eu.eudat.data.DescriptionTemplateTypeEntity; import eu.eudat.model.DescriptionTemplateType; -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; @@ -19,7 +15,6 @@ 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) @@ -39,21 +34,29 @@ public class DescriptionTemplateTypeBuilder extends BaseBuilder build(FieldSet fields, List datas) throws MyApplicationException { - this.logger.debug("building for {} items requesting {} fields", Optional.ofNullable(datas).map(List::size).orElse(0), Optional.ofNullable(fields).map(FieldSet::getFields).map(Set::size).orElse(0)); + 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 || datas == null || fields.isEmpty()) return new ArrayList<>(); + if (fields == null || data == null || fields.isEmpty()) + return new ArrayList<>(); List models = new ArrayList<>(); - for (DescriptionTemplateTypeEntity d : datas) { + for (DescriptionTemplateTypeEntity d : data) { DescriptionTemplateType m = new DescriptionTemplateType(); - if (fields.hasField(this.asIndexer(DescriptionTemplateType._id))) m.setId(d.getId()); - if (fields.hasField(this.asIndexer(DescriptionTemplateType._name))) m.setName(d.getName()); - if (fields.hasField(this.asIndexer(DescriptionTemplateType._createdAt))) m.setCreatedAt(d.getCreatedAt()); - if (fields.hasField(this.asIndexer(DescriptionTemplateType._updatedAt))) m.setUpdatedAt(d.getUpdatedAt()); - if (fields.hasField(this.asIndexer(DescriptionTemplateType._isActive))) m.setIsActive(d.getIsActive()); - if (fields.hasField(this.asIndexer(DescriptionTemplateType._status))) m.setStatus(d.getStatus()); - if (fields.hasField(this.asIndexer(DescriptionTemplateType._hash))) m.setHash(this.hashValue(d.getUpdatedAt())); + if (fields.hasField(this.asIndexer(DescriptionTemplateType._id))) + m.setId(d.getId()); + if (fields.hasField(this.asIndexer(DescriptionTemplateType._name))) + m.setName(d.getName()); + if (fields.hasField(this.asIndexer(DescriptionTemplateType._createdAt))) + m.setCreatedAt(d.getCreatedAt()); + if (fields.hasField(this.asIndexer(DescriptionTemplateType._updatedAt))) + m.setUpdatedAt(d.getUpdatedAt()); + if (fields.hasField(this.asIndexer(DescriptionTemplateType._isActive))) + m.setIsActive(d.getIsActive()); + if (fields.hasField(this.asIndexer(DescriptionTemplateType._status))) + m.setStatus(d.getStatus()); + if (fields.hasField(this.asIndexer(DescriptionTemplateType._hash))) + m.setHash(this.hashValue(d.getUpdatedAt())); models.add(m); } this.logger.debug("build {} items", Optional.of(models).map(List::size).orElse(0)); diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/EntityDoiBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/EntityDoiBuilder.java new file mode 100644 index 000000000..a4cff8bd7 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/EntityDoiBuilder.java @@ -0,0 +1,72 @@ +package eu.eudat.model.builder; + +import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.convention.ConventionService; +import eu.eudat.data.EntityDoiEntity; +import eu.eudat.model.EntityDoi; +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 EntityDoiBuilder extends BaseBuilder { + + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); + + @Autowired + public EntityDoiBuilder( + ConventionService conventionService) { + super(conventionService, new LoggerService(LoggerFactory.getLogger(EntityDoiBuilder.class))); + } + + public EntityDoiBuilder 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 (EntityDoiEntity d : data) { + EntityDoi m = new EntityDoi(); + if (fields.hasField(this.asIndexer(EntityDoi._id))) + m.setId(d.getId()); + if (fields.hasField(this.asIndexer(EntityDoi._doi))) + m.setDoi(d.getDoi()); + if (fields.hasField(this.asIndexer(EntityDoi._entityId))) + m.setEntityId(d.getEntityId()); + if (fields.hasField(this.asIndexer(EntityDoi._entityType))) + m.setEntityType(d.getEntityType()); + if (fields.hasField(this.asIndexer(EntityDoi._repositoryId))) + m.setRepositoryId(d.getRepositoryId()); + if (fields.hasField(this.asIndexer(EntityDoi._createdAt))) + m.setCreatedAt(d.getCreatedAt()); + if (fields.hasField(this.asIndexer(EntityDoi._updatedAt))) + m.setUpdatedAt(d.getUpdatedAt()); + if (fields.hasField(this.asIndexer(EntityDoi._isActive))) + m.setIsActive(d.getIsActive()); + if (fields.hasField(this.asIndexer(EntityDoi._hash))) + m.setHash(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/model/censorship/DescriptionTemplateTypeCensor.java b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionTemplateTypeCensor.java index b941be7e2..39a1f409c 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionTemplateTypeCensor.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionTemplateTypeCensor.java @@ -15,10 +15,12 @@ import java.util.UUID; @Component @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) -public class DescriptionTemplateTypeCensor extends BaseCensor{ +public class DescriptionTemplateTypeCensor extends BaseCensor { private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionTemplateTypeCensor.class)); + protected final AuthorizationService authService; + public DescriptionTemplateTypeCensor(ConventionService conventionService, AuthorizationService authService) { super(conventionService); this.authService = authService; @@ -26,7 +28,8 @@ public class DescriptionTemplateTypeCensor extends BaseCensor{ public void censor(FieldSet fields, UUID userId) { logger.debug(new DataLogEntry("censoring fields", fields)); - if (fields.isEmpty()) return; + if (fields.isEmpty()) + return; this.authService.authorizeForce(Permission.BrowseDescriptionTemplateType); } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/censorship/EntityDoiCensor.java b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/EntityDoiCensor.java new file mode 100644 index 000000000..55cfed580 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/EntityDoiCensor.java @@ -0,0 +1,36 @@ +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 EntityDoiCensor extends BaseCensor{ + + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(EntityDoiCensor.class)); + + protected final AuthorizationService authService; + + public EntityDoiCensor(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.isEmpty()) + return; + + this.authService.authorizeForce(Permission.BrowseEntityDoi); + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionTemplateTypeDeleter.java b/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionTemplateTypeDeleter.java index 068a2b94a..c27f4e7a8 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionTemplateTypeDeleter.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionTemplateTypeDeleter.java @@ -28,7 +28,9 @@ public class DescriptionTemplateTypeDeleter implements Deleter { private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionTemplateTypeDeleter.class)); private final EntityManager entityManager; + protected final QueryFactory queryFactory; + protected final DeleterFactory deleterFactory; @Autowired @@ -59,7 +61,8 @@ public class DescriptionTemplateTypeDeleter implements Deleter { 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; + if (data == null || data.isEmpty()) + return; Instant now = Instant.now(); diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/deleter/EntityDoiDeleter.java b/dmp-backend/core/src/main/java/eu/eudat/model/deleter/EntityDoiDeleter.java new file mode 100644 index 000000000..e090d092c --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/deleter/EntityDoiDeleter.java @@ -0,0 +1,79 @@ +package eu.eudat.model.deleter; + +import eu.eudat.commons.enums.IsActive; +import eu.eudat.data.DescriptionTemplateTypeEntity; +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 EntityDoiDeleter implements Deleter { + + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionTemplateTypeDeleter.class)); + + private final EntityManager entityManager; + + protected final QueryFactory queryFactory; + + protected final DeleterFactory deleterFactory; + + @Autowired + public EntityDoiDeleter( + 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(DescriptionTemplateTypeQuery.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 (DescriptionTemplateTypeEntity 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/model/persist/EntityDoiPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/EntityDoiPersist.java new file mode 100644 index 000000000..96d57d5d9 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/EntityDoiPersist.java @@ -0,0 +1,61 @@ +package eu.eudat.model.persist; + +import eu.eudat.commons.validation.FieldNotNullIfOtherSet; +import eu.eudat.commons.validation.ValidId; + +import java.util.UUID; + +@FieldNotNullIfOtherSet(message = "{validation.hashempty}") +public class EntityDoiPersist { + + @ValidId(message = "{validation.invalidid}") + private UUID id; + + private UUID entityId; + + private String repositoryId; + + private String doi; + + private String hash; + + public UUID getId() { + return id; + } + + public void setId(UUID id) { + this.id = id; + } + + public UUID getEntityId() { + return entityId; + } + + public void setEntityId(UUID entityId) { + this.entityId = entityId; + } + + public String getRepositoryId() { + return repositoryId; + } + + public void setRepositoryId(String repositoryId) { + this.repositoryId = repositoryId; + } + + public String getDoi() { + return doi; + } + + public void setDoi(String doi) { + this.doi = doi; + } + + public String getHash() { + return hash; + } + + public void setHash(String hash) { + this.hash = hash; + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionTemplateTypeQuery.java b/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionTemplateTypeQuery.java index 13dbec3ad..059a2470c 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionTemplateTypeQuery.java +++ b/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionTemplateTypeQuery.java @@ -25,10 +25,15 @@ import java.util.*; public class DescriptionTemplateTypeQuery extends QueryBase { private String like; + private Collection ids; + private Collection isActives; + private Collection statuses; + private Collection excludedIds; + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); public DescriptionTemplateTypeQuery like(String value) { @@ -102,6 +107,7 @@ public class DescriptionTemplateTypeQuery extends QueryBase predicates = new ArrayList<>(); if (this.ids != null) { CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(DescriptionTemplateTypeEntity._id)); - for (UUID item : this.ids) inClause.value(item); + for (UUID item : this.ids) + inClause.value(item); predicates.add(inClause); } if (this.like != null && !this.like.isEmpty()) { @@ -135,21 +142,24 @@ public class DescriptionTemplateTypeQuery extends QueryBase inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(DescriptionTemplateTypeEntity._isActive)); - for (IsActive item : this.isActives) inClause.value(item); + for (IsActive item : this.isActives) + inClause.value(item); predicates.add(inClause); } if (this.statuses != null) { CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(DescriptionTemplateTypeEntity._status)); - for (DescriptionTemplateTypeStatus item : this.statuses) inClause.value(item); + for (DescriptionTemplateTypeStatus item : this.statuses) + inClause.value(item); predicates.add(inClause); } if (this.excludedIds != null) { CriteriaBuilder.In notInClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(DescriptionTemplateTypeEntity._id)); - for (UUID item : this.excludedIds) notInClause.value(item); + for (UUID item : this.excludedIds) + notInClause.value(item); predicates.add(notInClause.not()); } - if (predicates.size() > 0) { + if (!predicates.isEmpty()) { Predicate[] predicatesArray = predicates.toArray(new Predicate[0]); return queryContext.CriteriaBuilder.and(predicatesArray); } else { @@ -171,13 +181,20 @@ public class DescriptionTemplateTypeQuery extends QueryBase { + + private Collection ids; + + private Collection isActives; + + private Collection types; + + private Collection excludedIds; + + private Collection dois; + + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); + + public EntityDoiQuery ids(UUID value) { + this.ids = List.of(value); + return this; + } + + public EntityDoiQuery ids(UUID... value) { + this.ids = Arrays.asList(value); + return this; + } + + public EntityDoiQuery ids(Collection values) { + this.ids = values; + return this; + } + + public EntityDoiQuery isActive(IsActive value) { + this.isActives = List.of(value); + return this; + } + + public EntityDoiQuery isActive(IsActive... value) { + this.isActives = Arrays.asList(value); + return this; + } + + public EntityDoiQuery isActive(Collection values) { + this.isActives = values; + return this; + } + + public EntityDoiQuery types(EntityType value) { + this.types = List.of(value); + return this; + } + + public EntityDoiQuery types(EntityType... value) { + this.types = Arrays.asList(value); + return this; + } + + public EntityDoiQuery types(Collection values) { + this.types = values; + return this; + } + + public EntityDoiQuery excludedIds(Collection values) { + this.excludedIds = values; + return this; + } + + public EntityDoiQuery excludedIds(UUID value) { + this.excludedIds = List.of(value); + return this; + } + + public EntityDoiQuery excludedIds(UUID... value) { + this.excludedIds = Arrays.asList(value); + return this; + } + + public EntityDoiQuery dois(Collection values) { + this.dois = values; + return this; + } + + public EntityDoiQuery dois(String value) { + this.dois = List.of(value); + return this; + } + + public EntityDoiQuery dois(String... value) { + this.dois = Arrays.asList(value); + return this; + } + + public EntityDoiQuery authorize(EnumSet values) { + this.authorize = values; + return this; + } + + private final UserScope userScope; + + private final AuthorizationService authService; + + public EntityDoiQuery( + UserScope userScope, + AuthorizationService authService + ) { + this.userScope = userScope; + this.authService = authService; + } + + @Override + protected Class entityClass() { + return EntityDoiEntity.class; + } + + @Override + protected Boolean isFalseQuery() { + return this.isEmpty(this.ids) || this.isEmpty(this.isActives) || this.isEmpty(this.excludedIds) || this.isEmpty(this.types); + } + + @Override + protected Predicate applyFilters(QueryContext queryContext) { + List predicates = new ArrayList<>(); + if (this.ids != null) { + CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(EntityDoiEntity._id)); + for (UUID item : this.ids) + inClause.value(item); + predicates.add(inClause); + } + if (this.isActives != null) { + CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(EntityDoiEntity._isActive)); + for (IsActive item : this.isActives) + inClause.value(item); + predicates.add(inClause); + } + + if (this.types != null) { + CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(EntityDoiEntity._entityType)); + for (EntityType item : this.types) + inClause.value(item); + predicates.add(inClause); + } + if (this.excludedIds != null) { + CriteriaBuilder.In notInClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(EntityDoiEntity._id)); + for (UUID item : this.excludedIds) + notInClause.value(item); + predicates.add(notInClause.not()); + } + if (this.dois != null) { + CriteriaBuilder.In notInClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(EntityDoiEntity._doi)); + for (String item : this.dois) + notInClause.value(item); + predicates.add(notInClause.not()); + } + if (!predicates.isEmpty()) { + Predicate[] predicatesArray = predicates.toArray(new Predicate[0]); + return queryContext.CriteriaBuilder.and(predicatesArray); + } else { + return null; + } + } + + @Override + protected EntityDoiEntity convert(Tuple tuple, Set columns) { + EntityDoiEntity item = new EntityDoiEntity(); + item.setId(QueryBase.convertSafe(tuple, columns, EntityDoiEntity._id, UUID.class)); + item.setDoi(QueryBase.convertSafe(tuple, columns, EntityDoiEntity._doi, String.class)); + item.setRepositoryId(QueryBase.convertSafe(tuple, columns, EntityDoiEntity._repositoryId, String.class)); + item.setEntityId(QueryBase.convertSafe(tuple, columns, EntityDoiEntity._entityId, UUID.class)); + item.setEntityType(QueryBase.convertSafe(tuple, columns, EntityDoiEntity._entityType, EntityType.class)); + item.setCreatedAt(QueryBase.convertSafe(tuple, columns, EntityDoiEntity._createdAt, Instant.class)); + item.setUpdatedAt(QueryBase.convertSafe(tuple, columns, EntityDoiEntity._updatedAt, Instant.class)); + item.setIsActive(QueryBase.convertSafe(tuple, columns, EntityDoiEntity._isActive, IsActive.class)); + return item; + } + + @Override + protected String fieldNameOf(FieldResolver item) { + if (item.match(EntityDoiEntity._id)) + return EntityDoiEntity._id; + else if (item.match(EntityDoiEntity._doi)) + return EntityDoiEntity._doi; + else if (item.match(EntityDoiEntity._repositoryId)) + return EntityDoiEntity._repositoryId; + else if (item.match(EntityDoiEntity._entityId)) + return EntityDoiEntity._entityId; + else if (item.match(EntityDoiEntity._entityType)) + return EntityDoiEntity._entityType; + else if (item.match(EntityDoiEntity._createdAt)) + return EntityDoiEntity._createdAt; + else if (item.match(EntityDoiEntity._updatedAt)) + return EntityDoiEntity._updatedAt; + else if (item.match(EntityDoiEntity._isActive)) + return EntityDoiEntity._isActive; + else + return null; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/query/lookup/DescriptionTemplateTypeLookup.java b/dmp-backend/core/src/main/java/eu/eudat/query/lookup/DescriptionTemplateTypeLookup.java index 26192428a..f12fe2bf9 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/query/lookup/DescriptionTemplateTypeLookup.java +++ b/dmp-backend/core/src/main/java/eu/eudat/query/lookup/DescriptionTemplateTypeLookup.java @@ -12,9 +12,13 @@ import java.util.UUID; public class DescriptionTemplateTypeLookup extends Lookup { private String like; + private List isActive; + private List statuses; + private List ids; + private List excludedIds; public String getLike() { @@ -51,11 +55,16 @@ public class DescriptionTemplateTypeLookup extends Lookup { public DescriptionTemplateTypeQuery enrich(QueryFactory queryFactory) { DescriptionTemplateTypeQuery query = queryFactory.query(DescriptionTemplateTypeQuery.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); + 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); diff --git a/dmp-backend/core/src/main/java/eu/eudat/query/lookup/EntityDoiLookup.java b/dmp-backend/core/src/main/java/eu/eudat/query/lookup/EntityDoiLookup.java new file mode 100644 index 000000000..a6c15e357 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/query/lookup/EntityDoiLookup.java @@ -0,0 +1,43 @@ +package eu.eudat.query.lookup; + +import eu.eudat.commons.enums.EntityType; +import eu.eudat.commons.enums.IsActive; +import eu.eudat.query.EntityDoiQuery; +import gr.cite.tools.data.query.Lookup; +import gr.cite.tools.data.query.QueryFactory; + +import java.util.List; +import java.util.UUID; + +public class EntityDoiLookup extends Lookup { + + private List isActive; + + private List types; + + private List ids; + + private List excludedIds; + + private List dois; + + public EntityDoiQuery enrich(QueryFactory queryFactory) { + EntityDoiQuery query = queryFactory.query(EntityDoiQuery.class); + if (this.isActive != null) + query.isActive(this.isActive); + if (this.types != null) + query.types(this.types); + if (this.ids != null) + query.ids(this.ids); + if (this.excludedIds != null) + query.excludedIds(this.excludedIds); + if (this.dois != null) { + query.dois(this.dois); + } + + this.enrichCommon(query); + + return query; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/DescriptionTemplateTypeService.java b/dmp-backend/core/src/main/java/eu/eudat/service/DescriptionTemplateTypeService.java index 35b8473b2..a95a300d1 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/service/DescriptionTemplateTypeService.java +++ b/dmp-backend/core/src/main/java/eu/eudat/service/DescriptionTemplateTypeService.java @@ -12,7 +12,9 @@ import javax.management.InvalidApplicationException; import java.util.UUID; public interface DescriptionTemplateTypeService { + DescriptionTemplateType persist(DescriptionTemplateTypePersist 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/DescriptionTemplateTypeServiceImpl.java b/dmp-backend/core/src/main/java/eu/eudat/service/DescriptionTemplateTypeServiceImpl.java index 188ff36fb..993021564 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/service/DescriptionTemplateTypeServiceImpl.java +++ b/dmp-backend/core/src/main/java/eu/eudat/service/DescriptionTemplateTypeServiceImpl.java @@ -41,17 +41,27 @@ import java.util.UUID; @Service @RequestScope public class DescriptionTemplateTypeServiceImpl implements DescriptionTemplateTypeService { + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionTemplateTypeServiceImpl.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 @@ -88,7 +98,8 @@ public class DescriptionTemplateTypeServiceImpl implements DescriptionTemplateTy DescriptionTemplateTypeEntity data; if (isUpdate) { data = this.entityManager.find(DescriptionTemplateTypeEntity.class, model.getId()); - if (data == null) throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{model.getId(), DescriptionTemplateType.class.getSimpleName()}, LocaleContextHolder.getLocale())); + if (data == null) + throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{model.getId(), DescriptionTemplateType.class.getSimpleName()}, LocaleContextHolder.getLocale())); } else { data = new DescriptionTemplateTypeEntity(); data.setId(UUID.randomUUID()); @@ -99,8 +110,10 @@ public class DescriptionTemplateTypeServiceImpl implements DescriptionTemplateTy data.setName(model.getName()); data.setStatus(model.getStatus()); data.setUpdatedAt(Instant.now()); - if (isUpdate) this.entityManager.merge(data); - else this.entityManager.persist(data); + if (isUpdate) + this.entityManager.merge(data); + else + this.entityManager.persist(data); this.entityManager.flush(); @@ -115,5 +128,6 @@ public class DescriptionTemplateTypeServiceImpl implements DescriptionTemplateTy this.deleterFactory.deleter(DescriptionTemplateTypeDeleter.class).deleteAndSaveByIds(List.of(id)); } + } diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/EntityDoiService.java b/dmp-backend/core/src/main/java/eu/eudat/service/EntityDoiService.java new file mode 100644 index 000000000..df6211d19 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/service/EntityDoiService.java @@ -0,0 +1,22 @@ +package eu.eudat.service; + +import eu.eudat.model.DescriptionTemplateType; +import eu.eudat.model.EntityDoi; +import eu.eudat.model.persist.DescriptionTemplateTypePersist; +import eu.eudat.model.persist.EntityDoiPersist; +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 EntityDoiService { + + EntityDoi persist(EntityDoiPersist 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/EntityDoiServiceImpl.java b/dmp-backend/core/src/main/java/eu/eudat/service/EntityDoiServiceImpl.java new file mode 100644 index 000000000..cbe47a1b2 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/service/EntityDoiServiceImpl.java @@ -0,0 +1,138 @@ +package eu.eudat.service; + +import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.authorization.Permission; +import eu.eudat.commons.JsonHandlingService; +import eu.eudat.commons.enums.EntityType; +import eu.eudat.commons.enums.IsActive; +import eu.eudat.convention.ConventionService; +import eu.eudat.data.DescriptionTemplateTypeEntity; +import eu.eudat.data.EntityDoiEntity; +import eu.eudat.errorcode.ErrorThesaurusProperties; +import eu.eudat.event.DescriptionTemplateTypeTouchedEvent; +import eu.eudat.event.EntityDoiTouchedEvent; +import eu.eudat.event.EventBroker; +import eu.eudat.model.DescriptionTemplateType; +import eu.eudat.model.EntityDoi; +import eu.eudat.model.builder.DescriptionTemplateTypeBuilder; +import eu.eudat.model.builder.EntityDoiBuilder; +import eu.eudat.model.deleter.DescriptionTemplateTypeDeleter; +import eu.eudat.model.deleter.EntityDoiDeleter; +import eu.eudat.model.persist.DescriptionTemplateTypePersist; +import eu.eudat.model.persist.EntityDoiPersist; +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 javax.management.InvalidApplicationException; +import java.time.Instant; +import java.util.Date; +import java.util.List; +import java.util.UUID; + +public class EntityDoiServiceImpl implements EntityDoiService { + + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(EntityDoiServiceImpl.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 EntityDoiServiceImpl( + 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; + } + + public EntityDoi persist(EntityDoiPersist model, FieldSet fields) throws MyForbiddenException, MyValidationException, MyApplicationException, MyNotFoundException, InvalidApplicationException { + logger.debug(new MapLogEntry("persisting data EntityDoi").And("model", model).And("fields", fields)); + + this.authorizationService.authorizeForce(Permission.EditEntityDoi); + + Boolean isUpdate = this.conventionService.isValidGuid(model.getId()); + + EntityDoiEntity data; + if (isUpdate) { + data = this.entityManager.find(EntityDoiEntity.class, model.getId()); + if (data == null) + throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{model.getId(), EntityDoi.class.getSimpleName()}, LocaleContextHolder.getLocale())); + } else { + data = new EntityDoiEntity(); + data.setId(UUID.randomUUID()); + data.setIsActive(IsActive.Active); + data.setCreatedAt(Instant.now()); + } + + data.setEntityType(EntityType.DMP); + data.setEntityId(model.getEntityId()); + data.setRepositoryId(model.getRepositoryId()); + data.setDoi(model.getDoi()); + data.setUpdatedAt(Instant.now()); + if (isUpdate) + this.entityManager.merge(data); + else + this.entityManager.persist(data); + + this.entityManager.flush(); + + this.eventBroker.emit(new EntityDoiTouchedEvent(data.getId())); + return this.builderFactory.builder(EntityDoiBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(BaseFieldSet.build(fields, EntityDoi._id), data); + } + + public void deleteAndSave(UUID id) throws MyForbiddenException, InvalidApplicationException { + logger.debug("deleting dataset: {}", id); + + this.authorizationService.authorizeForce(Permission.DeleteEntityDoi); + + this.deleterFactory.deleter(EntityDoiDeleter.class).deleteAndSaveByIds(List.of(id)); + } + +} diff --git a/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/EntityDoiDao.java b/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/EntityDoiDao.java deleted file mode 100644 index b675cc138..000000000 --- a/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/EntityDoiDao.java +++ /dev/null @@ -1,10 +0,0 @@ -package eu.eudat.data.dao.entities; - -import eu.eudat.data.dao.DatabaseAccessLayer; -import eu.eudat.data.old.EntityDoi; - -import java.util.UUID; - -public interface EntityDoiDao extends DatabaseAccessLayer { - EntityDoi findFromDoi(String doi); -} diff --git a/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/EntityDoiDaoImpl.java b/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/EntityDoiDaoImpl.java deleted file mode 100644 index c955dda63..000000000 --- a/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/EntityDoiDaoImpl.java +++ /dev/null @@ -1,56 +0,0 @@ -package eu.eudat.data.dao.entities; - -import eu.eudat.data.dao.DatabaseAccess; -import eu.eudat.data.dao.databaselayer.service.DatabaseService; -import eu.eudat.data.old.EntityDoi; -import eu.eudat.queryable.QueryableList; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.stereotype.Component; - -import java.util.UUID; -import java.util.concurrent.CompletableFuture; - -@Component("EntityDoiDao") -public class EntityDoiDaoImpl extends DatabaseAccess implements EntityDoiDao { - - @Autowired - public EntityDoiDaoImpl(DatabaseService databaseService){ - super(databaseService); - } - - - @Override - public EntityDoi createOrUpdate(EntityDoi item) { - return this.getDatabaseService().createOrUpdate(item, EntityDoi.class); - } - - @Override - public CompletableFuture createOrUpdateAsync(EntityDoi item) { - return CompletableFuture.supplyAsync(() -> this.createOrUpdate(item)); - } - - @Override - public EntityDoi find(UUID id) { - return this.getDatabaseService().getQueryable(EntityDoi.class).where((builder, root) -> builder.equal(root.get("id"), id)).getSingle(); - } - - @Override - public EntityDoi findFromDoi(String doi) { - return this.getDatabaseService().getQueryable(EntityDoi.class).where((builder, root) -> builder.equal(root.get("doi"), doi)).getSingle(); - } - - @Override - public EntityDoi find(UUID id, String hint) { - return null; - } - - @Override - public void delete(EntityDoi item) { - this.getDatabaseService().delete(item); - } - - @Override - public QueryableList asQueryable() { - return this.getDatabaseService().getQueryable(EntityDoi.class); - } -} diff --git a/dmp-backend/web/src/main/java/eu/eudat/logic/managers/DataManagementPlanManager.java b/dmp-backend/web/src/main/java/eu/eudat/logic/managers/DataManagementPlanManager.java index abeb71ff6..37dca6d08 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/logic/managers/DataManagementPlanManager.java +++ b/dmp-backend/web/src/main/java/eu/eudat/logic/managers/DataManagementPlanManager.java @@ -2,8 +2,10 @@ package eu.eudat.logic.managers; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; +import eu.eudat.commons.enums.EntityType; import eu.eudat.configurations.dynamicgrant.DynamicGrantConfiguration; import eu.eudat.configurations.dynamicgrant.entities.Property; +import eu.eudat.data.EntityDoiEntity; import eu.eudat.data.dao.criteria.*; import eu.eudat.data.dao.entities.*; import eu.eudat.data.old.DescriptionTemplate; @@ -2449,8 +2451,8 @@ public class DataManagementPlanManager { for (DMP dmp: dmps) { if (!dmp.getId().equals(selfId)) { if (dmp.getDois() != null && !dmp.getDois().isEmpty()) { - for (Iterator it = dmp.getDois().iterator(); it.hasNext(); ) { - EntityDoi entityDoi = it.next(); + for (Iterator it = dmp.getDois().iterator(); it.hasNext(); ) { + EntityDoiEntity entityDoi = it.next(); if(entityDoi.getRepositoryId().equals(repositoryId)){ return entityDoi.getDoi(); } @@ -2505,16 +2507,16 @@ public class DataManagementPlanManager { Doi doiModel = null; if (finalDoi != null) { - EntityDoi doiEntity = new EntityDoi(); + EntityDoiEntity doiEntity = new EntityDoiEntity(); doiEntity.setId(UUID.randomUUID()); - doiEntity.setEntityType(EntityDoi.EntityType.DMP); + doiEntity.setEntityType(EntityType.DMP); doiEntity.setDoi(finalDoi); doiEntity.setRepositoryId(depositRequest.getRepositoryId()); - Date now = new Date(); - doiEntity.setCreatedAt(now); - doiEntity.setUpdatedAt(now); - doiEntity.setEntityId(dmp); - apiContext.getOperationsContext().getDatabaseRepository().getEntityDoiDao().createOrUpdate(doiEntity); + doiEntity.setCreatedAt(Instant.now()); + doiEntity.setUpdatedAt(Instant.now()); + doiEntity.setEntityId(dmp.getId()); + //TODO: Save doi +// apiContext.getOperationsContext().getDatabaseRepository().getEntityDoiDao().createOrUpdate(doiEntity); dmp.getDois().add(doiEntity); apiContext.getOperationsContext().getDatabaseRepository().getDmpDao().createOrUpdate(dmp); diff --git a/dmp-backend/web/src/main/java/eu/eudat/logic/services/operations/DatabaseRepository.java b/dmp-backend/web/src/main/java/eu/eudat/logic/services/operations/DatabaseRepository.java index 3e6c949fb..83517459a 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/logic/services/operations/DatabaseRepository.java +++ b/dmp-backend/web/src/main/java/eu/eudat/logic/services/operations/DatabaseRepository.java @@ -3,8 +3,8 @@ package eu.eudat.logic.services.operations; import eu.eudat.data.dao.entities.*; import eu.eudat.data.dao.entities.security.CredentialDao; - public interface DatabaseRepository { + DataRepositoryDao getDataRepositoryDao(); DatasetDao getDatasetDao(); @@ -59,7 +59,5 @@ public interface DatabaseRepository { FileUploadDao getFileUploadDao(); - EntityDoiDao getEntityDoiDao(); - void detachEntity(T entity); } diff --git a/dmp-backend/web/src/main/java/eu/eudat/logic/services/operations/DatabaseRepositoryImpl.java b/dmp-backend/web/src/main/java/eu/eudat/logic/services/operations/DatabaseRepositoryImpl.java index 56d62d3d4..f35b5c3ec 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/logic/services/operations/DatabaseRepositoryImpl.java +++ b/dmp-backend/web/src/main/java/eu/eudat/logic/services/operations/DatabaseRepositoryImpl.java @@ -2,43 +2,66 @@ package eu.eudat.logic.services.operations; import eu.eudat.data.dao.entities.*; import eu.eudat.data.dao.entities.security.CredentialDao; +import jakarta.persistence.EntityManager; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; -import jakarta.persistence.EntityManager; - - @Service("databaseRepository") public class DatabaseRepositoryImpl implements DatabaseRepository { private DataRepositoryDao dataRepositoryDao; + private DatasetDao datasetDao; + private DatasetProfileDao datasetProfileDao; + private DMPDao dmpDao; + private DmpDatasetProfileDao dmpDatasetProfileDao; + private OrganisationDao organisationDao; + private GrantDao GrantDao; + private RegistryDao registryDao; + private ResearcherDao researcherDao; + private ServiceDao serviceDao; + private UserInfoDao userInfoDao; + private InvitationDao invitationDao; + private CredentialDao credentialDao; + private ExternalDatasetDao externalDatasetDao; + private UserRoleDao userRoleDao; + private UserDatasetProfileDao userDatasetProfileDao; + private UserDmpDao userDmpDao; + private ContentDao contentDao; + private DMPProfileDao dmpProfileDao; + private DatasetExternalDatasetDao datasetExternalDatasetDao; + private DatasetServiceDao datasetServiceDao; + private EmailConfirmationDao loginConfirmationEmailDao; + private ProjectDao projectDao; + private FunderDao funderDao; + private LockDao lockDao; + private NotificationDao notificationDao; + private FileUploadDao fileUploadDao; - private EntityDoiDao entityDoiDao; private EntityManager entityManager; @@ -317,16 +340,6 @@ public class DatabaseRepositoryImpl implements DatabaseRepository { this.fileUploadDao = fileUploadDao; } - @Override - public EntityDoiDao getEntityDoiDao() { - return entityDoiDao; - } - - @Autowired - public void setEntityDoiDao(EntityDoiDao entityDoiDao) { - this.entityDoiDao = entityDoiDao; - } - public void detachEntity(T entity) { this.entityManager.detach(entity); } diff --git a/dmp-backend/web/src/main/java/eu/eudat/models/data/doi/Doi.java b/dmp-backend/web/src/main/java/eu/eudat/models/data/doi/Doi.java index 906146129..58fc97398 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/models/data/doi/Doi.java +++ b/dmp-backend/web/src/main/java/eu/eudat/models/data/doi/Doi.java @@ -1,13 +1,13 @@ package eu.eudat.models.data.doi; -import eu.eudat.data.old.EntityDoi; +import eu.eudat.data.EntityDoiEntity; import eu.eudat.models.DataModel; import eu.eudat.models.data.dmp.DataManagementPlan; import java.util.Date; import java.util.UUID; -public class Doi implements DataModel { +public class Doi { private UUID id; private String repositoryId; private String doi; @@ -57,28 +57,25 @@ public class Doi implements DataModel { this.dmp = dmp; } - @Override - public Doi fromDataModel(EntityDoi entity) { + public Doi fromDataModel(EntityDoiEntity entity) { this.id = entity.getId(); this.repositoryId = entity.getRepositoryId(); this.doi = entity.getDoi(); - this.createdAt = entity.getCreatedAt(); - this.updatedAt = entity.getUpdatedAt(); + this.createdAt = Date.from(entity.getCreatedAt()); + this.updatedAt = Date.from(entity.getUpdatedAt()); return this; } - @Override - public EntityDoi toDataModel() throws Exception { - EntityDoi entityDoi = new EntityDoi(); + public EntityDoiEntity toDataModel() throws Exception { + EntityDoiEntity entityDoi = new EntityDoiEntity(); entityDoi.setId(this.id); entityDoi.setRepositoryId(this.repositoryId); entityDoi.setDoi(this.doi); - entityDoi.setCreatedAt(this.createdAt); - entityDoi.setUpdatedAt(this.updatedAt); + entityDoi.setCreatedAt(this.createdAt.toInstant()); + entityDoi.setUpdatedAt(this.updatedAt.toInstant()); return entityDoi; } - @Override public String getHint() { return null; } diff --git a/dmp-backend/web/src/main/java/eu/eudat/models/data/rda/DmpRDAExportModel.java b/dmp-backend/web/src/main/java/eu/eudat/models/data/rda/DmpRDAExportModel.java index 724d667ad..5dc13f059 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/models/data/rda/DmpRDAExportModel.java +++ b/dmp-backend/web/src/main/java/eu/eudat/models/data/rda/DmpRDAExportModel.java @@ -1,8 +1,8 @@ package eu.eudat.models.data.rda; +import eu.eudat.data.EntityDoiEntity; import eu.eudat.data.old.DMP; import eu.eudat.data.old.Dataset; -import eu.eudat.data.old.EntityDoi; import eu.eudat.data.old.UserDMP; import eu.eudat.logic.managers.DatasetManager; import eu.eudat.models.data.security.Principal; @@ -147,7 +147,7 @@ public class DmpRDAExportModel { dmpRda.description = entity.getDescription().replace("\n", " "); if (entity.getDois() != null && !entity.getDois().isEmpty()) { boolean zenodoDoi = false; - for(EntityDoi doi: entity.getDois()){ + for(EntityDoiEntity doi: entity.getDois()){ if(doi.getRepositoryId().equals("Zenodo")){ dmpRda.dmp_id = new IdRDAExportModel(doi.getDoi(), "zenodo"); zenodoDoi = true; diff --git a/dmp-backend/web/src/main/java/eu/eudat/models/rda/mapper/DmpRDAMapper.java b/dmp-backend/web/src/main/java/eu/eudat/models/rda/mapper/DmpRDAMapper.java index e93aa35fd..6ac1c3a02 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/models/rda/mapper/DmpRDAMapper.java +++ b/dmp-backend/web/src/main/java/eu/eudat/models/rda/mapper/DmpRDAMapper.java @@ -1,5 +1,6 @@ package eu.eudat.models.rda.mapper; +import eu.eudat.data.EntityDoiEntity; import eu.eudat.data.old.*; import eu.eudat.logic.services.ApiContext; import eu.eudat.logic.utilities.helpers.StreamDistinctBy; @@ -52,7 +53,7 @@ public class DmpRDAMapper { } Dmp rda = new Dmp(); if (dmp.getDois() != null && !dmp.getDois().isEmpty()) { - for(EntityDoi doi: dmp.getDois()){ + for(EntityDoiEntity doi: dmp.getDois()){ if(doi.getRepositoryId().equals("Zenodo")){ rda.setDmpId(DmpIdRDAMapper.toRDA(doi.getDoi())); } @@ -128,8 +129,9 @@ public class DmpRDAMapper { entity.setLabel(rda.getTitle()); if (rda.getDmpId().getType() == DmpId.Type.DOI) { try { - EntityDoi doi = apiContext.getOperationsContext().getDatabaseRepository().getEntityDoiDao().findFromDoi(rda.getDmpId().getIdentifier()); - Set dois = new HashSet<>(); + //TODO: Find from doi = rda.getDmpId().getIdentifier() + EntityDoiEntity doi = new EntityDoiEntity(); + Set dois = new HashSet<>(); dois.add(doi); entity.setDois(dois); } diff --git a/dmp-backend/web/src/main/java/eu/eudat/publicapi/models/doi/DoiPublicModel.java b/dmp-backend/web/src/main/java/eu/eudat/publicapi/models/doi/DoiPublicModel.java index ec0b12d52..cafb4d86d 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/publicapi/models/doi/DoiPublicModel.java +++ b/dmp-backend/web/src/main/java/eu/eudat/publicapi/models/doi/DoiPublicModel.java @@ -1,12 +1,12 @@ package eu.eudat.publicapi.models.doi; -import eu.eudat.data.old.EntityDoi; +import eu.eudat.data.EntityDoiEntity; import eu.eudat.logic.utilities.helpers.LabelGenerator; import eu.eudat.models.DataModel; import java.util.UUID; -public class DoiPublicModel implements DataModel, LabelGenerator { +public class DoiPublicModel implements LabelGenerator { private UUID id; private String repositoryId; private String doi; @@ -32,17 +32,15 @@ public class DoiPublicModel implements DataModel, Lab this.doi = doi; } - @Override - public DoiPublicModel fromDataModel(EntityDoi entity) { + public DoiPublicModel fromDataModel(EntityDoiEntity entity) { this.id = entity.getId(); this.repositoryId = entity.getRepositoryId(); this.doi = entity.getDoi(); return this; } - @Override - public EntityDoi toDataModel() throws Exception { - EntityDoi entity = new EntityDoi(); + public EntityDoiEntity toDataModel() throws Exception { + EntityDoiEntity entity = new EntityDoiEntity(); entity.setId(this.getId()); entity.setRepositoryId(this.getRepositoryId()); entity.setDoi(this.getDoi()); @@ -54,7 +52,6 @@ public class DoiPublicModel implements DataModel, Lab return this.getDoi(); } - @Override public String getHint() { return null; } diff --git a/dmp-db-scema/updates/00.01.002_Align_Entity_Doi_table.sql b/dmp-db-scema/updates/00.01.002_Align_Entity_Doi_table.sql new file mode 100644 index 000000000..b85c9c7f3 --- /dev/null +++ b/dmp-db-scema/updates/00.01.002_Align_Entity_Doi_table.sql @@ -0,0 +1,23 @@ +ALTER TABLE public."EntityDoi" + RENAME "ID" TO id; + +ALTER TABLE public."EntityDoi" + RENAME "EntityType" TO entity_type; + +ALTER TABLE public."EntityDoi" + RENAME "RepositoryId" TO repository_id; + +ALTER TABLE public."EntityDoi" + RENAME "Doi" TO doi; + +ALTER TABLE public."EntityDoi" + RENAME "CreatedAt" TO created_at; + +ALTER TABLE public."EntityDoi" + RENAME "UpdatedAt" TO updated_at; + +ALTER TABLE public."EntityDoi" + RENAME "EntityId" TO entity_id; + +ALTER TABLE public."EntityDoi" + ADD COLUMN is_active smallint NOT NULL DEFAULT 1 \ No newline at end of file