From 92c165e90441b1625944d1edc1b43415a05efbde Mon Sep 17 00:00:00 2001 From: amentis Date: Fri, 27 Oct 2023 17:35:35 +0300 Subject: [PATCH] add references definition xml,builder, persist --- .../java/eu/eudat/audit/AuditableAction.java | 8 +- .../commons/enums/ReferenceFieldDataType.java | 27 +++ .../types/reference/DefinitionEntity.java | 22 +++ .../commons/types/reference/FieldEntity.java | 47 +++++ .../ReferenceTypeConfiguration.java | 17 ++ .../referencetype/ReferenceTypeField.java | 24 +++ .../ReferenceTypeProperties.java | 163 ++++++++++++++++++ .../main/java/eu/eudat/model/Reference.java | 7 +- .../eudat/model/builder/ReferenceBuilder.java | 15 +- .../DefinitionBuilder.java | 59 +++++++ .../referencedefinition/FieldBuilder.java | 59 +++++++ .../eudat/model/persist/ReferencePersist.java | 123 +++++++++++++ .../DefinitionPersist.java | 21 +++ .../referencedefinition/FieldPersist.java | 47 +++++ .../model/referencedefinition/Definition.java | 17 ++ .../model/referencedefinition/Field.java | 39 +++++ .../data/dao/criteria/ReferenceCriteria.java | 17 ++ .../controllers/v2/ReferenceController.java | 51 +++--- .../services/references/ReferenceService.java | 120 ++++++++++--- .../src/main/resources/config/application.yml | 3 +- .../main/resources/config/reference-type.yml | 65 +++++++ .../common/enum/reference-field-data-type.ts | 4 + .../src/app/core/model/reference/reference.ts | 41 ++++- 23 files changed, 935 insertions(+), 61 deletions(-) create mode 100644 dmp-backend/core/src/main/java/eu/eudat/commons/enums/ReferenceFieldDataType.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/commons/types/reference/DefinitionEntity.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/commons/types/reference/FieldEntity.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/configurations/referencetype/ReferenceTypeConfiguration.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/configurations/referencetype/ReferenceTypeField.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/configurations/referencetype/ReferenceTypeProperties.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/builder/referencedefinition/DefinitionBuilder.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/builder/referencedefinition/FieldBuilder.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/persist/ReferencePersist.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/persist/referencedefinition/DefinitionPersist.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/persist/referencedefinition/FieldPersist.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/referencedefinition/Definition.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/referencedefinition/Field.java create mode 100644 dmp-backend/data/src/main/java/eu/eudat/data/dao/criteria/ReferenceCriteria.java create mode 100644 dmp-backend/web/src/main/resources/config/reference-type.yml create mode 100644 dmp-frontend/src/app/core/common/enum/reference-field-data-type.ts diff --git a/dmp-backend/core/src/main/java/eu/eudat/audit/AuditableAction.java b/dmp-backend/core/src/main/java/eu/eudat/audit/AuditableAction.java index 1c30efefa..fccfe1ef2 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/audit/AuditableAction.java +++ b/dmp-backend/core/src/main/java/eu/eudat/audit/AuditableAction.java @@ -36,9 +36,9 @@ public class AuditableAction { public static final EventId Description_Persist = new EventId(6002, "Description_Persist"); public static final EventId Description_Delete = new EventId(6003, "Description_Delete"); - public static final EventId External_Reference_Query = new EventId(7000, "External_Reference_Query"); - public static final EventId External_Reference_Lookup = new EventId(7001, "External_Reference_Lookup"); - public static final EventId External_Reference_Persist = new EventId(7002, "External_Reference_Persist"); - public static final EventId External_Reference_Delete = new EventId(7003, "External_Reference_Delete"); + public static final EventId Reference_Query = new EventId(7000, "Reference_Query"); + public static final EventId Reference_Lookup = new EventId(7001, "Reference_Lookup"); + public static final EventId Reference_Persist = new EventId(7002, "Reference_Persist"); + public static final EventId Reference_Delete = new EventId(7003, "Reference_Delete"); } diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/enums/ReferenceFieldDataType.java b/dmp-backend/core/src/main/java/eu/eudat/commons/enums/ReferenceFieldDataType.java new file mode 100644 index 000000000..462c3851a --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/enums/ReferenceFieldDataType.java @@ -0,0 +1,27 @@ +package eu.eudat.commons.enums; + +import com.fasterxml.jackson.annotation.JsonValue; +import eu.eudat.data.converters.enums.DatabaseEnum; + +import java.util.Map; + +public enum ReferenceFieldDataType implements DatabaseEnum { + Text((short) 0), + Date((short) 1); + private final Short value; + + ReferenceFieldDataType(Short value) { + this.value = value; + } + + @JsonValue + public Short getValue() { + return value; + } + + private static final Map map = EnumUtils.getEnumValueMap(ReferenceFieldDataType.class); + + public static ReferenceFieldDataType of(Short i) { + return map.get(i); + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/types/reference/DefinitionEntity.java b/dmp-backend/core/src/main/java/eu/eudat/commons/types/reference/DefinitionEntity.java new file mode 100644 index 000000000..bd727133c --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/types/reference/DefinitionEntity.java @@ -0,0 +1,22 @@ +package eu.eudat.commons.types.reference; + +import jakarta.xml.bind.annotation.*; + +import java.util.List; + +@XmlRootElement(name = "definition") +@XmlAccessorType(XmlAccessType.FIELD) +public class DefinitionEntity { + @XmlElementWrapper(name = "fields") + @XmlElement(name = "field") + private List fields; + + public List getFields() { + return fields; + } + + public void setFields(List fields) { + this.fields = fields; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/types/reference/FieldEntity.java b/dmp-backend/core/src/main/java/eu/eudat/commons/types/reference/FieldEntity.java new file mode 100644 index 000000000..7cde86c32 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/types/reference/FieldEntity.java @@ -0,0 +1,47 @@ +package eu.eudat.commons.types.reference; + +import eu.eudat.commons.enums.ReferenceFieldDataType; +import jakarta.xml.bind.annotation.XmlAccessType; +import jakarta.xml.bind.annotation.XmlAccessorType; +import jakarta.xml.bind.annotation.XmlAttribute; +import jakarta.xml.bind.annotation.XmlRootElement; + +@XmlRootElement(name = "field") +@XmlAccessorType(XmlAccessType.FIELD) +public class FieldEntity { + + @XmlAttribute(name = "code") + private String code; + @XmlAttribute(name = "dataType") + private ReferenceFieldDataType dataType; + @XmlAttribute(name = "value") + private String value; + + + public String getCode() { + return code; + } + + public void setCode(String code) { + this.code = code; + } + + + public ReferenceFieldDataType getDataType() { + return dataType; + } + + public void setDataType(ReferenceFieldDataType dataType) { + this.dataType = dataType; + } + + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/configurations/referencetype/ReferenceTypeConfiguration.java b/dmp-backend/core/src/main/java/eu/eudat/configurations/referencetype/ReferenceTypeConfiguration.java new file mode 100644 index 000000000..5276394ee --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/configurations/referencetype/ReferenceTypeConfiguration.java @@ -0,0 +1,17 @@ +package eu.eudat.configurations.referencetype; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.context.annotation.Configuration; + +@Configuration +@EnableConfigurationProperties({ReferenceTypeProperties.class}) +public class ReferenceTypeConfiguration { + + private final ReferenceTypeProperties referenceTypeProperties; + + @Autowired + public ReferenceTypeConfiguration(ReferenceTypeProperties referenceTypeProperties) { + this.referenceTypeProperties = referenceTypeProperties; + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/configurations/referencetype/ReferenceTypeField.java b/dmp-backend/core/src/main/java/eu/eudat/configurations/referencetype/ReferenceTypeField.java new file mode 100644 index 000000000..729880ac4 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/configurations/referencetype/ReferenceTypeField.java @@ -0,0 +1,24 @@ +package eu.eudat.configurations.referencetype; + +public class ReferenceTypeField { + + String code; + + String dataType; + + public String getCode() { + return code; + } + + public void setCode(String code) { + this.code = code; + } + + public String getDataType() { + return dataType; + } + + public void setDataType(String dataType) { + this.dataType = dataType; + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/configurations/referencetype/ReferenceTypeProperties.java b/dmp-backend/core/src/main/java/eu/eudat/configurations/referencetype/ReferenceTypeProperties.java new file mode 100644 index 000000000..3229f73da --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/configurations/referencetype/ReferenceTypeProperties.java @@ -0,0 +1,163 @@ +package eu.eudat.configurations.referencetype; + +import eu.eudat.model.persist.referencedefinition.DefinitionPersist; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.boot.context.properties.bind.ConstructorBinding; + +import java.util.List; +import java.util.Map; + +@ConfigurationProperties(prefix = "reference-type") +public class ReferenceTypeProperties { + + private Map> grant; + private Map> funder; + private Map> researcher; + private Map> service; + private Map> registry; + private Map> project; + private Map> organisation; + private Map> dataset; + private Map> dataRepository; + private Map> pubRepository; + private Map> journal; + private Map> publication; + private Map> licence; + private Map> taxonomy; + + @ConstructorBinding + public ReferenceTypeProperties(Map> grant, Map> funder, + Map> researcher, Map> service, + Map> registry, Map> project, + Map> organisation, Map> dataset, + Map> dataRepository, Map> pubRepository, + Map> journal, Map> publication, + Map> licence, Map> taxonomy) { + this.grant = grant; + this.funder = funder; + this.researcher = researcher; + this.service = service; + this.registry = registry; + this.project = project; + this.organisation = organisation; + this.dataset = dataset; + this.dataRepository = dataRepository; + this.pubRepository = pubRepository; + this.journal = journal; + this.publication = publication; + this.licence = licence; + this.taxonomy = taxonomy; + } + + public Map> getGrant() { + return grant; + } + + public void setGrant(Map> grant) { + this.grant = grant; + } + + public Map> getFunder() { + return funder; + } + + public void setFunder(Map> funder) { + this.funder = funder; + } + + public Map> getResearcher() { + return researcher; + } + + public void setResearcher(Map> researcher) { + this.researcher = researcher; + } + + public Map> getService() { + return service; + } + + public void setService(Map> service) { + this.service = service; + } + + public Map> getRegistry() { + return registry; + } + + public void setRegistry(Map> registry) { + this.registry = registry; + } + + public Map> getProject() { + return project; + } + + public void setProject(Map> project) { + this.project = project; + } + + public Map> getOrganisation() { + return organisation; + } + + public void setOrganisation(Map> organisation) { + this.organisation = organisation; + } + + public Map> getDataset() { + return dataset; + } + + public void setDataset(Map> dataset) { + this.dataset = dataset; + } + + public Map> getDataRepository() { + return dataRepository; + } + + public void setDataRepository(Map> dataRepository) { + this.dataRepository = dataRepository; + } + + public Map> getPubRepository() { + return pubRepository; + } + + public void setPubRepository(Map> pubRepository) { + this.pubRepository = pubRepository; + } + + public Map> getJournal() { + return journal; + } + + public void setJournal(Map> journal) { + this.journal = journal; + } + + public Map> getPublication() { + return publication; + } + + public void setPublication(Map> publication) { + this.publication = publication; + } + + public Map> getLicence() { + return licence; + } + + public void setLicence(Map> licence) { + this.licence = licence; + } + + public Map> getTaxonomy() { + return taxonomy; + } + + public void setTaxonomy(Map> taxonomy) { + this.taxonomy = taxonomy; + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/Reference.java b/dmp-backend/core/src/main/java/eu/eudat/model/Reference.java index 0b2a3beed..e5a7a06c8 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/Reference.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/Reference.java @@ -3,6 +3,7 @@ package eu.eudat.model; import eu.eudat.commons.enums.ReferenceType; import eu.eudat.commons.enums.IsActive; import eu.eudat.commons.enums.SourceType; +import eu.eudat.model.referencedefinition.Definition; import java.time.Instant; import java.util.List; @@ -22,7 +23,7 @@ public class Reference { private String description; public static final String _description = "description"; - private String definition; + private Definition definition; public static final String _definition = "definition"; private String reference; @@ -84,11 +85,11 @@ public class Reference { this.description = description; } - public String getDefinition() { + public Definition getDefinition() { return definition; } - public void setDefinition(String definition) { + public void setDefinition(Definition definition) { this.definition = definition; } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/ReferenceBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/ReferenceBuilder.java index 985f0b94c..c120175c6 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/builder/ReferenceBuilder.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/ReferenceBuilder.java @@ -1,10 +1,13 @@ package eu.eudat.model.builder; import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.commons.XmlHandlingService; +import eu.eudat.commons.types.reference.DefinitionEntity; import eu.eudat.convention.ConventionService; import eu.eudat.data.ReferenceEntity; import eu.eudat.model.DmpReference; import eu.eudat.model.Reference; +import eu.eudat.model.builder.referencedefinition.DefinitionBuilder; import eu.eudat.query.DmpReferenceQuery; import gr.cite.tools.data.builder.BuilderFactory; import gr.cite.tools.data.query.QueryFactory; @@ -28,15 +31,17 @@ public class ReferenceBuilder extends BaseBuilder{ private final BuilderFactory builderFactory; private final QueryFactory queryFactory; + private final XmlHandlingService xmlHandlingService; private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); @Autowired public ReferenceBuilder( ConventionService conventionService, - BuilderFactory builderFactory, QueryFactory queryFactory) { + BuilderFactory builderFactory, QueryFactory queryFactory, XmlHandlingService xmlHandlingService) { super(conventionService, new LoggerService(LoggerFactory.getLogger(ReferenceBuilder.class))); this.builderFactory = builderFactory; this.queryFactory = queryFactory; + this.xmlHandlingService = xmlHandlingService; } public ReferenceBuilder authorize(EnumSet values) { @@ -51,7 +56,8 @@ public class ReferenceBuilder extends BaseBuilder{ if (fields == null || data == null || fields.isEmpty()) return new ArrayList<>(); - //FieldSet userInfoFields = fields.extractPrefixed(this.asPrefix(Reference._createdBy)); + //ToDo FieldSet userInfoFields = fields.extractPrefixed(this.asPrefix(Reference._createdBy)); + FieldSet definitionFields = fields.extractPrefixed(this.asPrefix(Reference._definition)); FieldSet dmpReferencesFields = fields.extractPrefixed(this.asPrefix(Reference._dmpReferences)); Map> dmpReferenceMap = this.collectDmpReferences(dmpReferencesFields, data); @@ -64,7 +70,10 @@ public class ReferenceBuilder extends BaseBuilder{ if (fields.hasField(this.asIndexer(Reference._createdAt))) m.setCreatedAt(d.getCreatedAt()); if (fields.hasField(this.asIndexer(Reference._updatedAt))) m.setUpdatedAt(d.getUpdatedAt()); if (fields.hasField(this.asIndexer(Reference._isActive))) m.setIsActive(d.getIsActive()); - if (fields.hasField(this.asIndexer(Reference._definition))) m.setReference(d.getDefinition()); + if (!definitionFields.isEmpty() && d.getDefinition() != null){ + DefinitionEntity definition = this.xmlHandlingService.fromXmlSafe(DefinitionEntity.class, d.getDefinition()); + m.setDefinition(this.builderFactory.builder(DefinitionBuilder.class).authorize(this.authorize).build(definitionFields, definition)); + } if (fields.hasField(this.asIndexer(Reference._reference))) m.setReference(d.getReference()); if (fields.hasField(this.asIndexer(Reference._abbreviation))) m.setAbbreviation(d.getAbbreviation()); if (fields.hasField(this.asIndexer(Reference._description))) m.setDescription(d.getDescription()); diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/referencedefinition/DefinitionBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/referencedefinition/DefinitionBuilder.java new file mode 100644 index 000000000..6fadedd2d --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/referencedefinition/DefinitionBuilder.java @@ -0,0 +1,59 @@ +package eu.eudat.model.builder.referencedefinition; + +import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.commons.types.reference.DefinitionEntity; +import eu.eudat.convention.ConventionService; +import eu.eudat.model.builder.BaseBuilder; +import eu.eudat.model.referencedefinition.Definition; +import gr.cite.tools.data.builder.BuilderFactory; +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 DefinitionBuilder extends BaseBuilder { + + private final BuilderFactory builderFactory; + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); + + @Autowired + public DefinitionBuilder( + ConventionService conventionService, BuilderFactory builderFactory) { + super(conventionService, new LoggerService(LoggerFactory.getLogger(DefinitionBuilder.class))); + this.builderFactory = builderFactory; + } + + public DefinitionBuilder 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<>(); + + //Not Bulk Build because is XML no interaction with db + FieldSet definitionFields = fields.extractPrefixed(this.asPrefix(Definition._fields)); + + List models = new ArrayList<>(); + for (DefinitionEntity d : data) { + Definition m = new Definition(); + if (!definitionFields.isEmpty() && d.getFields() != null) m.setFields(this.builderFactory.builder(FieldBuilder.class).authorize(this.authorize).build(definitionFields, d.getFields())); + 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/builder/referencedefinition/FieldBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/referencedefinition/FieldBuilder.java new file mode 100644 index 000000000..da39787d2 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/referencedefinition/FieldBuilder.java @@ -0,0 +1,59 @@ +package eu.eudat.model.builder.referencedefinition; + +import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.commons.types.reference.FieldEntity; +import eu.eudat.convention.ConventionService; +import eu.eudat.model.builder.BaseBuilder; +import eu.eudat.model.referencedefinition.Field; +import gr.cite.tools.data.builder.BuilderFactory; +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 FieldBuilder extends BaseBuilder { + + private final BuilderFactory builderFactory; + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); + + @Autowired + public FieldBuilder( + ConventionService conventionService, BuilderFactory builderFactory) { + super(conventionService, new LoggerService(LoggerFactory.getLogger(FieldBuilder.class))); + this.builderFactory = builderFactory; + } + + public FieldBuilder 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 (FieldEntity d : data) { + Field m = new Field(); + if (fields.hasField(this.asIndexer(Field._code))) m.setCode(d.getCode()); + if (fields.hasField(this.asIndexer(Field._dataType))) m.setDataType(d.getDataType()); + if (fields.hasField(this.asIndexer(Field._value))) m.setValue(d.getValue()); + + 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/persist/ReferencePersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/ReferencePersist.java new file mode 100644 index 000000000..12eb99430 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/ReferencePersist.java @@ -0,0 +1,123 @@ +package eu.eudat.model.persist; + +import eu.eudat.commons.enums.ReferenceType; +import eu.eudat.commons.enums.SourceType; +import eu.eudat.commons.validation.FieldNotNullIfOtherSet; +import eu.eudat.commons.validation.ValidEnum; +import eu.eudat.commons.validation.ValidId; +import eu.eudat.model.persist.referencedefinition.DefinitionPersist; +import jakarta.validation.Valid; +import jakarta.validation.constraints.NotEmpty; +import jakarta.validation.constraints.NotNull; +import jakarta.validation.constraints.Size; + +import java.util.UUID; + +@FieldNotNullIfOtherSet(message = "{validation.hashempty}") +public class ReferencePersist { + + @ValidId(message = "{validation.invalidid}") + private UUID id; + + @NotNull(message = "{validation.empty}") + @NotEmpty(message = "{validation.empty}") + @Size(max = 250, message = "{validation.largerthanmax}") + private String label; + + @ValidEnum(message = "{validation.empty}") + private ReferenceType type; + + private String description; + + @Valid + private DefinitionPersist definition; + + @NotNull(message = "{validation.empty}") + @NotEmpty(message = "{validation.empty}") + @Size(max = 1024, message = "{validation.largerthanmax}") + private String reference; + + @Size(max = 50, message = "{validation.largerthanmax}") + private String abbreviation; + + @Size(max = 1024, message = "{validation.largerthanmax}") + private String source; + + @ValidEnum(message = "{validation.empty}") + private SourceType sourceType; + + //private UserInfoPersist createdBy; ToDo + + + 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 ReferenceType getType() { + return type; + } + + public void setType(ReferenceType type) { + this.type = type; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public DefinitionPersist getDefinition() { + return definition; + } + + public void setDefinition(DefinitionPersist definition) { + this.definition = definition; + } + + public String getReference() { + return reference; + } + + public void setReference(String reference) { + this.reference = reference; + } + + public String getAbbreviation() { + return abbreviation; + } + + public void setAbbreviation(String abbreviation) { + this.abbreviation = abbreviation; + } + + public String getSource() { + return source; + } + + public void setSource(String source) { + this.source = source; + } + + public SourceType getSourceType() { + return sourceType; + } + + public void setSourceType(SourceType sourceType) { + this.sourceType = sourceType; + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/referencedefinition/DefinitionPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/referencedefinition/DefinitionPersist.java new file mode 100644 index 000000000..60c8c6881 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/referencedefinition/DefinitionPersist.java @@ -0,0 +1,21 @@ +package eu.eudat.model.persist.referencedefinition; + +import jakarta.validation.Valid; +import jakarta.validation.constraints.NotNull; + +import java.util.List; + +public class DefinitionPersist { + + @NotNull(message = "{validation.empty}") + @Valid + private List fields = null; + + public List getFields() { + return fields; + } + + public void setFields(List fields) { + this.fields = fields; + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/referencedefinition/FieldPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/referencedefinition/FieldPersist.java new file mode 100644 index 000000000..0a53aaadc --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/referencedefinition/FieldPersist.java @@ -0,0 +1,47 @@ +package eu.eudat.model.persist.referencedefinition; + +import eu.eudat.commons.enums.ReferenceFieldDataType; +import eu.eudat.commons.validation.ValidEnum; + +import jakarta.validation.constraints.NotEmpty; +import jakarta.validation.constraints.NotNull; + +public class FieldPersist { + + @NotNull(message = "{validation.empty}") + @NotEmpty(message = "{validation.empty}") + private String code = null; + + @ValidEnum(message = "{validation.empty}") + private ReferenceFieldDataType dataType; + + @NotNull(message = "{validation.empty}") + @NotEmpty(message = "{validation.empty}") + private String value = null; + + public String getCode() { + return code; + } + + public void setCode(String code) { + this.code = code; + } + + public ReferenceFieldDataType getDataType() { + return dataType; + } + + public void setDataType(ReferenceFieldDataType dataType) { + this.dataType = dataType; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } +} + + diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/referencedefinition/Definition.java b/dmp-backend/core/src/main/java/eu/eudat/model/referencedefinition/Definition.java new file mode 100644 index 000000000..3c8bb7b70 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/referencedefinition/Definition.java @@ -0,0 +1,17 @@ +package eu.eudat.model.referencedefinition; + +import java.util.List; + +public class Definition { + + public final static String _fields = "fields"; + private List fields; + + public List getFields() { + return fields; + } + + public void setFields(List fields) { + this.fields = fields; + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/referencedefinition/Field.java b/dmp-backend/core/src/main/java/eu/eudat/model/referencedefinition/Field.java new file mode 100644 index 000000000..5bd9cfec5 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/referencedefinition/Field.java @@ -0,0 +1,39 @@ +package eu.eudat.model.referencedefinition; + +import eu.eudat.commons.enums.ReferenceFieldDataType; + +public class Field { + + public final static String _code = "code"; + private String code; + + public final static String _dataType = "dataType"; + private ReferenceFieldDataType dataType; + + public final static String _value = "value"; + private String value; + + public String getCode() { + return code; + } + + public void setCode(String code) { + this.code = code; + } + + public ReferenceFieldDataType getDataType() { + return dataType; + } + + public void setDataType(ReferenceFieldDataType dataType) { + this.dataType = dataType; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } +} diff --git a/dmp-backend/data/src/main/java/eu/eudat/data/dao/criteria/ReferenceCriteria.java b/dmp-backend/data/src/main/java/eu/eudat/data/dao/criteria/ReferenceCriteria.java new file mode 100644 index 000000000..f6bdc83a5 --- /dev/null +++ b/dmp-backend/data/src/main/java/eu/eudat/data/dao/criteria/ReferenceCriteria.java @@ -0,0 +1,17 @@ +package eu.eudat.data.dao.criteria; + +import eu.eudat.data.ReferenceEntity; + +import java.util.UUID; + +public class ReferenceCriteria extends Criteria{ + + private UUID creationUserId; + + public UUID getCreationUserId() { + return creationUserId; + } + public void setCreationUserId(UUID creationUserId) { + this.creationUserId = creationUserId; + } +} diff --git a/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/ReferenceController.java b/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/ReferenceController.java index 7c51ed60c..f5a5cd41f 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/ReferenceController.java +++ b/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/ReferenceController.java @@ -1,5 +1,6 @@ package eu.eudat.controllers.v2; +import com.fasterxml.jackson.core.JsonProcessingException; import eu.eudat.audit.AuditableAction; import eu.eudat.authorization.AuthorizationFlags; import eu.eudat.authorization.Permission; @@ -13,6 +14,7 @@ import eu.eudat.logic.services.references.ReferenceService; import eu.eudat.model.Reference; import eu.eudat.model.builder.ReferenceBuilder; import eu.eudat.model.censorship.ReferenceCensor; +import eu.eudat.model.persist.ReferencePersist; import eu.eudat.model.result.QueryResult; import eu.eudat.models.data.FetcherReference; import eu.eudat.models.data.helpers.responses.ResponseItem; @@ -30,7 +32,9 @@ import gr.cite.tools.exception.MyNotFoundException; import gr.cite.tools.fieldset.FieldSet; import gr.cite.tools.logging.LoggerService; import gr.cite.tools.logging.MapLogEntry; +import gr.cite.tools.validation.MyValidate; import jakarta.transaction.Transactional; +import jakarta.xml.bind.JAXBException; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.MessageSource; @@ -40,6 +44,8 @@ import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import javax.management.InvalidApplicationException; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.transform.TransformerException; import java.util.AbstractMap; import java.util.List; import java.util.Map; @@ -88,7 +94,7 @@ public class ReferenceController extends BaseController { List models = this.builderFactory.builder(ReferenceBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(lookup.getProject(), datas); long count = (lookup.getMetadata() != null && lookup.getMetadata().getCountAll()) ? query.count() : models.size(); - this.auditService.track(AuditableAction.External_Reference_Query, "lookup", lookup); + this.auditService.track(AuditableAction.Reference_Query, "lookup", lookup); return new QueryResult(models, count); } @@ -104,7 +110,7 @@ public class ReferenceController extends BaseController { if (model == null) throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{id, Reference.class.getSimpleName()}, LocaleContextHolder.getLocale())); - this.auditService.track(AuditableAction.External_Reference_Lookup, Map.ofEntries( + this.auditService.track(AuditableAction.Reference_Lookup, Map.ofEntries( new AbstractMap.SimpleEntry("id", id), new AbstractMap.SimpleEntry("fields", fieldSet) )); @@ -112,6 +118,22 @@ public class ReferenceController extends BaseController { return model; } + @PostMapping("persist") + @Transactional + public Reference persist(@MyValidate @RequestBody ReferencePersist model, FieldSet fieldSet) throws MyApplicationException, MyForbiddenException, MyNotFoundException, InvalidApplicationException, JAXBException, ParserConfigurationException, JsonProcessingException, TransformerException { + logger.debug(new MapLogEntry("persisting" + Reference.class.getSimpleName()).And("model", model).And("fieldSet", fieldSet)); + this.censorFactory.censor(ReferenceCensor.class).censor(fieldSet, null); + + Reference persisted = this.referenceService.persist(model, fieldSet); + + this.auditService.track(AuditableAction.Reference_Persist, Map.ofEntries( + new AbstractMap.SimpleEntry("model", model), + new AbstractMap.SimpleEntry("fields", fieldSet) + )); + //this.auditService.trackIdentity(AuditableAction.IdentityTracking_Action); + return persisted; + } + @GetMapping(path = {"search/{externalType}"}, produces = "application/json") public @ResponseBody ResponseEntity>> searchReference(@PathVariable(value = "externalType") int externalType, @RequestParam(value = "query", required = false) String query, @@ -131,7 +153,7 @@ public class ReferenceController extends BaseController { this.referenceService.deleteAndSave(id); - this.auditService.track(AuditableAction.External_Reference_Delete, "id", id); + this.auditService.track(AuditableAction.Reference_Delete, "id", id); } @@ -145,27 +167,4 @@ public class ReferenceController extends BaseController { // return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem().payload(newExternalReference).status(ApiMessageCode.SUCCESS_MESSAGE)); // } - - - -// @GetMapping(path = {"{externalType}"}, produces = "application/json") -// public @ResponseBody ResponseEntity>> listExternalReferecnes2(@RequestParam(value = "externalType") String externalType, @RequestParam(value = "query", required = false) String query, -// @RequestParam(value = "type", required = false) String type -// ) throws HugeResultSet, NoURLFound, InvalidApplicationException { -// this.authorizationService.authorizeForce(Permission.AuthenticatedRole); -// -// List externalReferences = this.externalReferencesService.getExternalReference2(externalType, query, type); -// return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem>().status(ApiMessageCode.NO_MESSAGE).payload(externalReferences)); -// } -// -// @Transactional -// @PostMapping(value = {"{externalType}/persist"}, consumes = "application/json", produces = "application/json") -// public @ResponseBody -// ResponseEntity> create(@RequestBody ExternalReference2 externalReference) throws Exception { -// this.authorizationService.authorizeForce(Permission.AuthenticatedRole); -// -// ExternalReference2 newExternalReference = this.externalReferencesService.create(externalReference); -// return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem().payload(newExternalReference).status(ApiMessageCode.SUCCESS_MESSAGE)); -// } - } diff --git a/dmp-backend/web/src/main/java/eu/eudat/logic/services/references/ReferenceService.java b/dmp-backend/web/src/main/java/eu/eudat/logic/services/references/ReferenceService.java index e531b4a60..c8ba55201 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/logic/services/references/ReferenceService.java +++ b/dmp-backend/web/src/main/java/eu/eudat/logic/services/references/ReferenceService.java @@ -1,13 +1,18 @@ package eu.eudat.logic.services.references; +import com.fasterxml.jackson.core.JsonProcessingException; +import eu.eudat.authorization.AuthorizationFlags; import eu.eudat.authorization.Permission; +import eu.eudat.commons.XmlHandlingService; +import eu.eudat.commons.enums.IsActive; import eu.eudat.commons.enums.ReferenceType; import eu.eudat.commons.scope.user.UserScope; +import eu.eudat.commons.types.reference.DefinitionEntity; +import eu.eudat.commons.types.reference.FieldEntity; +import eu.eudat.configurations.referencetype.ReferenceTypeProperties; import eu.eudat.convention.ConventionService; -import eu.eudat.data.dao.criteria.DataRepositoryCriteria; -import eu.eudat.data.dao.criteria.ExternalDatasetCriteria; -import eu.eudat.data.dao.criteria.RegistryCriteria; -import eu.eudat.data.dao.criteria.ServiceCriteria; +import eu.eudat.data.ReferenceEntity; +import eu.eudat.data.dao.criteria.*; import eu.eudat.data.old.DataRepository; import eu.eudat.data.old.ExternalDataset; import eu.eudat.data.old.Registry; @@ -18,20 +23,37 @@ import eu.eudat.logic.proxy.config.exceptions.HugeResultSet; import eu.eudat.logic.proxy.config.exceptions.NoURLFound; import eu.eudat.logic.proxy.fetching.RemoteFetcher; import eu.eudat.logic.services.ApiContext; +import eu.eudat.model.Reference; +import eu.eudat.model.builder.ReferenceBuilder; import eu.eudat.model.deleter.ReferenceDeleter; +import eu.eudat.model.persist.ReferencePersist; +import eu.eudat.model.persist.referencedefinition.DefinitionPersist; +import eu.eudat.model.persist.referencedefinition.FieldPersist; import eu.eudat.models.data.FetcherReference; import eu.eudat.queryable.QueryableList; 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 jakarta.xml.bind.JAXBException; +import org.jetbrains.annotations.NotNull; import org.slf4j.LoggerFactory; import org.springframework.context.MessageSource; +import org.springframework.context.i18n.LocaleContextHolder; import javax.management.InvalidApplicationException; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.transform.TransformerException; +import java.time.Instant; import java.util.*; import java.util.stream.Collectors; @@ -49,6 +71,8 @@ public class ReferenceService { private final ConventionService conventionService; private final MessageSource messageSource; private final QueryFactory queryFactory; + private final XmlHandlingService xmlHandlingService; + private final ReferenceTypeProperties referenceTypeProperties; public ReferenceService(ApiContext apiContext, UserScope userScope, @@ -59,7 +83,9 @@ public class ReferenceService { BuilderFactory builderFactory, ConventionService conventionService, MessageSource messageSource, - QueryFactory queryFactory) { + QueryFactory queryFactory, + XmlHandlingService xmlHandlingService, + ReferenceTypeProperties referenceTypeProperties) { this.apiContext = apiContext; this.userScope = userScope; this.remoteFetcher = remoteFetcher; @@ -70,6 +96,68 @@ public class ReferenceService { this.conventionService = conventionService; this.messageSource = messageSource; this.queryFactory = queryFactory; + this.xmlHandlingService = xmlHandlingService; + this.referenceTypeProperties = referenceTypeProperties; + } + + public Reference persist(ReferencePersist model, FieldSet fields) throws MyForbiddenException, MyValidationException, MyApplicationException, MyNotFoundException, InvalidApplicationException, JAXBException, JsonProcessingException, TransformerException, ParserConfigurationException { + logger.debug(new MapLogEntry("persisting data").And("model", model).And("fields", fields)); + + this.authorizationService.authorizeForce(Permission.EditDmpBlueprint); + + Boolean isUpdate = this.conventionService.isValidGuid(model.getId()); + + ReferenceEntity data; + if (isUpdate) { + data = this.entityManager.find(ReferenceEntity.class, model.getId()); + if (data == null) + throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{model.getId(), Reference.class.getSimpleName()}, LocaleContextHolder.getLocale())); + } else { + data = new ReferenceEntity(); + data.setId(UUID.randomUUID()); + data.setIsActive(IsActive.Active); + data.setCreatedAt(Instant.now()); + } + + data.setLabel(model.getLabel()); + data.setType(model.getType()); + data.setDescription(model.getDescription()); + data.setDefinition(this.xmlHandlingService.toXmlSafe(this.buildDefinitionEntity(model.getDefinition()))); + data.setUpdatedAt(Instant.now()); + data.setReference(model.getReference()); + data.setAbbreviation(model.getAbbreviation()); + data.setSource(model.getSource()); + + if (isUpdate) this.entityManager.merge(data); + else this.entityManager.persist(data); + + this.entityManager.flush(); + + return this.builderFactory.builder(ReferenceBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(BaseFieldSet.build(fields, Reference._id), data); + } + + private @NotNull DefinitionEntity buildDefinitionEntity(DefinitionPersist persist){ + DefinitionEntity data = new DefinitionEntity(); + if (persist == null) return data; + if (!this.conventionService.isListNullOrEmpty(persist.getFields())){ + data.setFields(new ArrayList<>()); + for (FieldPersist fieldPersist: persist.getFields()) { + data.getFields().add(this.buildFieldEntity(fieldPersist)); + } + } + + return data; + } + + private @NotNull FieldEntity buildFieldEntity(FieldPersist persist){ + FieldEntity data = new FieldEntity(); + if (persist == null) return data; + + data.setCode(persist.getCode()); + data.setDataType(persist.getDataType()); + data.setCode(persist.getCode()); + + return data; } public void deleteAndSave(UUID id) throws MyForbiddenException, InvalidApplicationException { @@ -80,27 +168,13 @@ public class ReferenceService { this.deleterFactory.deleter(ReferenceDeleter.class).deleteAndSaveByIds(List.of(id)); } - // external references: - // taxonomies, - // licenses, - // publications, - // journals, - // pubRepositories, - // dataRepositories - // registries, - // services public List searchReference(ReferenceType externalType, String query, String type) throws HugeResultSet, NoURLFound, InvalidApplicationException { ExternalUrlCriteria externalUrlCriteria = new ExternalUrlCriteria(query); - List> remoteRepos = null; - if (externalType.equals(ReferenceType.Datasets)){ - remoteRepos = remoteFetcher.getDatasets(externalUrlCriteria, type); - }else { - remoteRepos = this.apiContext.getOperationsContext().getRemoteFetcher().get(externalType, externalUrlCriteria, type); - } + List> remoteRepos = this.apiContext.getOperationsContext().getRemoteFetcher().get(externalType, externalUrlCriteria, type); List list = this.fetchFromDb(externalType, query, type, remoteRepos); - + list.addAll(remoteRepos.stream().map(FetcherReference::fromRemoteModel).toList()); list = list.stream().filter(x -> x.getName().toLowerCase().contains(query.toLowerCase())).collect(Collectors.toList()); list.sort(Comparator.comparing(FetcherReference::getName)); @@ -136,7 +210,7 @@ public class ReferenceService { if (!query.isEmpty()) criteria.setLike(query); criteria.setCreationUserId(this.userScope.getUserId()); - + if (type.equals("")) { List serviceList = (this.apiContext.getOperationsContext().getDatabaseRepository().getServiceDao().getWithCriteria(criteria)).toList(); list = serviceList.stream().map(item -> new FetcherReference().fromService(item)).collect(Collectors.toList()); @@ -156,7 +230,7 @@ public class ReferenceService { case Licenses: break; } - + return list; } diff --git a/dmp-backend/web/src/main/resources/config/application.yml b/dmp-backend/web/src/main/resources/config/application.yml index cd7cfe9ae..39eab1c42 100644 --- a/dmp-backend/web/src/main/resources/config/application.yml +++ b/dmp-backend/web/src/main/resources/config/application.yml @@ -18,4 +18,5 @@ spring: optional:classpath:config/cors.yml[.yml], optional:classpath:config/cors-${spring.profiles.active}.yml[.yml], optional:file:../config/cors-${spring.profiles.active}.yml[.yml], optional:classpath:config/swagger.yml[.yml], optional:classpath:config/swagger-${spring.profiles.active}.yml[.yml], optional:file:../config/swagger-${spring.profiles.active}.yml[.yml], optional:classpath:config/deposit.yml[.yml], optional:classpath:config/deposit-${spring.profiles.active}.yml[.yml], optional:file:../config/deposit-${spring.profiles.active}.yml[.yml], - optional:classpath:config/errors.yml[.yml], optional:classpath:config/errors-${spring.profiles.active}.yml[.yml], optional:file:../config/errors-${spring.profiles.active}.yml[.yml] + optional:classpath:config/errors.yml[.yml], optional:classpath:config/errors-${spring.profiles.active}.yml[.yml], optional:file:../config/errors-${spring.profiles.active}.yml[.yml], + optional:classpath:config/reference-type.yml[.yml], optional:classpath:config/reference-type-${spring.profiles.active}.yml[.yml], optional:file:../config/reference-type-${spring.profiles.active}.yml[.yml] diff --git a/dmp-backend/web/src/main/resources/config/reference-type.yml b/dmp-backend/web/src/main/resources/config/reference-type.yml new file mode 100644 index 000000000..da97e5940 --- /dev/null +++ b/dmp-backend/web/src/main/resources/config/reference-type.yml @@ -0,0 +1,65 @@ +reference-type: + grant: + fields: + - code: startDate + dataType: date + - code: endDate + dataType: date + funder: + fields: + - code: uri + dataType: text + researcher: + fields: + - code: firstName + dataType: text + - code: lastName + dataType: text + - code: uri + dataType: text + service: + fields: + - code: uri + dataType: text + registry: + fields: + - code: uri + dataType: text + project: + fields: + - code: startDate + dataType: date + - code: endDate + dataType: date + organisation: + fields: + - code: pid + dataType: text + - code: uri + dataType: text + - code: pidTypeField + dataType: text + dataset: + fields: + - code: pid + dataType: text + - code: pidTypeField + dataType: text + dataRepository: + fields: + pubRepository: + fields: + journal: + fields: + publication: + fields: + - code: pid + dataType: text + - code: pidTypeField + dataType: text + licence: + fields: + - code: uri + dataType: text + taxonomy: + fields: \ No newline at end of file diff --git a/dmp-frontend/src/app/core/common/enum/reference-field-data-type.ts b/dmp-frontend/src/app/core/common/enum/reference-field-data-type.ts new file mode 100644 index 000000000..a8fc9563b --- /dev/null +++ b/dmp-frontend/src/app/core/common/enum/reference-field-data-type.ts @@ -0,0 +1,4 @@ +export enum ReferenceFieldDataType { + Text = 0, + Date = 1 +} \ No newline at end of file diff --git a/dmp-frontend/src/app/core/model/reference/reference.ts b/dmp-frontend/src/app/core/model/reference/reference.ts index a03191bea..0fdf421a7 100644 --- a/dmp-frontend/src/app/core/model/reference/reference.ts +++ b/dmp-frontend/src/app/core/model/reference/reference.ts @@ -3,13 +3,14 @@ import { IsActive } from "@app/core/common/enum/is-active.enum"; import { SourceType } from "@app/core/common/enum/source-type"; import { UUID } from "crypto"; import { DmpModel } from "../dmp/dmp"; +import { ReferenceFieldDataType } from "@app/core/common/enum/reference-field-data-type"; export interface Reference { id: UUID; label: string; type: ReferenceType; description: string; - definition: string; + definition: Definition; reference: string; abbreviation: string; source: string; @@ -20,13 +21,26 @@ export interface Reference { dmpReferences: DmpReference[]; } +export interface Definition { + fields: Field[]; +} + +export interface Field { + code: string; + dataType: ReferenceFieldDataType; + value: string; +} + export interface DmpReference { id: UUID; dmp: DmpModel; reference: Reference; data: string; + createdAt: Date; + updatedAt: Date; } +// old fetcher export interface FetcherReference { id: string; name: string; @@ -42,4 +56,29 @@ export interface FetcherReference { firstName: string; lastName: string; tag: string; +} + + +// Persist + +export interface ReferencePersist { + id: UUID; + label: string; + type: ReferenceType; + description: string; + definition: DefinitionPersist; + reference: string; + abbreviation: string; + source: string; + sourceType: SourceType; +} + +export interface DefinitionPersist { + fields?: FieldPersist[]; +} + +export interface FieldPersist { + code: string; + dataType: ReferenceFieldDataType; + value: string; } \ No newline at end of file