diff --git a/dmp-backend/core/pom.xml b/dmp-backend/core/pom.xml index fe0ba767e..6f863585b 100644 --- a/dmp-backend/core/pom.xml +++ b/dmp-backend/core/pom.xml @@ -32,7 +32,7 @@ gr.cite validation - 3.0.2 + 3.0.3 gr.cite diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/enums/FieldType.java b/dmp-backend/core/src/main/java/eu/eudat/commons/enums/FieldType.java index 7f5ba87b2..d3fe953ba 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/commons/enums/FieldType.java +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/enums/FieldType.java @@ -81,4 +81,34 @@ public enum FieldType implements DatabaseEnum { public static FieldType of(String i) { return map.get(i); } + + public static boolean isNotImplemented(FieldType fieldType){ + return fieldType.equals(FieldType.EXTERNAL_SELECT) || fieldType.equals(FieldType.INTERNAL_DMP_ENTRIES_RESEARCHERS) || fieldType.equals(FieldType.INTERNAL_DMP_ENTRIES_DMPS) || + fieldType.equals(FieldType.INTERNAL_DMP_ENTRIES_DATASETS); + } + + public static boolean isReferenceType(FieldType fieldType){ + return fieldType.equals(FieldType.ORGANIZATIONS) || fieldType.equals(FieldType.RESEARCHERS) || fieldType.equals(FieldType.SERVICES) || + fieldType.equals(FieldType.REGISTRIES) || fieldType.equals(FieldType.PUBLICATIONS) || fieldType.equals(FieldType.TAXONOMIES)|| + fieldType.equals(FieldType.LICENSES) || fieldType.equals(FieldType.DATA_REPOSITORIES) || fieldType.equals(FieldType.PUB_REPOSITORIES)|| + fieldType.equals(FieldType.JOURNAL_REPOSITORIES) || fieldType.equals(FieldType.EXTERNAL_DATASETS); + } + + public static boolean isTextType(FieldType fieldType){ + return fieldType.equals(FieldType.FREE_TEXT) || fieldType.equals(FieldType.CHECK_BOX) || fieldType.equals(FieldType.TEXT_AREA) || + fieldType.equals(FieldType.RICH_TEXT_AREA) || fieldType.equals(FieldType.UPLOAD) || fieldType.equals(FieldType.BOOLEAN_DECISION) || + fieldType.equals(FieldType.RADIO_BOX) || fieldType.equals(FieldType.CURRENCY); + } + + public static boolean isTextListType(FieldType fieldType){ + return fieldType.equals(FieldType.SELECT) || fieldType.equals(FieldType.TAGS); + } + + public static boolean isDateType(FieldType fieldType){ + return fieldType.equals(FieldType.DATE_PICKER); + } + + public static boolean isExternalIdentifierType(FieldType fieldType){ + return fieldType.equals(FieldType.VALIDATION) || fieldType.equals(FieldType.DATASET_IDENTIFIER) ; + } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/types/description/ExternalIdentifierEntity.java b/dmp-backend/core/src/main/java/eu/eudat/commons/types/description/ExternalIdentifierEntity.java new file mode 100644 index 000000000..42e8cc744 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/types/description/ExternalIdentifierEntity.java @@ -0,0 +1,25 @@ +package eu.eudat.commons.types.description; + +public class ExternalIdentifierEntity { + + private String identifier; + + private String type; + + public String getIdentifier() { + return identifier; + } + + public void setIdentifier(String identifier) { + this.identifier = identifier; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/types/description/FieldEntity.java b/dmp-backend/core/src/main/java/eu/eudat/commons/types/description/FieldEntity.java index e8e060723..0e5dac41a 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/commons/types/description/FieldEntity.java +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/types/description/FieldEntity.java @@ -1,13 +1,44 @@ package eu.eudat.commons.types.description; -public class FieldEntity { - private String value; - public String getValue() { - return value; +import java.time.Instant; +import java.util.List; + +public class FieldEntity { + private String textValue; + private List textListValue; + private Instant dateValue; + private ExternalIdentifierEntity externalIdentifier; + + public String getTextValue() { + return textValue; } - public void setValue(String value) { - this.value = value; + public void setTextValue(String textValue) { + this.textValue = textValue; + } + + public List getTextListValue() { + return textListValue; + } + + public void setTextListValue(List textListValue) { + this.textListValue = textListValue; + } + + public Instant getDateValue() { + return dateValue; + } + + public void setDateValue(Instant dateValue) { + this.dateValue = dateValue; + } + + public ExternalIdentifierEntity getExternalIdentifier() { + return externalIdentifier; + } + + public void setExternalIdentifier(ExternalIdentifierEntity externalIdentifier) { + this.externalIdentifier = externalIdentifier; } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/types/descriptionreference/DescriptionReferenceDataEntity.java b/dmp-backend/core/src/main/java/eu/eudat/commons/types/descriptionreference/DescriptionReferenceDataEntity.java new file mode 100644 index 000000000..b63a2097b --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/types/descriptionreference/DescriptionReferenceDataEntity.java @@ -0,0 +1,15 @@ +package eu.eudat.commons.types.descriptionreference; + +import java.util.UUID; + +public class DescriptionReferenceDataEntity { + private String fieldId; + + public String getFieldId() { + return fieldId; + } + + public void setFieldId(String fieldId) { + this.fieldId = fieldId; + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/types/descriptiontemplate/DefinitionEntity.java b/dmp-backend/core/src/main/java/eu/eudat/commons/types/descriptiontemplate/DefinitionEntity.java index e88d6bc3e..5d6fda2e7 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/commons/types/descriptiontemplate/DefinitionEntity.java +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/types/descriptiontemplate/DefinitionEntity.java @@ -39,6 +39,11 @@ public class DefinitionEntity { } return fieldSetsEntities; } + + public List getFieldSetById(String id) { + return this.getAllFieldSets().stream().filter(x-> id.equals(x.getId())).toList(); + } + public List getFieldById(String id) { return this.getAllField().stream().filter(x-> id.equals(x.getId())).toList(); } diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/types/descriptiontemplate/FieldSetEntity.java b/dmp-backend/core/src/main/java/eu/eudat/commons/types/descriptiontemplate/FieldSetEntity.java index 11f453f73..dc70c2a0a 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/commons/types/descriptiontemplate/FieldSetEntity.java +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/types/descriptiontemplate/FieldSetEntity.java @@ -104,4 +104,8 @@ public class FieldSetEntity { public List getAllField() { return this.getFields() == null ? new ArrayList<>() : this.getFields(); } + + public List getFieldById(String id) { + return this.getAllField().stream().filter(x-> id.equals(x.getId())).toList(); + } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/validation/BaseValidator.java b/dmp-backend/core/src/main/java/eu/eudat/commons/validation/BaseValidator.java index 837c446b2..e9456005f 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/commons/validation/BaseValidator.java +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/validation/BaseValidator.java @@ -49,6 +49,20 @@ public abstract class BaseValidator extends AbstractValidator { return value == null; } + protected boolean isBoolean(String value) { + return value != null && Arrays.stream(new String[]{"true", "false"}) + .anyMatch(b -> b.equalsIgnoreCase(value)); + } + + protected boolean isUUID(String value) { + try { + UUID.fromString(value); + return true; + } catch (Exception e){ + return false; + } + } + protected Boolean isNull(Collection value) { return value == null; } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/DescriptionReference.java b/dmp-backend/core/src/main/java/eu/eudat/model/DescriptionReference.java index 4d5856b36..4e5398702 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/DescriptionReference.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/DescriptionReference.java @@ -1,6 +1,8 @@ package eu.eudat.model; import eu.eudat.commons.enums.IsActive; +import eu.eudat.model.descriptionreference.DescriptionReferenceData; +import eu.eudat.model.dmpreference.DmpReferenceData; import java.time.Instant; import java.util.UUID; @@ -35,6 +37,9 @@ public class DescriptionReference { public static final String _hash = "hash"; + private DescriptionReferenceData data; + public static final String _data = "data"; + public UUID getId() { return id; } @@ -83,6 +88,14 @@ public class DescriptionReference { this.isActive = isActive; } + public DescriptionReferenceData getData() { + return data; + } + + public void setData(DescriptionReferenceData data) { + this.data = data; + } + public String getHash() { return hash; } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionBuilder.java index 66629b89d..5d7c0a6d4 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionBuilder.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionBuilder.java @@ -2,9 +2,12 @@ package eu.eudat.model.builder; import eu.eudat.authorization.AuthorizationFlags; import eu.eudat.commons.JsonHandlingService; +import eu.eudat.commons.XmlHandlingService; import eu.eudat.commons.types.description.PropertyDefinitionEntity; +import eu.eudat.commons.types.descriptiontemplate.DefinitionEntity; import eu.eudat.convention.ConventionService; import eu.eudat.data.DescriptionEntity; +import eu.eudat.data.DescriptionTemplateEntity; import eu.eudat.data.UserRoleEntity; import eu.eudat.model.*; import eu.eudat.model.builder.descriptionpropertiesdefinition.PropertyDefinitionBuilder; @@ -33,18 +36,20 @@ public class DescriptionBuilder extends BaseBuilder authorize = EnumSet.of(AuthorizationFlags.None); @Autowired public DescriptionBuilder( - ConventionService conventionService, - QueryFactory queryFactory, - BuilderFactory builderFactory, JsonHandlingService jsonHandlingService) { + ConventionService conventionService, + QueryFactory queryFactory, + BuilderFactory builderFactory, JsonHandlingService jsonHandlingService, XmlHandlingService xmlHandlingService) { super(conventionService, new LoggerService(LoggerFactory.getLogger(DescriptionBuilder.class))); this.queryFactory = queryFactory; this.builderFactory = builderFactory; this.jsonHandlingService = jsonHandlingService; + this.xmlHandlingService = xmlHandlingService; } public DescriptionBuilder authorize(EnumSet values) { @@ -78,6 +83,9 @@ public class DescriptionBuilder extends BaseBuilder userItemsMap = this.collectUsers(userFields, data); FieldSet definitionPropertiesFields = fields.extractPrefixed(this.asPrefix(Description._properties)); + + Map definitionEntityMap = !definitionPropertiesFields.isEmpty() ? this.collectDescriptionTemplateDefinitions(data) : null; + List models = new ArrayList<>(); for (DescriptionEntity d : data) { Description m = new Description(); @@ -98,7 +106,7 @@ public class DescriptionBuilder extends BaseBuilder collectDescriptionTemplateDefinitions(List data) throws MyApplicationException { + if (data.isEmpty()) + return null; + this.logger.debug("checking related - {}", DefinitionEntity.class.getSimpleName()); + + Map itemMap = new HashMap<>(); + DescriptionTemplateQuery q = this.queryFactory.query(DescriptionTemplateQuery.class).authorize(this.authorize).ids(data.stream().map(DescriptionEntity::getDescriptionTemplateId).distinct().collect(Collectors.toList())); + List items = q.collectAs(new BaseFieldSet().ensure(eu.eudat.model.DescriptionTemplate._id).ensure(DescriptionTemplate._definition)); + for (DescriptionTemplateEntity item : items){ + DefinitionEntity definition =this.xmlHandlingService.fromXmlSafe(DefinitionEntity.class, item.getDefinition()); + itemMap.put(item.getId(), definition); + } + + return itemMap; + } + private Map collectDmps(FieldSet fields, List data) throws MyApplicationException { if (fields.isEmpty() || data.isEmpty()) return null; diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionReferenceBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionReferenceBuilder.java index 4fa6bc883..2e4a6dabb 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionReferenceBuilder.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionReferenceBuilder.java @@ -1,11 +1,17 @@ package eu.eudat.model.builder; import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.commons.JsonHandlingService; +import eu.eudat.commons.types.descriptionreference.DescriptionReferenceDataEntity; +import eu.eudat.commons.types.dmpreference.DmpReferenceDataEntity; import eu.eudat.convention.ConventionService; import eu.eudat.data.DescriptionReferenceEntity; import eu.eudat.model.Description; import eu.eudat.model.DescriptionReference; +import eu.eudat.model.DmpReference; import eu.eudat.model.Reference; +import eu.eudat.model.builder.descriptionreference.DescriptionReferenceDataBuilder; +import eu.eudat.model.builder.dmpreference.DmpReferenceDataBuilder; import eu.eudat.query.DescriptionQuery; import eu.eudat.query.ReferenceQuery; import gr.cite.tools.data.builder.BuilderFactory; @@ -33,14 +39,16 @@ public class DescriptionReferenceBuilder extends BaseBuilder authorize = EnumSet.of(AuthorizationFlags.None); + private final JsonHandlingService jsonHandlingService; @Autowired public DescriptionReferenceBuilder( - ConventionService conventionService, - BuilderFactory builderFactory, QueryFactory queryFactory) { + ConventionService conventionService, + BuilderFactory builderFactory, QueryFactory queryFactory, JsonHandlingService jsonHandlingService) { super(conventionService, new LoggerService(LoggerFactory.getLogger(DescriptionReferenceBuilder.class))); this.builderFactory = builderFactory; this.queryFactory = queryFactory; + this.jsonHandlingService = jsonHandlingService; } public DescriptionReferenceBuilder authorize(EnumSet values) { @@ -60,9 +68,10 @@ public class DescriptionReferenceBuilder extends BaseBuilder descriptionItemsMap = this.collectDescriptions(descriptionFields, data); + + FieldSet dataFields = fields.extractPrefixed(this.asPrefix(DescriptionReference._data)); List models = new ArrayList<>(); - for (DescriptionReferenceEntity d : data) { DescriptionReference m = new DescriptionReference(); if (fields.hasField(this.asIndexer(DescriptionReference._id))) m.setId(d.getId()); @@ -72,7 +81,10 @@ public class DescriptionReferenceBuilder extends BaseBuilder values = objectMapper.readValue(d.getValue(), new TypeReference>() {}); + List values = objectMapper.readValue(d.getTextValue(), new TypeReference>() {}); m.setValues(values); } catch (JsonProcessingException e) { throw new RuntimeException(e); diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/ExternalIdentifierBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/ExternalIdentifierBuilder.java new file mode 100644 index 000000000..4d6c494e3 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/ExternalIdentifierBuilder.java @@ -0,0 +1,60 @@ +package eu.eudat.model.builder.descriptionpropertiesdefinition; + +import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.commons.types.description.ExternalIdentifierEntity; +import eu.eudat.commons.types.description.FieldEntity; +import eu.eudat.convention.ConventionService; +import eu.eudat.model.builder.BaseBuilder; +import eu.eudat.model.descriptionproperties.ExternalIdentifier; +import eu.eudat.model.descriptionproperties.Field; +import eu.eudat.service.fielddatahelper.FieldDataHelperServiceProvider; +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("description.ExternalIdentifierBuilder") +@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) +public class ExternalIdentifierBuilder extends BaseBuilder { + + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); + + @Autowired + public ExternalIdentifierBuilder( + ConventionService conventionService, BuilderFactory builderFactory, FieldDataHelperServiceProvider fieldDataHelperServiceProvider) { + super(conventionService, new LoggerService(LoggerFactory.getLogger(ExternalIdentifierBuilder.class))); + } + + public ExternalIdentifierBuilder 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 (ExternalIdentifierEntity d : data) { + ExternalIdentifier m = new ExternalIdentifier(); + if (fields.hasField(this.asIndexer(ExternalIdentifier._identifier))) m.setIdentifier(d.getIdentifier()); + if (fields.hasField(this.asIndexer(ExternalIdentifier._type))) m.setType(d.getType()); + + 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/descriptionpropertiesdefinition/FieldBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/FieldBuilder.java index 0b1387f96..2b7a5e99e 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/FieldBuilder.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/FieldBuilder.java @@ -1,13 +1,23 @@ package eu.eudat.model.builder.descriptionpropertiesdefinition; import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.commons.enums.FieldType; import eu.eudat.commons.types.description.FieldEntity; import eu.eudat.convention.ConventionService; +import eu.eudat.data.DescriptionReferenceEntity; +import eu.eudat.model.DescriptionReference; +import eu.eudat.model.Reference; import eu.eudat.model.builder.BaseBuilder; +import eu.eudat.model.builder.ReferenceBuilder; import eu.eudat.model.descriptionproperties.Field; +import eu.eudat.model.descriptionproperties.PropertyDefinition; +import eu.eudat.model.persist.descriptionproperties.FieldPersist; +import eu.eudat.query.ReferenceQuery; import eu.eudat.service.fielddatahelper.FieldDataHelperServiceProvider; 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; @@ -18,17 +28,23 @@ import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Component; import java.util.*; +import java.util.stream.Collectors; @Component("description.FieldBuilder") @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) public class FieldBuilder extends BaseBuilder { - + private final BuilderFactory builderFactory; + private final QueryFactory queryFactory; private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); + private eu.eudat.commons.types.descriptiontemplate.FieldEntity fieldEntity; + @Autowired public FieldBuilder( - ConventionService conventionService, BuilderFactory builderFactory, FieldDataHelperServiceProvider fieldDataHelperServiceProvider) { + ConventionService conventionService, BuilderFactory builderFactory, QueryFactory queryFactory) { super(conventionService, new LoggerService(LoggerFactory.getLogger(FieldBuilder.class))); + this.builderFactory = builderFactory; + this.queryFactory = queryFactory; } public FieldBuilder authorize(EnumSet values) { @@ -36,22 +52,71 @@ public class FieldBuilder extends BaseBuilder { return this; } + public FieldBuilder withFieldEntity(eu.eudat.commons.types.descriptiontemplate.FieldEntity fieldEntity) { + this.fieldEntity = fieldEntity; + 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<>(); - + FieldSet externalIdentifierFields = fields.extractPrefixed(this.asPrefix(Field._externalIdentifier)); + + FieldType fieldType = this.fieldEntity != null && this.fieldEntity.getData() != null ? this.fieldEntity.getData().getFieldType() : FieldType.FREE_TEXT; + + FieldSet referenceFields = fields.extractPrefixed(this.asPrefix(Field._references)); + Map referenceItemsMap = FieldType.isReferenceType(fieldType) ? this.collectReferences(referenceFields, data) : null; List models = new ArrayList<>(); for (FieldEntity d : data) { Field m = new Field(); - if (fields.hasField(this.asIndexer(Field._value))) m.setValue(d.getValue()); + if (fields.hasField(this.asIndexer(Field._dateValue)) && FieldType.isDateType(fieldType)) m.setDateValue(d.getDateValue()); + if (fields.hasField(this.asIndexer(Field._textValue)) && FieldType.isTextType(fieldType)) m.setTextValue(d.getTextValue()); + if (fields.hasField(this.asIndexer(Field._textListValue)) && FieldType.isTextListType(fieldType)) m.setTextListValue(d.getTextListValue()); + if (!referenceFields.isEmpty() && FieldType.isReferenceType(fieldType) && referenceItemsMap != null && d.getTextListValue() != null && !d.getTextListValue().isEmpty()) { + m.setReferences(new ArrayList<>()); + for (UUID referenceId : d.getTextListValue().stream().map(UUID::fromString).toList()){ + if (referenceItemsMap.containsKey(referenceId)) m.getReferences().add(referenceItemsMap.get(referenceId)); + } + } + if (!externalIdentifierFields.isEmpty() && d.getExternalIdentifier() != null && FieldType.isExternalIdentifierType(fieldType)) m.setExternalIdentifier(this.builderFactory.builder(ExternalIdentifierBuilder.class).authorize(this.authorize).build(externalIdentifierFields, d.getExternalIdentifier())); models.add(m); } this.logger.debug("build {} items", Optional.of(models).map(List::size).orElse(0)); return models; } + + private Map collectReferences(FieldSet fields, List data) throws MyApplicationException { + if (fields.isEmpty() || data.isEmpty()) + return null; + this.logger.debug("checking related - {}", Reference.class.getSimpleName()); + + Map itemMap; + if (!fields.hasOtherField(this.asIndexer(Reference._id))) { + itemMap = this.asEmpty( + data.stream().map(FieldEntity::getTextListValue).flatMap(List::stream).map(UUID::fromString).distinct().collect(Collectors.toList()), + x -> { + Reference item = new Reference(); + item.setId(x); + return item; + }, + Reference::getId); + } else { + FieldSet clone = new BaseFieldSet(fields.getFields()).ensure(Reference._id); + ReferenceQuery q = this.queryFactory.query(ReferenceQuery.class).authorize(this.authorize).ids(data.stream().map(FieldEntity::getTextListValue).flatMap(List::stream).map(UUID::fromString).distinct().collect(Collectors.toList())); + itemMap = this.builderFactory.builder(ReferenceBuilder.class).authorize(this.authorize).asForeignKey(q, clone, Reference::getId); + } + if (!fields.hasField(Reference._id)) { + itemMap.forEach((id, item) -> { + if (item != null) + item.setId(null); + }); + } + + return itemMap; + } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/PropertyDefinitionBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/PropertyDefinitionBuilder.java index 271585133..022f43a88 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/PropertyDefinitionBuilder.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/PropertyDefinitionBuilder.java @@ -3,9 +3,11 @@ package eu.eudat.model.builder.descriptionpropertiesdefinition; import eu.eudat.authorization.AuthorizationFlags; import eu.eudat.commons.types.description.PropertyDefinitionEntity; import eu.eudat.commons.types.descriptiontemplate.DefinitionEntity; +import eu.eudat.commons.types.descriptiontemplate.FieldSetEntity; import eu.eudat.convention.ConventionService; import eu.eudat.model.builder.BaseBuilder; import eu.eudat.model.descriptiontemplatedefinition.Definition; +import eu.eudat.model.persist.descriptionproperties.PropertyDefinitionPersist; import gr.cite.tools.data.builder.BuilderFactory; import gr.cite.tools.exception.MyApplicationException; import gr.cite.tools.fieldset.FieldSet; @@ -26,6 +28,7 @@ public class PropertyDefinitionBuilder extends BaseBuilder authorize = EnumSet.of(AuthorizationFlags.None); + private DefinitionEntity definition; @Autowired public PropertyDefinitionBuilder( @@ -34,6 +37,11 @@ public class PropertyDefinitionBuilder extends BaseBuilder values) { this.authorize = values; return this; @@ -55,7 +63,8 @@ public class PropertyDefinitionBuilder extends BaseBuilder()); for (String key : d.getFieldSets().keySet()){ - m.getFieldSets().put(key, this.builderFactory.builder(PropertyDefinitionFieldSetBuilder.class).authorize(this.authorize).build(fieldsFields, d.getFieldSets().get(key))); + FieldSetEntity fieldSetEntity = definition != null ? definition.getFieldSetById(key).stream().findFirst().orElse(null) : null; + m.getFieldSets().put(key, this.builderFactory.builder(PropertyDefinitionFieldSetBuilder.class).authorize(this.authorize).withFieldSetEntity(fieldSetEntity).build(fieldsFields, d.getFieldSets().get(key))); } } models.add(m); diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/PropertyDefinitionFieldSetBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/PropertyDefinitionFieldSetBuilder.java index 8c10f96d4..2eb45e1a3 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/PropertyDefinitionFieldSetBuilder.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/PropertyDefinitionFieldSetBuilder.java @@ -2,9 +2,11 @@ package eu.eudat.model.builder.descriptionpropertiesdefinition; import eu.eudat.authorization.AuthorizationFlags; import eu.eudat.commons.types.description.PropertyDefinitionFieldSetEntity; +import eu.eudat.commons.types.descriptiontemplate.FieldSetEntity; import eu.eudat.convention.ConventionService; import eu.eudat.model.builder.BaseBuilder; import eu.eudat.model.descriptionproperties.PropertyDefinitionFieldSet; +import eu.eudat.model.persist.descriptionproperties.PropertyDefinitionFieldSetPersist; import gr.cite.tools.data.builder.BuilderFactory; import gr.cite.tools.exception.MyApplicationException; import gr.cite.tools.fieldset.FieldSet; @@ -24,6 +26,7 @@ public class PropertyDefinitionFieldSetBuilder extends BaseBuilder authorize = EnumSet.of(AuthorizationFlags.None); + private FieldSetEntity fieldSetEntity; @Autowired public PropertyDefinitionFieldSetBuilder( @@ -37,6 +40,11 @@ public class PropertyDefinitionFieldSetBuilder extends BaseBuilder 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)); @@ -50,7 +58,7 @@ public class PropertyDefinitionFieldSetBuilder extends BaseBuilder models = new ArrayList<>(); for (PropertyDefinitionFieldSetEntity d : data) { PropertyDefinitionFieldSet m = new PropertyDefinitionFieldSet(); - if (!itemsFields.isEmpty() && d.getItems() != null) m.setItems(this.builderFactory.builder(PropertyDefinitionFieldSetItemBuilder.class).authorize(this.authorize).build(itemsFields, d.getItems())); + if (!itemsFields.isEmpty() && d.getItems() != null) m.setItems(this.builderFactory.builder(PropertyDefinitionFieldSetItemBuilder.class).withFieldSetEntity(this.fieldSetEntity).authorize(this.authorize).build(itemsFields, d.getItems())); 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/descriptionpropertiesdefinition/PropertyDefinitionFieldSetItemBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/PropertyDefinitionFieldSetItemBuilder.java index 9959d09b8..5e653ea6d 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/PropertyDefinitionFieldSetItemBuilder.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionpropertiesdefinition/PropertyDefinitionFieldSetItemBuilder.java @@ -3,11 +3,14 @@ package eu.eudat.model.builder.descriptionpropertiesdefinition; import eu.eudat.authorization.AuthorizationFlags; import eu.eudat.commons.types.description.PropertyDefinitionEntity; import eu.eudat.commons.types.description.PropertyDefinitionFieldSetItemEntity; +import eu.eudat.commons.types.descriptiontemplate.FieldEntity; +import eu.eudat.commons.types.descriptiontemplate.FieldSetEntity; import eu.eudat.convention.ConventionService; import eu.eudat.model.DescriptionTemplate; import eu.eudat.model.builder.BaseBuilder; import eu.eudat.model.descriptionproperties.PropertyDefinition; import eu.eudat.model.descriptionproperties.PropertyDefinitionFieldSetItem; +import eu.eudat.model.persist.descriptionproperties.PropertyDefinitionFieldSetItemPersist; import gr.cite.tools.data.builder.BuilderFactory; import gr.cite.tools.exception.MyApplicationException; import gr.cite.tools.fieldset.FieldSet; @@ -26,6 +29,7 @@ import java.util.*; public class PropertyDefinitionFieldSetItemBuilder extends BaseBuilder { private final BuilderFactory builderFactory; + private FieldSetEntity fieldSetEntity; private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); @Autowired @@ -40,6 +44,11 @@ public class PropertyDefinitionFieldSetItemBuilder extends BaseBuilder 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)); @@ -58,7 +67,8 @@ public class PropertyDefinitionFieldSetItemBuilder extends BaseBuilder()); for (String key : d.getFields().keySet()){ - m.getFields().put(key, this.builderFactory.builder(FieldBuilder.class).authorize(this.authorize).build(fieldsFields, d.getFields().get(key))); + FieldEntity fieldEntity = fieldSetEntity != null ? fieldSetEntity.getAllField().stream().findFirst().orElse(null) : null; + m.getFields().put(key, this.builderFactory.builder(FieldBuilder.class).authorize(this.authorize).withFieldEntity(fieldEntity).build(fieldsFields, d.getFields().get(key))); } } models.add(m); diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionreference/DescriptionReferenceDataBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionreference/DescriptionReferenceDataBuilder.java new file mode 100644 index 000000000..a1c951652 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/descriptionreference/DescriptionReferenceDataBuilder.java @@ -0,0 +1,55 @@ +package eu.eudat.model.builder.descriptionreference; + +import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.commons.types.descriptionreference.DescriptionReferenceDataEntity; +import eu.eudat.convention.ConventionService; +import eu.eudat.model.builder.BaseBuilder; +import eu.eudat.model.descriptionreference.DescriptionReferenceData; +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("referencedescriptionreferencedatabuilder") +@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) +public class DescriptionReferenceDataBuilder extends BaseBuilder { + + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); + + @Autowired + public DescriptionReferenceDataBuilder( + ConventionService conventionService) { + super(conventionService, new LoggerService(LoggerFactory.getLogger(DescriptionReferenceDataBuilder.class))); + } + + public DescriptionReferenceDataBuilder 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 + + List models = new ArrayList<>(); + for (DescriptionReferenceDataEntity d : data) { + DescriptionReferenceData m = new DescriptionReferenceData(); + if (fields.hasField(this.asIndexer(DescriptionReferenceData._fieldId))) m.setFieldId(d.getFieldId()); + 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/filetransformer/DescriptionFieldFileTransformerBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/filetransformer/DescriptionFieldFileTransformerBuilder.java index 4e9d4a460..3a21cec3d 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/builder/filetransformer/DescriptionFieldFileTransformerBuilder.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/filetransformer/DescriptionFieldFileTransformerBuilder.java @@ -66,10 +66,10 @@ public class DescriptionFieldFileTransformerBuilder extends BaseFileTransformerB if (fieldEntity.getData() != null) { /*boolean isMultiValue = fieldDataHelperServiceProvider.get(eu.eudat.commons.enums.FieldType.of(fieldEntity.getData().getFieldType().getValue())).isMultiValue(fieldEntity.getData()); if (!isMultiValue) fieldEntity.getData().setValue(List.of(d.getValue()); - else*/ { + else { fieldEntity.getData().setValue(d.getValue()); } - + */ /*switch (field.getData().getFieldType()) { case AUTO_COMPLETE -> m.setFieldType(FieldType.AUTO_COMPLETE); case WORD_LIST -> m.setFieldType(FieldType.WORD_LIST); diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionReferenceCensor.java b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionReferenceCensor.java index eabf97fe6..14970865a 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionReferenceCensor.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionReferenceCensor.java @@ -3,6 +3,7 @@ package eu.eudat.model.censorship; import eu.eudat.authorization.Permission; import eu.eudat.convention.ConventionService; import eu.eudat.model.DescriptionReference; +import eu.eudat.model.censorship.descriptionreference.DescriptionReferenceDataCensor; import gr.cite.commons.web.authz.service.AuthorizationService; import gr.cite.tools.data.censor.CensorFactory; import gr.cite.tools.fieldset.FieldSet; @@ -45,6 +46,8 @@ public class DescriptionReferenceCensor extends BaseCensor { this.censorFactory.censor(DescriptionCensor.class).censor(descriptionFields, userId); FieldSet referenceFields = fields.extractPrefixed(this.asIndexerPrefix(DescriptionReference._reference)); this.censorFactory.censor(ReferenceCensor.class).censor(referenceFields, userId); + FieldSet dataFields = fields.extractPrefixed(this.asIndexerPrefix(DescriptionReference._data)); + this.censorFactory.censor(DescriptionReferenceDataCensor.class).censor(dataFields, userId); } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/censorship/descriptionreference/DescriptionReferenceDataCensor.java b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/descriptionreference/DescriptionReferenceDataCensor.java new file mode 100644 index 000000000..74f530dc7 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/descriptionreference/DescriptionReferenceDataCensor.java @@ -0,0 +1,42 @@ +package eu.eudat.model.censorship.descriptionreference; + +import eu.eudat.authorization.Permission; +import eu.eudat.convention.ConventionService; +import eu.eudat.model.censorship.BaseCensor; +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.annotation.Autowired; +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 DescriptionReferenceDataCensor extends BaseCensor { + + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionReferenceDataCensor.class)); + + protected final AuthorizationService authService; + + + @Autowired + public DescriptionReferenceDataCensor(ConventionService conventionService, + AuthorizationService authService) { + super(conventionService); + this.authService = authService; + } + + public void censor(FieldSet fields, UUID userId) { + logger.debug(new DataLogEntry("censoring fields", fields)); + if (fields == null || fields.isEmpty()) + return; + + this.authService.authorizeForce(Permission.BrowseDescriptionReference); + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/descriptionproperties/ExternalIdentifier.java b/dmp-backend/core/src/main/java/eu/eudat/model/descriptionproperties/ExternalIdentifier.java new file mode 100644 index 000000000..9007f69c6 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/descriptionproperties/ExternalIdentifier.java @@ -0,0 +1,27 @@ +package eu.eudat.model.descriptionproperties; + +public class ExternalIdentifier { + + private String identifier; + public static final String _identifier = "identifier"; + + private String type; + public static final String _type = "type"; + + public String getIdentifier() { + return identifier; + } + + public void setIdentifier(String identifier) { + this.identifier = identifier; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/descriptionproperties/Field.java b/dmp-backend/core/src/main/java/eu/eudat/model/descriptionproperties/Field.java index 654f605fb..0cb6f031f 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/descriptionproperties/Field.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/descriptionproperties/Field.java @@ -1,19 +1,67 @@ package eu.eudat.model.descriptionproperties; +import eu.eudat.commons.enums.FieldType; +import eu.eudat.model.Reference; + +import java.time.Instant; +import java.util.List; + public class Field { + private String textValue; + public static final String _textValue = "textValue"; - public final static String _value = "value"; - private String value; + private List textListValue; + public static final String _textListValue = "textListValue"; - public String getValue() { - return value; + private Instant dateValue; + public static final String _dateValue = "dateValue"; + + private List references; + public static final String _references = "references"; + + private ExternalIdentifier externalIdentifier; + public static final String _externalIdentifier = "externalIdentifier"; + + public String getTextValue() { + return textValue; } - public void setValue(String value) { - this.value = value; + public void setTextValue(String textValue) { + this.textValue = textValue; + } + + public List getTextListValue() { + return textListValue; + } + + public void setTextListValue(List textListValue) { + this.textListValue = textListValue; + } + + public Instant getDateValue() { + return dateValue; + } + + public void setDateValue(Instant dateValue) { + this.dateValue = dateValue; + } + + public List getReferences() { + return references; + } + + public void setReferences(List references) { + this.references = references; + } + + public ExternalIdentifier getExternalIdentifier() { + return externalIdentifier; + } + + public void setExternalIdentifier(ExternalIdentifier externalIdentifier) { + this.externalIdentifier = externalIdentifier; } } - diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/descriptionreference/DescriptionReferenceData.java b/dmp-backend/core/src/main/java/eu/eudat/model/descriptionreference/DescriptionReferenceData.java new file mode 100644 index 000000000..871379615 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/descriptionreference/DescriptionReferenceData.java @@ -0,0 +1,16 @@ +package eu.eudat.model.descriptionreference; + +import java.util.UUID; + +public class DescriptionReferenceData { + private String fieldId; + public final static String _fieldId = "fieldId"; + + public String getFieldId() { + return fieldId; + } + + public void setFieldId(String fieldId) { + this.fieldId = fieldId; + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionPersist.java index 1e4cef9ff..255e251fe 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionPersist.java @@ -1,13 +1,19 @@ package eu.eudat.model.persist; +import eu.eudat.commons.XmlHandlingService; import eu.eudat.commons.enums.DescriptionStatus; +import eu.eudat.commons.types.descriptiontemplate.DefinitionEntity; import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.data.DescriptionTemplateEntity; +import eu.eudat.model.DescriptionTemplate; +import gr.cite.tools.exception.MyNotFoundException; import gr.cite.tools.validation.ValidatorFactory; import gr.cite.tools.validation.specification.Specification; import eu.eudat.convention.ConventionService; import eu.eudat.data.DescriptionEntity; import eu.eudat.errorcode.ErrorThesaurusProperties; import eu.eudat.model.persist.descriptionproperties.PropertyDefinitionPersist; +import jakarta.persistence.EntityManager; import org.springframework.beans.factory.config.ConfigurableBeanFactory; import org.springframework.context.MessageSource; import org.springframework.context.annotation.Scope; @@ -52,9 +58,6 @@ public class DescriptionPersist { public static final String _tags = "tags"; - private List references; - - public static final String _references = "references"; private String hash; @@ -124,14 +127,6 @@ public class DescriptionPersist { this.tags = tags; } - public List getReferences() { - return references; - } - - public void setReferences(List references) { - this.references = references; - } - public String getHash() { return hash; } @@ -157,11 +152,15 @@ public class DescriptionPersist { private final MessageSource messageSource; private final ValidatorFactory validatorFactory; + private final EntityManager entityManager; + private final XmlHandlingService xmlHandlingService; - protected DescriptionPersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource, ValidatorFactory validatorFactory) { + protected DescriptionPersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource, ValidatorFactory validatorFactory, EntityManager entityManager, XmlHandlingService xmlHandlingService) { super(conventionService, errors); this.messageSource = messageSource; this.validatorFactory = validatorFactory; + this.entityManager = entityManager; + this.xmlHandlingService = xmlHandlingService; } @Override @@ -171,6 +170,8 @@ public class DescriptionPersist { @Override protected List specifications(DescriptionPersist item) { + DescriptionTemplateEntity descriptionTemplate = this.isValidGuid(item.getDescriptionTemplateId()) ? this.entityManager.find(DescriptionTemplateEntity.class, item.getDescriptionTemplateId()) : null; + DefinitionEntity definition = descriptionTemplate == null ? null : this.xmlHandlingService.fromXmlSafe(DefinitionEntity.class, descriptionTemplate.getDefinition()); return Arrays.asList( this.spec() .iff(() -> this.isValidGuid(item.getId())) @@ -214,16 +215,7 @@ public class DescriptionPersist { .iff(() -> !this.isNull(item.getProperties())) .on(DescriptionPersist._properties) .over(item.getProperties()) - .using(() -> this.validatorFactory.validator(PropertyDefinitionPersist.PropertyDefinitionPersistValidator.class).setStatus(item.getStatus())), - this.spec() - .iff(() -> item.getStatus() == DescriptionStatus.Finalized) - .must(() -> !this.isListNullOrEmpty(item.getReferences())) - .failOn(DescriptionPersist._references).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionPersist._references}, LocaleContextHolder.getLocale())), - this.navSpec() - .iff(() -> !this.isListNullOrEmpty(item.getReferences())) - .on(DescriptionPersist._references) - .over(item.getReferences()) - .using((itm) -> this.validatorFactory.validator(DescriptionReferencePersist.DescriptionReferencePersistValidator.class)) + .using(() -> this.validatorFactory.validator(PropertyDefinitionPersist.PropertyDefinitionPersistValidator.class).setStatus(item.getStatus()).withDefinition(definition)) ); } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionReferencePersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionReferencePersist.java index 65495d31f..8ddf17435 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionReferencePersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/DescriptionReferencePersist.java @@ -1,6 +1,8 @@ package eu.eudat.model.persist; import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.model.persist.descriptionreference.DescriptionReferenceDataPersist; +import eu.eudat.model.persist.dmpreference.DmpReferenceDataPersist; import gr.cite.tools.validation.ValidatorFactory; import gr.cite.tools.validation.specification.Specification; import eu.eudat.convention.ConventionService; @@ -17,23 +19,15 @@ import java.util.UUID; public class DescriptionReferencePersist { - private UUID id; private ReferencePersist reference = null; public static final String _reference = "reference"; - private String hash; - public static final String _hash = "hash"; + private DescriptionReferenceDataPersist data; - public UUID getId() { - return id; - } - - public void setId(UUID id) { - this.id = id; - } + public static final String _data = "data"; public ReferencePersist getReference() { return reference; @@ -43,12 +37,12 @@ public class DescriptionReferencePersist { this.reference = reference; } - public String getHash() { - return hash; + public DescriptionReferenceDataPersist getData() { + return data; } - public void setHash(String hash) { - this.hash = hash; + public void setData(DescriptionReferenceDataPersist data) { + this.data = data; } @Component(DescriptionReferencePersistValidator.ValidatorName) @@ -75,15 +69,6 @@ public class DescriptionReferencePersist { @Override protected List specifications(DescriptionReferencePersist item) { return Arrays.asList( - this.spec() - .iff(() -> this.isValidGuid(item.getId())) - .must(() -> this.isValidHash(item.getHash())) - .failOn(DescriptionReferencePersist._hash).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionReferencePersist._hash}, LocaleContextHolder.getLocale())), - this.spec() - .iff(() -> !this.isValidGuid(item.getId())) - .must(() -> !this.isValidHash(item.getHash())) - .failOn(DescriptionReferencePersist._hash).failWith(messageSource.getMessage("Validation_OverPosting", new Object[]{}, LocaleContextHolder.getLocale())), - this.spec() .must(() -> !this.isNull(item.getReference())) .failOn(DescriptionReferencePersist._reference).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionReferencePersist._reference}, LocaleContextHolder.getLocale())), @@ -91,7 +76,15 @@ public class DescriptionReferencePersist { .iff(() -> !this.isNull(item.getReference())) .on(DescriptionReferencePersist._reference) .over(item.getReference()) - .using(() -> this.validatorFactory.validator(ReferencePersist.ReferencePersistValidator.class)) + .using(() -> this.validatorFactory.validator(ReferencePersist.ReferencePersistValidator.class)), + this.spec() + .must(() -> !this.isNull(item.getData())) + .failOn(DescriptionReferencePersist._data).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionReferencePersist._data}, LocaleContextHolder.getLocale())), + this.refSpec() + .iff(() -> !this.isNull(item.getData())) + .on(DescriptionReferencePersist._data) + .over(item.getData()) + .using(() -> this.validatorFactory.validator(DmpReferenceDataPersist.DmpReferenceDataPersistValidator.class)) ); } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/DmpReferencePersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/DmpReferencePersist.java index f3d2e8088..bc6ef1b48 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/DmpReferencePersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/DmpReferencePersist.java @@ -67,9 +67,6 @@ public class DmpReferencePersist { @Override protected List specifications(DmpReferencePersist item) { return Arrays.asList( - this.spec() - .must(() -> !this.isNull(item.getData())) - .failOn(DmpReferencePersist._data).failWith(messageSource.getMessage("Validation_Required", new Object[]{DmpReferencePersist._data}, LocaleContextHolder.getLocale())), this.spec() .must(() -> !this.isNull(item.getReference())) .failOn(DmpReferencePersist._reference).failWith(messageSource.getMessage("Validation_Required", new Object[]{DmpReferencePersist._reference}, LocaleContextHolder.getLocale())), diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/ExternalIdentifierPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/ExternalIdentifierPersist.java new file mode 100644 index 000000000..c8e3ec5cc --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/ExternalIdentifierPersist.java @@ -0,0 +1,68 @@ +package eu.eudat.model.persist.descriptionproperties; + +import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.convention.ConventionService; +import eu.eudat.errorcode.ErrorThesaurusProperties; +import gr.cite.tools.validation.specification.Specification; +import org.springframework.context.MessageSource; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Component; + +import java.util.Arrays; +import java.util.List; + +public class ExternalIdentifierPersist { + + private String identifier; + public static final String _identifier = "identifier"; + + private String type; + public static final String _type = "type"; + + public String getIdentifier() { + return identifier; + } + + public void setIdentifier(String identifier) { + this.identifier = identifier; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + @Component(PersistValidator.ValidatorName) + public static class PersistValidator extends BaseValidator { + + public static final String ValidatorName = "Description.ExternalIdentifierPersistPersistValidator"; + + private final MessageSource messageSource; + + protected PersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource) { + super(conventionService, errors); + this.messageSource = messageSource; + } + + @Override + protected Class modelClass() { + return ExternalIdentifierPersist.class; + } + + @Override + protected List specifications(ExternalIdentifierPersist item) { + return Arrays.asList( + this.spec() + .must(() -> !this.isEmpty(item.getIdentifier())) + .failOn(ExternalIdentifierPersist._identifier).failWith(messageSource.getMessage("Validation_Required", new Object[]{ExternalIdentifierPersist._identifier}, LocaleContextHolder.getLocale())), + this.spec() + .must(() -> !this.isEmpty(item.getType())) + .failOn(ExternalIdentifierPersist._type).failWith(messageSource.getMessage("Validation_Required", new Object[]{ExternalIdentifierPersist._type}, LocaleContextHolder.getLocale())) + ); + } + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/FieldPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/FieldPersist.java index e95e6a584..64d6900a1 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/FieldPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/FieldPersist.java @@ -1,6 +1,11 @@ package eu.eudat.model.persist.descriptionproperties; +import eu.eudat.commons.enums.FieldType; +import eu.eudat.commons.types.descriptiontemplate.FieldEntity; import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.model.descriptionproperties.Field; +import eu.eudat.model.persist.ReferencePersist; +import gr.cite.tools.validation.ValidatorFactory; import gr.cite.tools.validation.specification.Specification; import eu.eudat.convention.ConventionService; import eu.eudat.errorcode.ErrorThesaurusProperties; @@ -8,33 +13,81 @@ import org.springframework.context.MessageSource; import org.springframework.context.i18n.LocaleContextHolder; import org.springframework.stereotype.Component; +import java.time.Instant; import java.util.Arrays; import java.util.List; +import java.util.UUID; public class FieldPersist { - private String value; + private String textValue; + public static final String _textValue = "textValue"; - public static final String _value = "value"; + private List textListValue; + public static final String _textListValue = "textListValue"; - public String getValue() { - return value; + private Instant dateValue; + public static final String _dateValue = "dateValue"; + + private List references; + public static final String _references = "references"; + + private ExternalIdentifierPersist externalIdentifier; + public static final String _externalIdentifier = "externalIdentifier"; + + public String getTextValue() { + return textValue; } - public void setValue(String value) { - this.value = value; + public void setTextValue(String textValue) { + this.textValue = textValue; + } + + public List getTextListValue() { + return textListValue; + } + + public void setTextListValue(List textListValue) { + this.textListValue = textListValue; + } + + public Instant getDateValue() { + return dateValue; + } + + public void setDateValue(Instant dateValue) { + this.dateValue = dateValue; + } + + public List getReferences() { + return references; + } + + public void setReferences(List references) { + this.references = references; + } + + public ExternalIdentifierPersist getExternalIdentifier() { + return externalIdentifier; + } + + public void setExternalIdentifier(ExternalIdentifierPersist externalIdentifier) { + this.externalIdentifier = externalIdentifier; } @Component(PersistValidator.ValidatorName) public static class PersistValidator extends BaseValidator { public static final String ValidatorName = "Description.FieldPersistValidator"; + private final ValidatorFactory validatorFactory; private final MessageSource messageSource; + private FieldEntity fieldEntity; - protected PersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource) { + protected PersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, ValidatorFactory validatorFactory, MessageSource messageSource) { super(conventionService, errors); - this.messageSource = messageSource; + this.validatorFactory = validatorFactory; + this.messageSource = messageSource; } @Override @@ -44,12 +97,61 @@ public class FieldPersist { @Override protected List specifications(FieldPersist item) { - return Arrays.asList( + FieldType fieldType = this.fieldEntity != null && this.fieldEntity.getData() != null ? this.fieldEntity.getData().getFieldType() : FieldType.FREE_TEXT; + return Arrays.asList( this.spec() - .must(() -> !this.isEmpty(item.getValue())) - .failOn(FieldPersist._value).failWith(messageSource.getMessage("Validation_Required", new Object[]{FieldPersist._value}, LocaleContextHolder.getLocale())) + .iff(()-> FieldType.isNotImplemented(fieldType)) + .must(() -> false) + .failOn(FieldPersist._textValue).failWith("Field Not implemented yet!!"), + this.spec() + .iff(()-> FieldType.isTextType(fieldType)) + .must(() -> !this.isEmpty(item.getTextValue())) + .failOn(FieldPersist._textValue).failWith(messageSource.getMessage("Validation_Required", new Object[]{FieldPersist._textValue}, LocaleContextHolder.getLocale())), + this.spec() + .iff(()-> FieldType.isDateType(fieldType)) + .must(() -> !this.isNull(item.getDateValue())) + .failOn(FieldPersist._dateValue).failWith(messageSource.getMessage("Validation_Required", new Object[]{FieldPersist._dateValue}, LocaleContextHolder.getLocale())), + this.spec() + .iff(()-> FieldType.isExternalIdentifierType(fieldType)) + .must(() -> !this.isNull(item.getExternalIdentifier())) + .failOn(FieldPersist._externalIdentifier).failWith(messageSource.getMessage("Validation_Required", new Object[]{FieldPersist._externalIdentifier}, LocaleContextHolder.getLocale())), + this.spec() + .iff(()-> FieldType.isTextListType(fieldType)) + .must(() -> !this.isNull(item.getTextListValue())) + .failOn(FieldPersist._textListValue).failWith(messageSource.getMessage("Validation_Required", new Object[]{FieldPersist._textListValue}, LocaleContextHolder.getLocale())), + this.spec() + .iff(()-> FieldType.isReferenceType(fieldType)) + .must(() -> !this.isNull(item.getTextListValue())) + .failOn(FieldPersist._textListValue).failWith(messageSource.getMessage("Validation_Required", new Object[]{FieldPersist._textListValue}, LocaleContextHolder.getLocale())), + this.spec() + .iff(()-> !this.isEmpty(item.getTextValue()) && fieldType.equals(FieldType.CHECK_BOX) || fieldType.equals(FieldType.BOOLEAN_DECISION)) + .must(() -> this.isBoolean(item.getTextValue())) + .failOn(FieldPersist._textValue).failWith(messageSource.getMessage("Validation_UnexpectedValue", new Object[]{FieldPersist._textValue}, LocaleContextHolder.getLocale())), + this.spec() + .iff(()-> !this.isEmpty(item.getTextValue()) && fieldType.equals(FieldType.CURRENCY)) + .must(() -> this.isUUID(item.getTextValue())) + .failOn(FieldPersist._textValue).failWith(messageSource.getMessage("Validation_UnexpectedValue", new Object[]{FieldPersist._textValue}, LocaleContextHolder.getLocale())), + this.spec() + .iff(()-> !this.isNull(item.getTextListValue()) && fieldType.equals(FieldType.TAGS)) + .must(() -> item.getTextListValue().stream().allMatch(this::isUUID)) + .failOn(FieldPersist._textListValue).failWith(messageSource.getMessage("Validation_UnexpectedValue", new Object[]{FieldPersist._textListValue}, LocaleContextHolder.getLocale())), + this.navSpec() + .iff(() -> FieldType.isReferenceType(fieldType) && !this.isListNullOrEmpty(item.getReferences())) + .on(FieldPersist._references) + .over(item.getReferences()) + .using((itm) -> this.validatorFactory.validator(ReferencePersist.ReferencePersistValidator.class)), + this.refSpec() + .iff(() -> FieldType.isExternalIdentifierType(fieldType) && !this.isNull(item.getExternalIdentifier())) + .on(FieldPersist._externalIdentifier) + .over(item.getExternalIdentifier()) + .using(() -> this.validatorFactory.validator(ExternalIdentifierPersist.PersistValidator.class)) ); } + + public PersistValidator withFieldEntity(FieldEntity fieldEntity) { + this.fieldEntity = fieldEntity; + return this; + } } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionFieldSetItemPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionFieldSetItemPersist.java index 98dd1f2c1..e028c03ae 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionFieldSetItemPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionFieldSetItemPersist.java @@ -1,5 +1,7 @@ package eu.eudat.model.persist.descriptionproperties; +import eu.eudat.commons.types.descriptiontemplate.FieldEntity; +import eu.eudat.commons.types.descriptiontemplate.FieldSetEntity; import eu.eudat.commons.validation.BaseValidator; import eu.eudat.convention.ConventionService; import eu.eudat.errorcode.ErrorThesaurusProperties; @@ -56,7 +58,7 @@ public class PropertyDefinitionFieldSetItemPersist { private final ValidatorFactory validatorFactory; private final MessageSource messageSource; - + private FieldSetEntity fieldSetEntity; protected PersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, ValidatorFactory validatorFactory, MessageSource messageSource) { super(conventionService, errors); this.validatorFactory = validatorFactory; @@ -79,10 +81,19 @@ public class PropertyDefinitionFieldSetItemPersist { .on(PropertyDefinitionFieldSetItemPersist._fields) .over(item.getFields()) .mapKey((k) -> ((String)k)) - .using((itm) -> this.validatorFactory.validator(FieldPersist.PersistValidator.class)) + .using((itm) -> + { + FieldEntity fieldEntity = fieldSetEntity != null ? fieldSetEntity.getFieldById((String)itm.getKey()).stream().findFirst().orElse(null) : null; + return this.validatorFactory.validator(FieldPersist.PersistValidator.class).withFieldEntity(fieldEntity); + }) ); } + + public PersistValidator withFieldSetEntity(FieldSetEntity fieldSetEntity) { + this.fieldSetEntity = fieldSetEntity; + return this; + } } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionFieldSetPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionFieldSetPersist.java index a2a75ec93..58bd2bf22 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionFieldSetPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionFieldSetPersist.java @@ -1,5 +1,6 @@ package eu.eudat.model.persist.descriptionproperties; +import eu.eudat.commons.types.descriptiontemplate.FieldSetEntity; import eu.eudat.commons.validation.BaseValidator; import eu.eudat.convention.ConventionService; import eu.eudat.errorcode.ErrorThesaurusProperties; @@ -29,13 +30,10 @@ public class PropertyDefinitionFieldSetPersist { public static final String ValidatorName = "Description.PropertyDefinitionFieldSetPersistValidator"; private final ValidatorFactory validatorFactory; - - private final MessageSource messageSource; - + private FieldSetEntity fieldSetEntity; protected PersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, ValidatorFactory validatorFactory, MessageSource messageSource) { super(conventionService, errors); this.validatorFactory = validatorFactory; - this.messageSource = messageSource; } @Override @@ -46,13 +44,18 @@ public class PropertyDefinitionFieldSetPersist { @Override protected List specifications(PropertyDefinitionFieldSetPersist item) { return Arrays.asList( - this.refSpec() + this.navSpec() .iff(() -> !this.isNull(item.getItems())) .on(PropertyDefinitionFieldSetPersist._items) .over(item.getItems()) - .using(() -> this.validatorFactory.validator(PropertyDefinitionFieldSetItemPersist.PersistValidator.class)) + .using((itm) -> this.validatorFactory.validator(PropertyDefinitionFieldSetItemPersist.PersistValidator.class).withFieldSetEntity(this.fieldSetEntity)) ); } + + public PersistValidator withFieldSetEntity(FieldSetEntity fieldSetEntity) { + this.fieldSetEntity = fieldSetEntity; + return this; + } } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionPersist.java index a9c90114f..bb4e0d067 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionPersist.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionproperties/PropertyDefinitionPersist.java @@ -1,6 +1,8 @@ package eu.eudat.model.persist.descriptionproperties; import eu.eudat.commons.enums.DescriptionStatus; +import eu.eudat.commons.types.descriptiontemplate.DefinitionEntity; +import eu.eudat.commons.types.descriptiontemplate.FieldSetEntity; import eu.eudat.commons.validation.BaseValidator; import eu.eudat.convention.ConventionService; import eu.eudat.errorcode.ErrorThesaurusProperties; @@ -42,6 +44,7 @@ public class PropertyDefinitionPersist { private final ValidatorFactory validatorFactory; private DescriptionStatus status; + private DefinitionEntity definition; protected PropertyDefinitionPersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource, ValidatorFactory validatorFactory) { super(conventionService, errors); @@ -67,7 +70,10 @@ public class PropertyDefinitionPersist { .on(PropertyDefinitionPersist._fieldSets) .over(item.getFieldSets()) .mapKey((k) -> ((String)k)) - .using((itm) -> this.validatorFactory.validator(PropertyDefinitionFieldSetPersist.PersistValidator.class)) + .using((itm) -> { + FieldSetEntity fieldSetEntity = definition != null ? definition.getFieldSetById((String)itm.getKey()).stream().findFirst().orElse(null) : null; + return this.validatorFactory.validator(PropertyDefinitionFieldSetPersist.PersistValidator.class).withFieldSetEntity(fieldSetEntity); + }) ); } @@ -76,6 +82,11 @@ public class PropertyDefinitionPersist { this.status = status; return this; } + + public PropertyDefinitionPersistValidator withDefinition(DefinitionEntity definition) { + this.definition = definition; + return this; + } } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionreference/DescriptionReferenceDataPersist.java b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionreference/DescriptionReferenceDataPersist.java new file mode 100644 index 000000000..acc527039 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/persist/descriptionreference/DescriptionReferenceDataPersist.java @@ -0,0 +1,58 @@ +package eu.eudat.model.persist.descriptionreference; + +import eu.eudat.commons.validation.BaseValidator; +import eu.eudat.convention.ConventionService; +import eu.eudat.errorcode.ErrorThesaurusProperties; +import gr.cite.tools.validation.specification.Specification; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.MessageSource; +import org.springframework.context.annotation.Scope; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Component; + +import java.util.Arrays; +import java.util.List; +import java.util.UUID; + +public class DescriptionReferenceDataPersist { + + private String fieldId; + + public static final String _fieldId = "fieldId"; + + public String getFieldId() { + return fieldId; + } + + public void setFieldId(String fieldId) { + this.fieldId = fieldId; + } + + @Component(DescriptionReferenceDataPersistValidator.ValidatorName) + @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public static class DescriptionReferenceDataPersistValidator extends BaseValidator { + + public static final String ValidatorName = "DescriptionReferenceDataPersistValidator"; + private final MessageSource messageSource; + + protected DescriptionReferenceDataPersistValidator(ConventionService conventionService, ErrorThesaurusProperties errors, MessageSource messageSource) { + super(conventionService, errors); + this.messageSource = messageSource; + } + + @Override + protected Class modelClass() { + return DescriptionReferenceDataPersist.class; + } + + @Override + protected List specifications(DescriptionReferenceDataPersist item) { + return Arrays.asList( + this.spec() + .must(() -> !this.isNull(item.getFieldId())) + .failOn(DescriptionReferenceDataPersist._fieldId).failWith(messageSource.getMessage("Validation_Required", new Object[]{DescriptionReferenceDataPersist._fieldId}, LocaleContextHolder.getLocale())) + ); + } + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionServiceImpl.java b/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionServiceImpl.java index 69c295b06..9329be7bd 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionServiceImpl.java +++ b/dmp-backend/core/src/main/java/eu/eudat/service/description/DescriptionServiceImpl.java @@ -4,16 +4,13 @@ import eu.eudat.authorization.AuthorizationFlags; import eu.eudat.authorization.Permission; import eu.eudat.commons.JsonHandlingService; import eu.eudat.commons.XmlHandlingService; -import eu.eudat.commons.enums.ContactInfoType; -import eu.eudat.commons.enums.DescriptionStatus; -import eu.eudat.commons.enums.DmpStatus; -import eu.eudat.commons.enums.IsActive; +import eu.eudat.commons.enums.*; import eu.eudat.commons.enums.notification.NotificationContactType; import eu.eudat.commons.scope.user.UserScope; -import eu.eudat.commons.types.description.FieldEntity; -import eu.eudat.commons.types.description.PropertyDefinitionEntity; -import eu.eudat.commons.types.description.PropertyDefinitionFieldSetEntity; -import eu.eudat.commons.types.description.PropertyDefinitionFieldSetItemEntity; +import eu.eudat.commons.types.description.*; +import eu.eudat.commons.types.descriptionreference.DescriptionReferenceDataEntity; +import eu.eudat.commons.types.descriptiontemplate.FieldSetEntity; +import eu.eudat.commons.types.dmpreference.DmpReferenceDataEntity; import eu.eudat.commons.types.notification.*; import eu.eudat.commons.types.reference.DefinitionEntity; import eu.eudat.configurations.notification.NotificationProperties; @@ -34,10 +31,9 @@ import eu.eudat.model.persist.DescriptionPersist; import eu.eudat.model.persist.DescriptionReferencePersist; import eu.eudat.model.persist.DescriptionStatusPersist; import eu.eudat.model.persist.ReferencePersist; -import eu.eudat.model.persist.descriptionproperties.FieldPersist; -import eu.eudat.model.persist.descriptionproperties.PropertyDefinitionFieldSetItemPersist; -import eu.eudat.model.persist.descriptionproperties.PropertyDefinitionFieldSetPersist; -import eu.eudat.model.persist.descriptionproperties.PropertyDefinitionPersist; +import eu.eudat.model.persist.descriptionproperties.*; +import eu.eudat.model.persist.descriptionreference.DescriptionReferenceDataPersist; +import eu.eudat.model.persist.dmpreference.DmpReferenceDataPersist; import eu.eudat.model.persist.referencedefinition.DefinitionPersist; import eu.eudat.query.*; import eu.eudat.service.elastic.ElasticService; @@ -146,7 +142,7 @@ public class DescriptionServiceImpl implements DescriptionService { @Override public Description persist(DescriptionPersist model, FieldSet fields) throws MyForbiddenException, MyValidationException, MyApplicationException, MyNotFoundException, InvalidApplicationException, IOException { - logger.debug(new MapLogEntry("persisting data dmp").And("model", model).And("fields", fields)); + logger.debug(new MapLogEntry("persisting data description").And("model", model).And("fields", fields)); this.authorizationService.authorizeForce(Permission.EditDescription); @@ -183,7 +179,6 @@ public class DescriptionServiceImpl implements DescriptionService { if (dmp.getStatus().equals(DmpStatus.Finalized) && isUpdate) throw new MyValidationException(this.errors.getDmpIsFinalized().getCode(), this.errors.getDmpIsFinalized().getMessage()); data.setLabel(model.getLabel()); - data.setProperties(this.jsonHandlingService.toJson(this.buildPropertyDefinitionEntity(model.getProperties()))); data.setStatus(model.getStatus()); data.setDescription(model.getDescription()); data.setDescriptionTemplateId(model.getDescriptionTemplateId()); @@ -191,10 +186,20 @@ public class DescriptionServiceImpl implements DescriptionService { if (isUpdate) this.entityManager.merge(data); else this.entityManager.persist(data); - this.persistTags(data.getId(), model.getTags()); - this.persistDescriptionReferences(data.getId(), model.getReferences()); - this.entityManager.flush(); + + eu.eudat.commons.types.descriptiontemplate.DefinitionEntity definition = this.xmlHandlingService.fromXmlSafe(eu.eudat.commons.types.descriptiontemplate.DefinitionEntity.class, descriptionTemplateEntity.getDefinition()); + Map> fieldToReferenceMap = this.patchAndSaveReferences(this.buildDescriptionReferencePersists(model.getProperties()), data.getId()); + + this.entityManager.flush(); + + data.setProperties(this.jsonHandlingService.toJson(this.buildPropertyDefinitionEntity(model.getProperties(), definition, fieldToReferenceMap))); + + this.entityManager.merge(data); + + this.entityManager.flush(); + + this.persistTags(data.getId(), model.getTags()); if (isUpdate){ this.sendNotification(data); @@ -357,50 +362,191 @@ public class DescriptionServiceImpl implements DescriptionService { return this.builderFactory.builder(DescriptionBuilder.class).authorize(AuthorizationFlags.OwnerOrDmpAssociatedOrPermissionOrPublic).build(BaseFieldSet.build(fields, Description._id), data); } - private @NotNull PropertyDefinitionEntity buildPropertyDefinitionEntity(PropertyDefinitionPersist persist){ + private @NotNull PropertyDefinitionEntity buildPropertyDefinitionEntity(PropertyDefinitionPersist persist, eu.eudat.commons.types.descriptiontemplate.DefinitionEntity definition, Map> fieldToReferenceMap){ PropertyDefinitionEntity data = new PropertyDefinitionEntity(); if (persist == null) return data; if (persist.getFieldSets() != null && !persist.getFieldSets().isEmpty()){ data.setFieldSets(new HashMap<>()); for (String key: persist.getFieldSets().keySet()) { - data.getFieldSets().put(key, this.buildPropertyDefinitionFieldSetEntity(persist.getFieldSets().get(key))); + FieldSetEntity fieldSetEntity = definition != null ? definition.getFieldSetById(key).stream().findFirst().orElse(null) : null; + data.getFieldSets().put(key, this.buildPropertyDefinitionFieldSetEntity(persist.getFieldSets().get(key), fieldSetEntity, fieldToReferenceMap)); } } return data; } - private @NotNull PropertyDefinitionFieldSetEntity buildPropertyDefinitionFieldSetEntity(PropertyDefinitionFieldSetPersist persist){ + private @NotNull PropertyDefinitionFieldSetEntity buildPropertyDefinitionFieldSetEntity(PropertyDefinitionFieldSetPersist persist, FieldSetEntity fieldSetEntity, Map> fieldToReferenceMap){ PropertyDefinitionFieldSetEntity data = new PropertyDefinitionFieldSetEntity(); if (persist == null) return data; if (!this.conventionService.isListNullOrEmpty(persist.getItems())){ data.setItems(new ArrayList<>()); - for (PropertyDefinitionFieldSetItemPersist sectionPersist: persist.getItems()) { - data.getItems().add(this.buildPropertyDefinitionFieldSetItemEntity(sectionPersist)); + for (PropertyDefinitionFieldSetItemPersist itemsPersist: persist.getItems()) { + data.getItems().add(this.buildPropertyDefinitionFieldSetItemEntity(itemsPersist, fieldSetEntity, fieldToReferenceMap)); } } return data; } - private @NotNull PropertyDefinitionFieldSetItemEntity buildPropertyDefinitionFieldSetItemEntity(PropertyDefinitionFieldSetItemPersist persist){ + private @NotNull PropertyDefinitionFieldSetItemEntity buildPropertyDefinitionFieldSetItemEntity(PropertyDefinitionFieldSetItemPersist persist, FieldSetEntity fieldSetEntity, Map> fieldToReferenceMap){ PropertyDefinitionFieldSetItemEntity data = new PropertyDefinitionFieldSetItemEntity(); if (persist == null) return data; if (persist.getFields() != null && !persist.getFields().isEmpty()){ data.setFields(new HashMap<>()); for (String key: persist.getFields().keySet()) { - data.getFields().put(key, this.buildFieldEntity(persist.getFields().get(key))); + eu.eudat.commons.types.descriptiontemplate.FieldEntity fieldEntity = fieldSetEntity != null ? fieldSetEntity.getAllField().stream().findFirst().orElse(null) : null; + data.getFields().put(key, this.buildFieldEntity(persist.getFields().get(key), fieldEntity, fieldToReferenceMap)); } } return data; } - private @NotNull FieldEntity buildFieldEntity(FieldPersist persist){ + private @NotNull FieldEntity buildFieldEntity(FieldPersist persist, eu.eudat.commons.types.descriptiontemplate.FieldEntity fieldEntity, Map> fieldToReferenceMap){ + FieldType fieldType = fieldEntity != null && fieldEntity.getData() != null ? fieldEntity.getData().getFieldType() : FieldType.FREE_TEXT; FieldEntity data = new FieldEntity(); if (persist == null) return data; - data.setValue(persist.getValue()); + if (FieldType.isTextType(fieldType)) data.setTextValue(persist.getTextValue()); + else if (FieldType.isDateType(fieldType)) data.setDateValue(persist.getDateValue()); + else if (FieldType.isTextListType(fieldType)) data.setTextListValue(persist.getTextListValue()); + else if (FieldType.isExternalIdentifierType(fieldType) && persist.getExternalIdentifier() != null) data.setExternalIdentifier(this.buildExternalIdentifierEntity(persist.getExternalIdentifier())); + else if (FieldType.isReferenceType(fieldType) && fieldEntity != null ) { + List referenceIds = fieldToReferenceMap.getOrDefault(fieldEntity.getId(), null); + if (referenceIds != null) data.setTextListValue(referenceIds.stream().map(UUID::toString).toList()); + } return data; } + private @NotNull ExternalIdentifierEntity buildExternalIdentifierEntity(ExternalIdentifierPersist persist){ + ExternalIdentifierEntity data = new ExternalIdentifierEntity(); + if (persist == null) return data; + + data.setIdentifier(persist.getIdentifier()); + data.setType(persist.getType()); + return data; + } + + private @NotNull List buildDescriptionReferencePersists(PropertyDefinitionPersist persist){ + List descriptionReferencePersists = new ArrayList<>(); + if (persist.getFieldSets() != null && !persist.getFieldSets().isEmpty()){ + for (PropertyDefinitionFieldSetPersist propertyDefinitionFieldSetPersist: persist.getFieldSets().values()) { + if (this.conventionService.isListNullOrEmpty( propertyDefinitionFieldSetPersist.getItems())) { + for (PropertyDefinitionFieldSetItemPersist definitionFieldSetItemPersist : propertyDefinitionFieldSetPersist.getItems()) { + if (definitionFieldSetItemPersist.getFields() != null && !definitionFieldSetItemPersist.getFields().isEmpty()) { + for (String key : definitionFieldSetItemPersist.getFields().keySet()) { + FieldPersist fieldPersist = definitionFieldSetItemPersist.getFields().get(key); + BuildDescriptionReferencePersist(key, fieldPersist, descriptionReferencePersists); + } + } + } + } + } + } + return descriptionReferencePersists; + } + + private void BuildDescriptionReferencePersist(String fieldId, FieldPersist fieldPersist, List descriptionReferencePersists) { + if (this.conventionService.isListNullOrEmpty(fieldPersist.getReferences())) { + for (ReferencePersist referencePersist : fieldPersist.getReferences()) { + DescriptionReferencePersist descriptionReferencePersist = new DescriptionReferencePersist(); + descriptionReferencePersist.setData(new DescriptionReferenceDataPersist()); + descriptionReferencePersist.getData().setFieldId(fieldId); + descriptionReferencePersist.setReference(referencePersist); + descriptionReferencePersists.add(descriptionReferencePersist); + } + } + } + + private Map> patchAndSaveReferences(List models, UUID descriptionId) throws InvalidApplicationException { + if (models == null) models = new ArrayList<>(); + + Map> fieldToReferenceMap = new HashMap<>(); + + List descriptionReferences = this.queryFactory.query(DescriptionReferenceQuery.class).descriptionIds(descriptionId).collect(); + Map> descriptionReferenceEntityByReferenceId = new HashMap<>(); + for (DescriptionReferenceEntity descriptionReferenceEntity : descriptionReferences){ + List descriptionReferenceEntities = descriptionReferenceEntityByReferenceId.getOrDefault(descriptionReferenceEntity.getReferenceId(), null); + if (descriptionReferenceEntities == null) { + descriptionReferenceEntities = new ArrayList<>(); + descriptionReferenceEntityByReferenceId.put(descriptionReferenceEntity.getReferenceId(), descriptionReferenceEntities); + } + descriptionReferenceEntities.add(descriptionReferenceEntity); + } + + Map descriptionReferenceDataEntityMap = new HashMap<>(); + for (DescriptionReferenceEntity descriptionReferenceEntity : descriptionReferences){ + descriptionReferenceDataEntityMap.put(descriptionReferenceEntity.getId(), this.jsonHandlingService.fromJsonSafe(DescriptionReferenceDataEntity.class, descriptionReferenceEntity.getData())); + } + + List updatedCreatedIds = new ArrayList<>(); + for (DescriptionReferencePersist model : models) { + ReferencePersist referencePersist = model.getReference(); + ReferenceEntity referenceEntity = null; + if (this.conventionService.isValidGuid(referencePersist.getId())){ + referenceEntity = this.entityManager.find(ReferenceEntity.class, referencePersist.getId()); + if (referenceEntity == null) throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{referencePersist.getId(), Reference.class.getSimpleName()}, LocaleContextHolder.getLocale())); + } else { + referenceEntity = this.queryFactory.query(ReferenceQuery.class).sourceTypes(referencePersist.getSourceType()).references(referencePersist.getReference()).first(); + if (referenceEntity == null){ + referenceEntity = new ReferenceEntity(); + referenceEntity.setId(UUID.randomUUID()); + referenceEntity.setIsActive(IsActive.Active); + referenceEntity.setCreatedAt(Instant.now()); + + referenceEntity.setDefinition(this.xmlHandlingService.toXmlSafe(this.buildDefinitionEntity(referencePersist.getDefinition()))); + referenceEntity.setUpdatedAt(Instant.now()); + referenceEntity.setReference(referencePersist.getReference()); + referenceEntity.setAbbreviation(referencePersist.getAbbreviation()); + referenceEntity.setSource(referencePersist.getSource()); + referenceEntity.setSourceType(referencePersist.getSourceType()); + this.entityManager.persist(referenceEntity); + } + } + + DescriptionReferenceEntity data = null; + List descriptionReferenceEntities = descriptionReferenceEntityByReferenceId.getOrDefault(referenceEntity.getId(), new ArrayList<>()); + for (DescriptionReferenceEntity descriptionReferenceEntity : descriptionReferenceEntities){ + DescriptionReferenceDataEntity descriptionReferenceDataEntity = descriptionReferenceDataEntityMap.getOrDefault(descriptionReferenceEntity.getId(), new DescriptionReferenceDataEntity()); + if (Objects.equals(descriptionReferenceDataEntity.getFieldId(), model.getData().getFieldId())){ + data = descriptionReferenceEntity; + break; + } + } + boolean isUpdate = data != null; + + if (!isUpdate) { + data = new DescriptionReferenceEntity(); + data.setId(UUID.randomUUID()); + data.setReferenceId(referenceEntity.getId()); + data.setDescriptionId(descriptionId); + data.setCreatedAt(Instant.now()); + data.setIsActive(IsActive.Active); + data.setData(this.jsonHandlingService.toJsonSafe(this.buildDescriptionReferenceDataEntity(model.getData()))); + } + updatedCreatedIds.add(data.getId()); + + if (model.getData() != null){ + if (!fieldToReferenceMap.containsKey(model.getData().getFieldId())) fieldToReferenceMap.put(model.getData().getFieldId(), new ArrayList<>()); + fieldToReferenceMap.get(model.getData().getFieldId()).add(referenceEntity.getId()); + } + + data.setUpdatedAt(Instant.now()); + + if (isUpdate) this.entityManager.merge(data); + else this.entityManager.persist(data); + } + List toDelete = descriptionReferences.stream().filter(x-> updatedCreatedIds.stream().noneMatch(y-> y.equals(x.getId()))).collect(Collectors.toList()); + this.deleterFactory.deleter(DescriptionReferenceDeleter.class).delete(toDelete); + this.entityManager.flush(); + + return fieldToReferenceMap; + } + + private @NotNull DescriptionReferenceDataEntity buildDescriptionReferenceDataEntity(DescriptionReferenceDataPersist persist){ + DescriptionReferenceDataEntity data = new DescriptionReferenceDataEntity(); + if (persist == null) return data; + data.setFieldId(persist.getFieldId()); + return data; + } private void persistTags(UUID id, List tagLabels) throws InvalidApplicationException { if (tagLabels == null) tagLabels = new ArrayList<>(); @@ -444,75 +590,6 @@ public class DescriptionServiceImpl implements DescriptionService { this.deleterFactory.deleter(DescriptionTagDeleter.class).delete(toDelete); } - private void persistDescriptionReferences(UUID id, List persists) throws InvalidApplicationException { - if (persists == null) persists = new ArrayList<>(); - - List existingItems = this.queryFactory.query(DescriptionReferenceQuery.class).isActive(IsActive.Active).descriptionIds(id).collect(); - Map existingReferencesMap = this.queryFactory.query(ReferenceQuery.class).isActive(IsActive.Active).ids(persists.stream().filter(x-> x.getReference().getId() != null).map(x-> x.getReference().getId()).toList()).collect() - .stream() - .collect(Collectors.toMap(ReferenceEntity::getId, x-> x));; - - List updatedCreatedIds = new ArrayList<>(); - for (DescriptionReferencePersist persist : persists) { - Boolean isUpdate = this.conventionService.isValidGuid(persist.getId()); - - DescriptionReferenceEntity data; - if (isUpdate) { - data = this.entityManager.find(DescriptionReferenceEntity.class, persist.getId()); - if (data == null) throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{persist.getId(), DescriptionReference.class.getSimpleName()}, LocaleContextHolder.getLocale())); - if (!this.conventionService.hashValue(data.getUpdatedAt()).equals(persist.getHash())) throw new MyValidationException(this.errors.getHashConflict().getCode(), this.errors.getHashConflict().getMessage()); - if (!data.getReferenceId().equals(persist.getReference().getId())) throw new MyValidationException("reference can not changed"); - } else { - data = new DescriptionReferenceEntity(); - data.setId(UUID.randomUUID()); - data.setDescriptionId(id); - data.setCreatedAt(Instant.now()); - data.setIsActive(IsActive.Active); - } - - ReferenceEntity reference = this.persistReference(existingReferencesMap, persist.getReference()); - data.setReferenceId(reference.getId()); - data.setUpdatedAt(Instant.now()); - - if (isUpdate) this.entityManager.merge(data); - else this.entityManager.persist(data); - - updatedCreatedIds.add(data.getId()); - } - List toDelete = existingItems.stream().filter(x-> updatedCreatedIds.stream().noneMatch(y-> y.equals(x.getId()))).collect(Collectors.toList()); - - this.deleterFactory.deleter(DescriptionReferenceDeleter.class).delete(toDelete); - } - - private ReferenceEntity persistReference(Map existingReferencesMap , ReferencePersist persist){ - Boolean isUpdate = this.conventionService.isValidGuid(persist.getId()); - - ReferenceEntity data; - if (isUpdate) { - data = this.entityManager.find(ReferenceEntity.class, persist.getId()); - if (data == null) throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{persist.getId(), Reference.class.getSimpleName()}, LocaleContextHolder.getLocale())); - if (!this.conventionService.hashValue(data.getUpdatedAt()).equals(persist.getHash())) throw new MyValidationException(this.errors.getHashConflict().getCode(), this.errors.getHashConflict().getMessage()); - } else { - data = new ReferenceEntity(); - data.setId(UUID.randomUUID()); - data.setCreatedAt(Instant.now()); - data.setIsActive(IsActive.Active); - } - data.setDefinition(this.xmlHandlingService.toXmlSafe(this.buildDefinitionEntity(persist.getDefinition()))); - data.setUpdatedAt(Instant.now()); - data.setReference(persist.getReference()); - data.setAbbreviation(persist.getAbbreviation()); - data.setSource(persist.getSource()); - data.setSourceType(persist.getSourceType()); - data.setUpdatedAt(Instant.now()); - - - if (isUpdate) this.entityManager.merge(data); - else this.entityManager.persist(data); - - return data; - } - private @NotNull DefinitionEntity buildDefinitionEntity(DefinitionPersist persist){ DefinitionEntity data = new DefinitionEntity(); if (persist == null) return data; @@ -556,7 +633,7 @@ public class DescriptionServiceImpl implements DescriptionService { @Override public void clone(UUID dmpId, UUID descriptionId) throws InvalidApplicationException, IOException { - logger.debug("cloning description: {} with dmp: {}", descriptionId, dmpId); + logger.debug("cloning description: {} with description: {}", descriptionId, dmpId); this.authorizationService.authorizeForce(Permission.CloneDescription); diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java b/dmp-backend/core/src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java index 3742c0c0c..2970813b7 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java +++ b/dmp-backend/core/src/main/java/eu/eudat/service/dmp/DmpServiceImpl.java @@ -215,7 +215,7 @@ public class DmpServiceImpl implements DmpService { event.setContactHint(jsonHandlingService.toJsonSafe(contactData)); event.setContactTypeHint(type); - event = this.applyNotificationType(dmp.getStatus(), event); + this.applyNotificationType(dmp.getStatus(), event); NotificationFieldData data = new NotificationFieldData(); List fieldInfoList = new ArrayList<>(); fieldInfoList.add(new FieldInfo("{recipient}", DataType.String, user.getName())); @@ -228,14 +228,14 @@ public class DmpServiceImpl implements DmpService { eventHandler.handle(event); } - private NotifyIntegrationEvent applyNotificationType(DmpStatus status, NotifyIntegrationEvent event) { + private void applyNotificationType(DmpStatus status, NotifyIntegrationEvent event) { switch (status) { case Draft: event.setNotificationType(notificationProperties.getDmpModifiedType()); - return event; + break; case Finalized: event.setNotificationType(notificationProperties.getDmpFinalisedType()); - return event; + break; default: throw new MyApplicationException("Unsupported Dmp Status."); } diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/prefilling/PrefillingServiceImpl.java b/dmp-backend/core/src/main/java/eu/eudat/service/prefilling/PrefillingServiceImpl.java index 82429be9c..13559dd4a 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/service/prefilling/PrefillingServiceImpl.java +++ b/dmp-backend/core/src/main/java/eu/eudat/service/prefilling/PrefillingServiceImpl.java @@ -223,7 +223,7 @@ public class PrefillingServiceImpl implements PrefillingService { if(this.conventionService.isListNullOrEmpty(issuedFieldEntities)){ String issuedIdNode = issuedFieldEntities.getFirst().getId(); String issuedValue = description.getProperties().getFieldSets().values().stream().map(PropertyDefinitionFieldSet::getItems).flatMap(List::stream) - .filter(x-> x.getFields() != null && x.getFields().containsKey(issuedIdNode)).map(x-> x.getFields().get(issuedIdNode).getValue()).findFirst().orElse(null);//TODO + .filter(x-> x.getFields() != null && x.getFields().containsKey(issuedIdNode)).map(x-> x.getFields().get(issuedIdNode).getTextValue()).findFirst().orElse(null); //TODO Update with the new logic of property definition List licStartFieldSetsEntities = definition.getAllFieldSets().stream().filter(x-> x.getAllField() != null && x.getAllField().stream().anyMatch(y-> y.getSchematics() != null && y.getSchematics().contains("rda.dataset.distribution.license.start_date"))).toList(); @@ -299,48 +299,49 @@ public class PrefillingServiceImpl implements PrefillingService { PropertyDefinitionFieldSetItem fieldSetItem = new PropertyDefinitionFieldSetItem(); fieldSetItem.setFields(new HashMap<>()); Field field = new Field(); - switch (fieldEntity.getData().getFieldType()) { - case EXTERNAL_SELECT: - case SELECT: { - if (!parsedValues.stream().allMatch(Objects::isNull)) { - field.setValue(this.jsonHandlingService.toJsonSafe(parseComboBoxValues(fieldEntity, parsedValues))); - } - break; - } - case TAGS: { - if (!parsedValues.isEmpty()) { - field.setValue(jsonHandlingService.toJsonSafe(parseTags(String.join(", ", parsedValues)))); - } - break; - } - case DATASET_IDENTIFIER: { - JSONObject datasetID = new JSONObject(); - datasetID.put("identifier", parsedValue); - if (type.equals(PrefillingServiceImpl.Zenodo)) { - datasetID.put("type", "doi"); - } - field.setValue(datasetID.toString()); - break; - } - case LICENSES: { - List licenses = this.queryFactory.query(ReferenceQuery.class).references(parsedValues).collect(); - LabelAndMultiplicityDataEntity licenseDataEntity = (LabelAndMultiplicityDataEntity) fieldEntity.getData(); - if (licenses != null && !licenses.isEmpty() && licenseDataEntity != null) { - boolean isMultiAutocomplete = licenseDataEntity.getMultipleSelect(); - List licenseModels = this.builderFactory.builder(ReferenceBuilder.class).authorize(AuthorizationFlags.OwnerOrDmpAssociatedOrPermissionOrPublic).build(new BaseFieldSet(), licenses); - if (isMultiAutocomplete) { - field.setValue(jsonHandlingService.toJsonSafe(licenseModels)); - } else { - field.setValue(jsonHandlingService.toJsonSafe(licenseModels.getFirst())); - } - } - - break; - } - default: - field.setValue(parsedValue); - break; - } + //TODO Update with the new logic of property definition +// switch (fieldEntity.getData().getFieldType()) { +// case EXTERNAL_SELECT: +// case SELECT: { +// if (!parsedValues.stream().allMatch(Objects::isNull)) { +// field.setValue(this.jsonHandlingService.toJsonSafe(parseComboBoxValues(fieldEntity, parsedValues))); +// } +// break; +// } +// case TAGS: { +// if (!parsedValues.isEmpty()) { +// field.setValue(jsonHandlingService.toJsonSafe(parseTags(String.join(", ", parsedValues)))); +// } +// break; +// } +// case DATASET_IDENTIFIER: { +// JSONObject datasetID = new JSONObject(); +// datasetID.put("identifier", parsedValue); +// if (type.equals(PrefillingServiceImpl.Zenodo)) { +// datasetID.put("type", "doi"); +// } +// field.setValue(datasetID.toString()); +// break; +// } +// case LICENSES: { +// List licenses = this.queryFactory.query(ReferenceQuery.class).references(parsedValues).collect(); +// LabelAndMultiplicityDataEntity licenseDataEntity = (LabelAndMultiplicityDataEntity) fieldEntity.getData(); +// if (licenses != null && !licenses.isEmpty() && licenseDataEntity != null) { +// boolean isMultiAutocomplete = licenseDataEntity.getMultipleSelect(); +// List licenseModels = this.builderFactory.builder(ReferenceBuilder.class).authorize(AuthorizationFlags.OwnerOrDmpAssociatedOrPermissionOrPublic).build(new BaseFieldSet(), licenses); +// if (isMultiAutocomplete) { +// field.setValue(jsonHandlingService.toJsonSafe(licenseModels)); +// } else { +// field.setValue(jsonHandlingService.toJsonSafe(licenseModels.getFirst())); +// } +// } +// +// break; +// } +// default: +// field.setValue(parsedValue); +// break; +// } fieldSetItem.getFields().put(fieldEntity.getId(), field); return fieldSetItem; } diff --git a/dmp-backend/pom.xml b/dmp-backend/pom.xml index a16c5f273..6dd04a220 100644 --- a/dmp-backend/pom.xml +++ b/dmp-backend/pom.xml @@ -330,7 +330,7 @@ gr.cite validation - 3.0.2 + 3.0.3 gr.cite diff --git a/dmp-backend/web/src/main/java/eu/eudat/controllers/CommonController.java b/dmp-backend/web/src/main/java/eu/eudat/controllers/CommonController.java deleted file mode 100644 index fc846c063..000000000 --- a/dmp-backend/web/src/main/java/eu/eudat/controllers/CommonController.java +++ /dev/null @@ -1,37 +0,0 @@ -package eu.eudat.controllers; - -import eu.eudat.logic.managers.CommonsManager; -import eu.eudat.logic.proxy.config.configloaders.ConfigLoader; -import eu.eudat.models.data.externalurl.ExternalSourcesConfiguration; -import eu.eudat.models.data.helpers.responses.ResponseItem; -import eu.eudat.service.remotefetcher.ExternalUrlConfigProvider; -import eu.eudat.types.ApiMessageCode; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.http.HttpStatus; -import org.springframework.http.ResponseEntity; -import org.springframework.web.bind.annotation.*; - -/** - * Created by ikalyvas on 3/28/2018. - */ -@RestController -@CrossOrigin -@RequestMapping(value = {"/api/common"}) -public class CommonController { - - private ConfigLoader configLoader; - private final ExternalUrlConfigProvider externalUrlConfigProvider; - - @Autowired - public CommonController(ConfigLoader configLoader, ExternalUrlConfigProvider externalUrlConfigProvider) { - this.configLoader = configLoader; - this.externalUrlConfigProvider = externalUrlConfigProvider; - } - - @RequestMapping(method = RequestMethod.GET, value = {"/externalSourcesConfiguration"}, produces = "application/json") - public @ResponseBody - ResponseEntity> getExternalSourcesConfiguration() { - ExternalSourcesConfiguration configuration = CommonsManager.getExternalSourcesConfiguration(configLoader, externalUrlConfigProvider); - return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem().status(ApiMessageCode.NO_MESSAGE).payload(configuration)); - } -}