diff --git a/dmp-backend/core/src/main/java/eu/eudat/commons/enums/UserDescriptionTemplateRole.java b/dmp-backend/core/src/main/java/eu/eudat/commons/enums/UserDescriptionTemplateRole.java new file mode 100644 index 000000000..cc570ad56 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/commons/enums/UserDescriptionTemplateRole.java @@ -0,0 +1,30 @@ +package eu.eudat.commons.enums; + +import com.fasterxml.jackson.annotation.JsonValue; +import eu.eudat.data.converters.enums.DatabaseEnum; + +import java.util.Map; + +public enum UserDescriptionTemplateRole implements DatabaseEnum { + + Owner((short) 0), + Member((short) 1); + + private final Short value; + + UserDescriptionTemplateRole(Short value) { + this.value = value; + } + + @JsonValue + public Short getValue() { + return value; + } + + private static final Map map = EnumUtils.getEnumValueMap(UserDescriptionTemplateRole.class); + + public static UserDescriptionTemplateRole of(Short i) { + return map.get(i); + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/DescriptionTemplateEntity.java b/dmp-backend/core/src/main/java/eu/eudat/data/DescriptionTemplateEntity.java index 855dfddf8..a485dbd04 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/data/DescriptionTemplateEntity.java +++ b/dmp-backend/core/src/main/java/eu/eudat/data/DescriptionTemplateEntity.java @@ -5,7 +5,6 @@ import eu.eudat.commons.enums.DescriptionTemplateStatus; import eu.eudat.commons.enums.IsActive; import eu.eudat.data.converters.enums.DescriptionTemplateStatusConverter; import eu.eudat.data.converters.enums.IsActiveConverter; -import eu.eudat.data.old.UserDatasetProfile; import eu.eudat.queryable.queryableentity.DataEntity; import jakarta.persistence.*; import org.hibernate.annotations.Type; @@ -150,13 +149,6 @@ public class DescriptionTemplateEntity implements DataEntity getUsers() { - return new HashSet<>(); - } - public void setUsers(Set users) { - //this.users = users; - } - @Override public void update(DescriptionTemplateEntity entity) { } diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/UserDatasetProfile.java b/dmp-backend/core/src/main/java/eu/eudat/data/UserDatasetProfile.java deleted file mode 100644 index f8fc8109b..000000000 --- a/dmp-backend/core/src/main/java/eu/eudat/data/UserDatasetProfile.java +++ /dev/null @@ -1,80 +0,0 @@ -package eu.eudat.data; - -import eu.eudat.data.old.UserInfo; -import eu.eudat.data.old.helpers.EntityBinder; -import eu.eudat.queryable.queryableentity.DataEntity; -import jakarta.persistence.*; -import org.hibernate.annotations.GenericGenerator; - -import java.util.List; -import java.util.UUID; - -//@Entity -//@Table(name = "\"UserDatasetProfile\"") -public class UserDatasetProfile implements DataEntity { - @Id - @GeneratedValue - @GenericGenerator(name = "uuid2", strategy = "uuid2") - @Column(name = "id", updatable = false, nullable = false, columnDefinition = "BINARY(16)") - private UUID id; - - @OneToOne(fetch = FetchType.LAZY) - @JoinColumn(name = "usr") - private UserInfo user; - - @OneToOne(fetch = FetchType.LAZY) - @JoinColumn(name = "\"descriptionTemplate\"") - private DescriptionTemplateEntity descriptionTemplate; - - @Column(name = "role") - private Integer role; - - public UUID getId() { - return id; - } - - public void setId(UUID id) { - this.id = id; - } - - public UserInfo getUser() { - return user; - } - - public void setUser(UserInfo user) { - this.user = user; - } - - public DescriptionTemplateEntity getDatasetProfile() { - return descriptionTemplate; - } - - public void setDatasetProfile(DescriptionTemplateEntity descriptionTemplateEntity) { - this.descriptionTemplate = descriptionTemplateEntity; - } - - public Integer getRole() { - return role; - } - - public void setRole(Integer role) { - this.role = role; - } - - @Override - public void update(UserDatasetProfile entity) { - this.role = entity.getRole(); - } - - @Override - public UUID getKeys() { - return this.id; - } - - @Override - public UserDatasetProfile buildFromTuple(List tuple, List fields, String base) { - String currentBase = base.isEmpty() ? "" : base + "."; - if (fields.contains(currentBase + "id")) this.id = EntityBinder.fromTuple(tuple, currentBase + "id"); - return this; - } -} diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/UserDescriptionTemplateEntity.java b/dmp-backend/core/src/main/java/eu/eudat/data/UserDescriptionTemplateEntity.java new file mode 100644 index 000000000..c7d0928cc --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/data/UserDescriptionTemplateEntity.java @@ -0,0 +1,122 @@ +package eu.eudat.data; + +import eu.eudat.commons.enums.IsActive; +import eu.eudat.commons.enums.UserDescriptionTemplateRole; +import eu.eudat.data.converters.enums.IsActiveConverter; +import eu.eudat.data.converters.enums.UserDescriptionTemplateRoleConverter; +import eu.eudat.data.old.helpers.EntityBinder; +import eu.eudat.queryable.queryableentity.DataEntity; +import jakarta.persistence.*; + +import java.time.Instant; +import java.util.List; +import java.util.UUID; + +@Entity +@Table(name = "\"UserDescriptionTemplate\"") +public class UserDescriptionTemplateEntity implements DataEntity { + @Id + @Column(name = "id", columnDefinition = "uuid", updatable = false, nullable = false) + private UUID id; + public static final String _id = "id"; + + @Column(name = "\"user\"", nullable = false) + private UUID user; + public static final String _user = "user"; + + @Column(name = "is_active", nullable = false) + @Convert(converter = IsActiveConverter.class) + private IsActive isActive; + public static final String _isActive = "isActive"; + + + @Column(name = "\"created_at\"", nullable = false) + private Instant createdAt = null; + public static final String _createdAt = "createdAt"; + + @Column(name = "\"updated_at\"", nullable = false) + private Instant updatedAt; + public static final String _updatedAt = "updatedAt"; + + @Column(name = "\"description_template\"", nullable = false) + private UUID descriptionTemplate; + public static final String _descriptionTemplate = "descriptionTemplate"; + + @Column(name = "role", nullable = false) + @Convert(converter = UserDescriptionTemplateRoleConverter.class) + private UserDescriptionTemplateRole role; + public static final String _role = "role"; + + public UUID getId() { + return id; + } + + public void setId(UUID id) { + this.id = id; + } + + public UUID getUser() { + return user; + } + + public void setUser(UUID user) { + this.user = user; + } + + public IsActive getIsActive() { + return isActive; + } + + public void setIsActive(IsActive isActive) { + this.isActive = isActive; + } + + public Instant getCreatedAt() { + return createdAt; + } + + public void setCreatedAt(Instant createdAt) { + this.createdAt = createdAt; + } + + public Instant getUpdatedAt() { + return updatedAt; + } + + public void setUpdatedAt(Instant updatedAt) { + this.updatedAt = updatedAt; + } + + public UUID getDescriptionTemplate() { + return descriptionTemplate; + } + + public void setDescriptionTemplate(UUID descriptionTemplate) { + this.descriptionTemplate = descriptionTemplate; + } + + public UserDescriptionTemplateRole getRole() { + return role; + } + + public void setRole(UserDescriptionTemplateRole role) { + this.role = role; + } + + @Override + public void update(UserDescriptionTemplateEntity entity) { + this.role = entity.getRole(); + } + + @Override + public UUID getKeys() { + return this.id; + } + + @Override + public UserDescriptionTemplateEntity buildFromTuple(List tuple, List fields, String base) { + String currentBase = base.isEmpty() ? "" : base + "."; + if (fields.contains(currentBase + "id")) this.id = EntityBinder.fromTuple(tuple, currentBase + "id"); + return this; + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/converters/enums/UserDescriptionTemplateRoleConverter.java b/dmp-backend/core/src/main/java/eu/eudat/data/converters/enums/UserDescriptionTemplateRoleConverter.java new file mode 100644 index 000000000..6df96a3b0 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/data/converters/enums/UserDescriptionTemplateRoleConverter.java @@ -0,0 +1,11 @@ +package eu.eudat.data.converters.enums; + +import eu.eudat.commons.enums.UserDescriptionTemplateRole; +import jakarta.persistence.Converter; + +@Converter +public class UserDescriptionTemplateRoleConverter extends DatabaseEnumConverter{ + protected UserDescriptionTemplateRole of(Short i) { + return UserDescriptionTemplateRole.of(i); + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/data/old/UserDatasetProfile.java b/dmp-backend/core/src/main/java/eu/eudat/data/old/UserDatasetProfile.java deleted file mode 100644 index c853f9a33..000000000 --- a/dmp-backend/core/src/main/java/eu/eudat/data/old/UserDatasetProfile.java +++ /dev/null @@ -1,80 +0,0 @@ -package eu.eudat.data.old; - -import eu.eudat.data.DescriptionTemplateEntity; -import eu.eudat.data.old.helpers.EntityBinder; -import eu.eudat.queryable.queryableentity.DataEntity; -import org.hibernate.annotations.GenericGenerator; - -import jakarta.persistence.*; -import java.util.List; -import java.util.UUID; - -@Entity -@Table(name = "\"UserDatasetProfile\"") -public class UserDatasetProfile implements DataEntity { - @Id - @GeneratedValue - @GenericGenerator(name = "uuid2", strategy = "uuid2") - @Column(name = "id", updatable = false, nullable = false, columnDefinition = "BINARY(16)") - private UUID id; - - @OneToOne(fetch = FetchType.LAZY) - @JoinColumn(name = "usr") - private UserInfo user; - - @OneToOne(fetch = FetchType.LAZY) - @JoinColumn(name = "\"descriptionTemplate\"") - private DescriptionTemplateEntity descriptionTemplate; - - @Column(name = "role") - private Integer role; - - public UUID getId() { - return id; - } - - public void setId(UUID id) { - this.id = id; - } - - public UserInfo getUser() { - return user; - } - - public void setUser(UserInfo user) { - this.user = user; - } - - public DescriptionTemplateEntity getDatasetProfile() { - return descriptionTemplate; - } - - public void setDatasetProfile(DescriptionTemplateEntity descriptionTemplateEntity) { - this.descriptionTemplate = descriptionTemplateEntity; - } - - public Integer getRole() { - return role; - } - - public void setRole(Integer role) { - this.role = role; - } - - @Override - public void update(UserDatasetProfile entity) { - this.role = entity.getRole(); - } - - @Override - public UUID getKeys() { - return this.id; - } - - @Override - public UserDatasetProfile buildFromTuple(List tuple, List fields, String base) { - String currentBase = base.isEmpty() ? "" : base + "."; - if (fields.contains(currentBase + "id")) this.id = EntityBinder.fromTuple(tuple, currentBase + "id"); - return this; - } -} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/DescriptionTemplate.java b/dmp-backend/core/src/main/java/eu/eudat/model/DescriptionTemplate.java index 921ea4a03..545184bee 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/DescriptionTemplate.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/DescriptionTemplate.java @@ -6,6 +6,7 @@ import eu.eudat.commons.enums.IsActive; import eu.eudat.model.descriptiontemplatedefinition.Definition; import java.time.Instant; +import java.util.List; import java.util.UUID; public class DescriptionTemplate { @@ -46,6 +47,9 @@ public class DescriptionTemplate { public final static String _status = "status"; private DescriptionTemplateStatus status; + public final static String _users = "users"; + private List users; + public final static String _hash = "hash"; private String hash; @@ -145,6 +149,14 @@ public class DescriptionTemplate { this.status = status; } + public List getUsers() { + return users; + } + + public void setUsers(List users) { + this.users = users; + } + public String getHash() { return hash; } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/UserDescriptionTemplate.java b/dmp-backend/core/src/main/java/eu/eudat/model/UserDescriptionTemplate.java new file mode 100644 index 000000000..09a345a1f --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/UserDescriptionTemplate.java @@ -0,0 +1,88 @@ +package eu.eudat.model; + +import eu.eudat.commons.enums.DescriptionTemplateStatus; +import eu.eudat.commons.enums.IsActive; +import eu.eudat.commons.enums.UserDescriptionTemplateRole; +import eu.eudat.model.descriptiontemplatedefinition.Definition; + +import java.time.Instant; +import java.util.UUID; + +public class UserDescriptionTemplate { + + public final static String _id = "id"; + private UUID id; + + public final static String _descriptionTemplate = "descriptionTemplate"; + private DescriptionTemplate descriptionTemplate; + public final static String _role = "role"; + private UserDescriptionTemplateRole role; + + public final static String _createdAt = "createdAt"; + private Instant createdAt; + + public final static String _updatedAt = "updatedAt"; + private Instant updatedAt; + + public final static String _isActive = "isActive"; + private IsActive isActive; + + public final static String _hash = "hash"; + private String hash; + + public UUID getId() { + return id; + } + + public void setId(UUID id) { + this.id = id; + } + + public DescriptionTemplate getDescriptionTemplate() { + return descriptionTemplate; + } + + public void setDescriptionTemplate(DescriptionTemplate descriptionTemplate) { + this.descriptionTemplate = descriptionTemplate; + } + + public UserDescriptionTemplateRole getRole() { + return role; + } + + public void setRole(UserDescriptionTemplateRole role) { + this.role = role; + } + + public Instant getCreatedAt() { + return createdAt; + } + + public void setCreatedAt(Instant createdAt) { + this.createdAt = createdAt; + } + + public Instant getUpdatedAt() { + return updatedAt; + } + + public void setUpdatedAt(Instant updatedAt) { + this.updatedAt = updatedAt; + } + + public IsActive getIsActive() { + return isActive; + } + + public void setIsActive(IsActive isActive) { + this.isActive = isActive; + } + + public String getHash() { + return hash; + } + + public void setHash(String hash) { + this.hash = hash; + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionTemplateBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionTemplateBuilder.java index cf093735a..602d11ab5 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionTemplateBuilder.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/DescriptionTemplateBuilder.java @@ -7,8 +7,10 @@ import eu.eudat.convention.ConventionService; import eu.eudat.data.DescriptionTemplateEntity; import eu.eudat.model.DescriptionTemplate; import eu.eudat.model.DescriptionTemplateType; +import eu.eudat.model.UserDescriptionTemplate; import eu.eudat.model.builder.descriptiontemplatedefinition.DefinitionBuilder; import eu.eudat.query.DescriptionTemplateTypeQuery; +import eu.eudat.query.UserDescriptionTemplateQuery; import gr.cite.tools.data.builder.BuilderFactory; import gr.cite.tools.data.query.QueryFactory; import gr.cite.tools.exception.MyApplicationException; @@ -58,6 +60,8 @@ public class DescriptionTemplateBuilder extends BaseBuilder descriptionTemplateTypeMap = this.collectDescriptionTemplateTypes(descriptionTemplateTypeFields, datas); + FieldSet usersFields = fields.extractPrefixed(this.asPrefix(DescriptionTemplate._users)); + Map> usersMap = this.collectUserDescriptionTemplates(usersFields, datas); FieldSet definitionFields = fields.extractPrefixed(this.asPrefix(DescriptionTemplate._definition)); List models = new ArrayList<>(); @@ -80,6 +84,7 @@ public class DescriptionTemplateBuilder extends BaseBuilder> collectUserDescriptionTemplates(FieldSet fields, List datas) throws MyApplicationException { + if (fields.isEmpty() || datas.isEmpty()) return null; + this.logger.debug("checking related - {}", UserDescriptionTemplate.class.getSimpleName()); + + Map> itemMap = null; + FieldSet clone = new BaseFieldSet(fields.getFields()).ensure(this.asIndexer(UserDescriptionTemplate._descriptionTemplate, DescriptionTemplate._id)); + UserDescriptionTemplateQuery query = this.queryFactory.query(UserDescriptionTemplateQuery.class).authorize(this.authorize).descriptionTemplateIds(datas.stream().map(DescriptionTemplateEntity::getId).distinct().collect(Collectors.toList())); + itemMap = this.builderFactory.builder(UserDescriptionTemplateBuilder.class).authorize(this.authorize).authorize(this.authorize).asMasterKey(query, clone, x -> x.getDescriptionTemplate().getId()); + + if (!fields.hasField(this.asIndexer(UserDescriptionTemplate._descriptionTemplate, DescriptionTemplate._id))) { + itemMap.values().stream().flatMap(List::stream).filter(x -> x != null && x.getDescriptionTemplate() != null).map(x -> { + x.getDescriptionTemplate().setId(null); + return x; + }).collect(Collectors.toList()); + } + return itemMap; + } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/UserDescriptionTemplateBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/UserDescriptionTemplateBuilder.java new file mode 100644 index 000000000..22bf107f3 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/UserDescriptionTemplateBuilder.java @@ -0,0 +1,104 @@ +package eu.eudat.model.builder; + +import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.commons.XmlHandlingService; +import eu.eudat.convention.ConventionService; +import eu.eudat.data.UserDescriptionTemplateEntity; +import eu.eudat.model.DescriptionTemplate; +import eu.eudat.model.UserDescriptionTemplate; +import eu.eudat.query.DescriptionTemplateQuery; +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; +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.*; +import java.util.stream.Collectors; + +@Component +@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) +public class UserDescriptionTemplateBuilder extends BaseBuilder { + + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); + private final QueryFactory queryFactory; + private final BuilderFactory builderFactory; + private final XmlHandlingService xmlHandlingService; + + @Autowired + public UserDescriptionTemplateBuilder( + ConventionService conventionService, QueryFactory queryFactory, BuilderFactory builderFactory, XmlHandlingService xmlHandlingService) { + super(conventionService, new LoggerService(LoggerFactory.getLogger(UserDescriptionTemplateBuilder.class))); + this.queryFactory = queryFactory; + this.builderFactory = builderFactory; + this.xmlHandlingService = xmlHandlingService; + } + + public UserDescriptionTemplateBuilder authorize(EnumSet values) { + this.authorize = values; + return this; + } + + @Override + public List build(FieldSet fields, List datas) throws MyApplicationException { + this.logger.debug("building for {} items requesting {} fields", Optional.ofNullable(datas).map(List::size).orElse(0), Optional.ofNullable(fields).map(FieldSet::getFields).map(Set::size).orElse(0)); + this.logger.trace(new DataLogEntry("requested fields", fields)); + if (fields == null || datas == null || fields.isEmpty()) + return new ArrayList<>(); + + FieldSet descriptionTemplateFields = fields.extractPrefixed(this.asPrefix(UserDescriptionTemplate._descriptionTemplate)); + Map descriptionTemplateMap = this.collectDescriptionTemplates(descriptionTemplateFields, datas); + + + List models = new ArrayList<>(); + for (UserDescriptionTemplateEntity d : datas) { + UserDescriptionTemplate m = new UserDescriptionTemplate(); + if (fields.hasField(this.asIndexer(UserDescriptionTemplate._id))) m.setId(d.getId()); + if (fields.hasField(this.asIndexer(UserDescriptionTemplate._createdAt))) m.setCreatedAt(d.getCreatedAt()); + if (fields.hasField(this.asIndexer(UserDescriptionTemplate._updatedAt))) m.setUpdatedAt(d.getUpdatedAt()); + if (fields.hasField(this.asIndexer(UserDescriptionTemplate._isActive))) m.setIsActive(d.getIsActive()); + if (fields.hasField(this.asIndexer(UserDescriptionTemplate._role))) m.setRole(d.getRole()); + if (fields.hasField(this.asIndexer(UserDescriptionTemplate._hash))) m.setHash(this.hashValue(d.getUpdatedAt())); + if (!descriptionTemplateFields.isEmpty() && descriptionTemplateMap != null && descriptionTemplateMap.containsKey(d.getDescriptionTemplate())) m.setDescriptionTemplate(descriptionTemplateMap.get(d.getDescriptionTemplate())); + models.add(m); + } + this.logger.debug("build {} items", Optional.of(models).map(List::size).orElse(0)); + return models; + } + + private Map collectDescriptionTemplates(FieldSet fields, List datas) throws MyApplicationException { + if (fields.isEmpty() || datas.isEmpty()) return null; + this.logger.debug("checking related - {}", DescriptionTemplate.class.getSimpleName()); + + Map itemMap = null; + if (!fields.hasOtherField(this.asIndexer(DescriptionTemplate._id))) { + itemMap = this.asEmpty( + datas.stream().map(UserDescriptionTemplateEntity::getDescriptionTemplate).distinct().collect(Collectors.toList()), + x -> { + DescriptionTemplate item = new DescriptionTemplate(); + item.setId(x); + return item; + }, + x -> x.getId()); + } else { + FieldSet clone = new BaseFieldSet(fields.getFields()).ensure(DescriptionTemplate._id); + DescriptionTemplateQuery q = this.queryFactory.query(DescriptionTemplateQuery.class).ids(datas.stream().map(UserDescriptionTemplateEntity::getDescriptionTemplate).distinct().collect(Collectors.toList())); + itemMap = this.builderFactory.builder(DescriptionTemplateBuilder.class).asForeignKey(q, clone, DescriptionTemplate::getId); + } + if (!fields.hasField(DescriptionTemplate._id)) { + itemMap.values().stream().filter(x -> x != null).map(x -> { + x.setId(null); + return x; + }).collect(Collectors.toList()); + } + + return itemMap; + } +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionTemplateCensor.java b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionTemplateCensor.java index f5bb46c4b..d6a6c999c 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionTemplateCensor.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionTemplateCensor.java @@ -41,6 +41,8 @@ public class DescriptionTemplateCensor extends BaseCensor { this.censorFactory.censor(DescriptionTemplateTypeCensor.class).censor(definitionFields, userId); FieldSet typeFields = fields.extractPrefixed(this.asIndexerPrefix(DescriptionTemplate._type)); this.censorFactory.censor(DefinitionCensor.class).censor(typeFields, userId); + FieldSet _usersFields = fields.extractPrefixed(this.asIndexerPrefix(DescriptionTemplate._users)); + this.censorFactory.censor(UserDescriptionTemplateCensor.class).censor(_usersFields, userId); } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/censorship/UserDescriptionTemplateCensor.java b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/UserDescriptionTemplateCensor.java new file mode 100644 index 000000000..bf8730a16 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/UserDescriptionTemplateCensor.java @@ -0,0 +1,45 @@ +package eu.eudat.model.censorship; + +import eu.eudat.authorization.Permission; +import eu.eudat.convention.ConventionService; +import eu.eudat.model.DescriptionTemplate; +import eu.eudat.model.UserDescriptionTemplate; +import eu.eudat.model.censorship.descriptiontemplatedefinition.DefinitionCensor; +import gr.cite.commons.web.authz.service.AuthorizationService; +import gr.cite.tools.data.censor.CensorFactory; +import gr.cite.tools.fieldset.FieldSet; +import gr.cite.tools.logging.DataLogEntry; +import gr.cite.tools.logging.LoggerService; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.annotation.Scope; +import org.springframework.stereotype.Component; + +import java.util.UUID; + +@Component +@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) +public class UserDescriptionTemplateCensor extends BaseCensor { + + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(UserDescriptionTemplateCensor.class)); + + protected final AuthorizationService authService; + protected final CensorFactory censorFactory; + + public UserDescriptionTemplateCensor(ConventionService conventionService, AuthorizationService authService, CensorFactory censorFactory) { + super(conventionService); + this.authService = authService; + this.censorFactory = censorFactory; + } + + public void censor(FieldSet fields, UUID userId) { + logger.debug(new DataLogEntry("censoring fields", fields)); + if (fields == null || fields.isEmpty()) + return; + + this.authService.authorizeForce(Permission.BrowseDescriptionTemplate); + FieldSet userFields = fields.extractPrefixed(this.asIndexerPrefix(UserDescriptionTemplate._descriptionTemplate)); + this.censorFactory.censor(DescriptionTemplateCensor.class).censor(userFields, userId); + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionTemplateDeleter.java b/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionTemplateDeleter.java index 630452689..e54be0757 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionTemplateDeleter.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/deleter/DescriptionTemplateDeleter.java @@ -2,7 +2,9 @@ package eu.eudat.model.deleter; import eu.eudat.commons.enums.IsActive; import eu.eudat.data.DescriptionTemplateEntity; +import eu.eudat.data.UserDescriptionTemplateEntity; import eu.eudat.query.DescriptionTemplateQuery; +import eu.eudat.query.UserDescriptionTemplateQuery; import gr.cite.tools.data.deleter.Deleter; import gr.cite.tools.data.deleter.DeleterFactory; import gr.cite.tools.data.query.QueryFactory; @@ -20,6 +22,7 @@ import java.time.Instant; import java.util.List; import java.util.Optional; import java.util.UUID; +import java.util.stream.Collectors; @Component @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) @@ -59,16 +62,24 @@ public class DescriptionTemplateDeleter implements Deleter { logger.trace("changes saved"); } - public void delete(List data) throws InvalidApplicationException { - logger.debug("will delete {} items", Optional.ofNullable(data).map(List::size).orElse(0)); - if (data == null || data.isEmpty()) + public void delete(List datas) throws InvalidApplicationException { + logger.debug("will delete {} items", Optional.ofNullable(datas).map(List::size).orElse(0)); + if (datas == null || datas.isEmpty()) return; + + List ids = datas.stream().map(x -> x.getId()).distinct().collect(Collectors.toList()); + { + logger.debug("checking related - {}", UserDescriptionTemplateEntity.class.getSimpleName()); + List items = this.queryFactory.query(UserDescriptionTemplateQuery.class).descriptionTemplateIds(ids).collect(); + UserDescriptionTemplateDeleter deleter = this.deleterFactory.deleter(UserDescriptionTemplateDeleter.class); + deleter.delete(items); + } //TODO can not delete profile if has Datasets Instant now = Instant.now(); - for (DescriptionTemplateEntity item : data) { + for (DescriptionTemplateEntity item : datas) { logger.trace("deleting item {}", item.getId()); item.setIsActive(IsActive.Inactive); item.setUpdatedAt(now); diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/deleter/UserDescriptionTemplateDeleter.java b/dmp-backend/core/src/main/java/eu/eudat/model/deleter/UserDescriptionTemplateDeleter.java new file mode 100644 index 000000000..be51b19ab --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/deleter/UserDescriptionTemplateDeleter.java @@ -0,0 +1,80 @@ +package eu.eudat.model.deleter; + +import eu.eudat.commons.enums.IsActive; +import eu.eudat.data.UserDescriptionTemplateEntity; +import eu.eudat.query.DescriptionTemplateQuery; +import eu.eudat.query.UserDescriptionTemplateQuery; +import gr.cite.tools.data.deleter.Deleter; +import gr.cite.tools.data.deleter.DeleterFactory; +import gr.cite.tools.data.query.QueryFactory; +import gr.cite.tools.logging.LoggerService; +import gr.cite.tools.logging.MapLogEntry; +import jakarta.persistence.EntityManager; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.annotation.Scope; +import org.springframework.stereotype.Component; + +import javax.management.InvalidApplicationException; +import java.time.Instant; +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +@Component +@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) +public class UserDescriptionTemplateDeleter implements Deleter { + + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(UserDescriptionTemplateDeleter.class)); + + private final EntityManager entityManager; + + protected final QueryFactory queryFactory; + + protected final DeleterFactory deleterFactory; + + @Autowired + public UserDescriptionTemplateDeleter( + EntityManager entityManager, + QueryFactory queryFactory, + DeleterFactory deleterFactory + ) { + this.entityManager = entityManager; + this.queryFactory = queryFactory; + this.deleterFactory = deleterFactory; + } + + public void deleteAndSaveByIds(List ids) throws InvalidApplicationException { + logger.debug(new MapLogEntry("collecting to delete").And("count", Optional.ofNullable(ids).map(List::size).orElse(0)).And("ids", ids)); + List data = this.queryFactory.query(UserDescriptionTemplateQuery.class).ids(ids).collect(); + logger.trace("retrieved {} items", Optional.ofNullable(data).map(List::size).orElse(0)); + this.deleteAndSave(data); + } + + public void deleteAndSave(List data) throws InvalidApplicationException { + logger.debug("will delete {} items", Optional.ofNullable(data).map(List::size).orElse(0)); + this.delete(data); + logger.trace("saving changes"); + this.entityManager.flush(); + logger.trace("changes saved"); + } + + public void delete(List data) throws InvalidApplicationException { + logger.debug("will delete {} items", Optional.ofNullable(data).map(List::size).orElse(0)); + if (data == null || data.isEmpty()) + return; + + Instant now = Instant.now(); + + for (UserDescriptionTemplateEntity item : data) { + logger.trace("deleting item {}", item.getId()); + item.setIsActive(IsActive.Inactive); + item.setUpdatedAt(now); + logger.trace("updating item"); + this.entityManager.merge(item); + logger.trace("updated item"); + } + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionTemplateQuery.java b/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionTemplateQuery.java index 26b52732a..fa9b59b23 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionTemplateQuery.java +++ b/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionTemplateQuery.java @@ -212,6 +212,7 @@ public class DescriptionTemplateQuery extends QueryBase { + + private Collection ids; + private Collection isActives; + private Collection roles; + private Collection excludedIds; + private Collection userIds; + private Collection descriptionTemplateIds; + + private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); + + public UserDescriptionTemplateQuery ids(UUID value) { + this.ids = List.of(value); + return this; + } + + public UserDescriptionTemplateQuery ids(UUID... value) { + this.ids = Arrays.asList(value); + return this; + } + + public UserDescriptionTemplateQuery ids(Collection values) { + this.ids = values; + return this; + } + + public UserDescriptionTemplateQuery userIds(UUID value) { + this.userIds = List.of(value); + return this; + } + + public UserDescriptionTemplateQuery userIds(UUID... value) { + this.userIds = Arrays.asList(value); + return this; + } + + public UserDescriptionTemplateQuery userIds(Collection values) { + this.userIds = values; + return this; + } + + public UserDescriptionTemplateQuery descriptionTemplateIds(UUID value) { + this.descriptionTemplateIds = List.of(value); + return this; + } + + public UserDescriptionTemplateQuery descriptionTemplateIds(UUID... value) { + this.descriptionTemplateIds = Arrays.asList(value); + return this; + } + + public UserDescriptionTemplateQuery descriptionTemplateIds(Collection values) { + this.descriptionTemplateIds = values; + return this; + } + + public UserDescriptionTemplateQuery isActive(IsActive value) { + this.isActives = List.of(value); + return this; + } + + public UserDescriptionTemplateQuery isActive(IsActive... value) { + this.isActives = Arrays.asList(value); + return this; + } + + public UserDescriptionTemplateQuery isActive(Collection values) { + this.isActives = values; + return this; + } + + public UserDescriptionTemplateQuery roles(UserDescriptionTemplateRole value) { + this.roles = List.of(value); + return this; + } + + public UserDescriptionTemplateQuery roles(UserDescriptionTemplateRole... value) { + this.roles = Arrays.asList(value); + return this; + } + + public UserDescriptionTemplateQuery roles(Collection values) { + this.roles = values; + return this; + } + + public UserDescriptionTemplateQuery excludedIds(Collection values) { + this.excludedIds = values; + return this; + } + + public UserDescriptionTemplateQuery excludedIds(UUID value) { + this.excludedIds = List.of(value); + return this; + } + + public UserDescriptionTemplateQuery excludedIds(UUID... value) { + this.excludedIds = Arrays.asList(value); + return this; + } + + public UserDescriptionTemplateQuery authorize(EnumSet values) { + this.authorize = values; + return this; + } + + private final AuthorizationService authService; + + public UserDescriptionTemplateQuery( + UserScope userScope, + AuthorizationService authService + ) { + this.authService = authService; + } + + @Override + protected Class entityClass() { + return UserDescriptionTemplateEntity.class; + } + + @Override + protected Boolean isFalseQuery() { + return this.isEmpty(this.ids) || this.isEmpty(this.userIds) || this.isEmpty(this.descriptionTemplateIds) ||this.isEmpty(this.isActives) ||this.isEmpty(this.roles) || this.isEmpty(this.excludedIds); + } + + @Override + protected Predicate applyFilters(QueryContext queryContext) { + List predicates = new ArrayList<>(); + if (this.ids != null) { + CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(UserDescriptionTemplateEntity._id)); + for (UUID item : this.ids) + inClause.value(item); + predicates.add(inClause); + } + if (this.userIds != null) { + CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(UserDescriptionTemplateEntity._user)); + for (UUID item : this.userIds) + inClause.value(item); + predicates.add(inClause); + } + if (this.descriptionTemplateIds != null) { + CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(UserDescriptionTemplateEntity._descriptionTemplate)); + for (UUID item : this.descriptionTemplateIds) + inClause.value(item); + predicates.add(inClause); + } + if (this.isActives != null) { + CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(UserDescriptionTemplateEntity._isActive)); + for (IsActive item : this.isActives) + inClause.value(item); + predicates.add(inClause); + } + if (this.roles != null) { + CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(UserDescriptionTemplateEntity._role)); + for (UserDescriptionTemplateRole item : this.roles) + inClause.value(item); + predicates.add(inClause); + } + if (this.excludedIds != null) { + CriteriaBuilder.In notInClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(UserDescriptionTemplateEntity._id)); + for (UUID item : this.excludedIds) + notInClause.value(item); + predicates.add(notInClause.not()); + } + if (!predicates.isEmpty()) { + Predicate[] predicatesArray = predicates.toArray(new Predicate[0]); + return queryContext.CriteriaBuilder.and(predicatesArray); + } else { + return null; + } + } + + @Override + protected UserDescriptionTemplateEntity convert(Tuple tuple, Set columns) { + UserDescriptionTemplateEntity item = new UserDescriptionTemplateEntity(); + item.setId(QueryBase.convertSafe(tuple, columns, UserDescriptionTemplateEntity._id, UUID.class)); + item.setUser(QueryBase.convertSafe(tuple, columns, UserDescriptionTemplateEntity._user, UUID.class)); + item.setDescriptionTemplate(QueryBase.convertSafe(tuple, columns, UserDescriptionTemplateEntity._descriptionTemplate, UUID.class)); + item.setRole(QueryBase.convertSafe(tuple, columns, UserDescriptionTemplateEntity._role, UserDescriptionTemplateRole.class)); + item.setCreatedAt(QueryBase.convertSafe(tuple, columns, UserDescriptionTemplateEntity._createdAt, Instant.class)); + item.setUpdatedAt(QueryBase.convertSafe(tuple, columns, UserDescriptionTemplateEntity._updatedAt, Instant.class)); + item.setIsActive(QueryBase.convertSafe(tuple, columns, UserDescriptionTemplateEntity._isActive, IsActive.class)); + return item; + } + + @Override + protected String fieldNameOf(FieldResolver item) { + if (item.match(UserDescriptionTemplateEntity._id)) return UserDescriptionTemplateEntity._id; + else if (item.prefix(UserDescriptionTemplateEntity._user)) return UserDescriptionTemplateEntity._user; + else if (item.prefix(UserDescriptionTemplateEntity._descriptionTemplate)) return UserDescriptionTemplateEntity._descriptionTemplate; + else if (item.match(UserDescriptionTemplateEntity._role)) return UserDescriptionTemplateEntity._role; + else if (item.match(UserDescriptionTemplateEntity._createdAt)) return UserDescriptionTemplateEntity._createdAt; + else if (item.match(UserDescriptionTemplateEntity._updatedAt)) return UserDescriptionTemplateEntity._updatedAt; + else if (item.match(UserDescriptionTemplateEntity._isActive)) return UserDescriptionTemplateEntity._isActive; + else return null; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/query/lookup/UserDescriptionTemplateLookup.java b/dmp-backend/core/src/main/java/eu/eudat/query/lookup/UserDescriptionTemplateLookup.java new file mode 100644 index 000000000..3ce6f8e15 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/query/lookup/UserDescriptionTemplateLookup.java @@ -0,0 +1,93 @@ +package eu.eudat.query.lookup; + +import eu.eudat.commons.enums.IsActive; +import eu.eudat.commons.enums.UserDescriptionTemplateRole; +import eu.eudat.query.UserDescriptionTemplateQuery; +import gr.cite.tools.data.query.Lookup; +import gr.cite.tools.data.query.QueryFactory; + +import java.util.List; +import java.util.UUID; + +public class UserDescriptionTemplateLookup extends Lookup { + + private List isActive; + + private List roles; + + private List ids; + + private List userIds; + private List descriptionTemplateIds; + + private List excludedIds; + + public List getIsActive() { + return isActive; + } + + public void setIsActive(List isActive) { + this.isActive = isActive; + } + + public List getRoles() { + return roles; + } + + public void setRoles(List roles) { + this.roles = roles; + } + + public List getIds() { + return ids; + } + + public void setIds(List ids) { + this.ids = ids; + } + + public List getUserIds() { + return userIds; + } + + public void setUserIds(List userIds) { + this.userIds = userIds; + } + + public List getDescriptionTemplateIds() { + return descriptionTemplateIds; + } + + public void setDescriptionTemplateIds(List descriptionTemplateIds) { + this.descriptionTemplateIds = descriptionTemplateIds; + } + + public List getExcludedIds() { + return excludedIds; + } + + public void setExcludedIds(List excludedIds) { + this.excludedIds = excludedIds; + } + + public UserDescriptionTemplateQuery enrich(QueryFactory queryFactory) { + UserDescriptionTemplateQuery query = queryFactory.query(UserDescriptionTemplateQuery.class); + if (this.isActive != null) + query.isActive(this.isActive); + if (this.roles != null) + query.roles(this.roles); + if (this.ids != null) + query.ids(this.ids); + if (this.excludedIds != null) + query.excludedIds(this.excludedIds); + if (this.userIds != null) + query.userIds(this.userIds); + if (this.descriptionTemplateIds != null) + query.userIds(this.descriptionTemplateIds); + + this.enrichCommon(query); + + return query; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/descriptiontemplate/DescriptionTemplateServiceImpl.java b/dmp-backend/core/src/main/java/eu/eudat/service/descriptiontemplate/DescriptionTemplateServiceImpl.java index bcece070a..11da8e49f 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/service/descriptiontemplate/DescriptionTemplateServiceImpl.java +++ b/dmp-backend/core/src/main/java/eu/eudat/service/descriptiontemplate/DescriptionTemplateServiceImpl.java @@ -5,10 +5,13 @@ import eu.eudat.authorization.AuthorizationFlags; import eu.eudat.authorization.Permission; import eu.eudat.commons.XmlHandlingService; import eu.eudat.commons.enums.IsActive; +import eu.eudat.commons.enums.UserDescriptionTemplateRole; +import eu.eudat.commons.scope.user.UserScope; import eu.eudat.commons.types.descriptiontemplate.*; import eu.eudat.commons.types.descriptiontemplate.fielddata.BaseFieldDataEntity; import eu.eudat.convention.ConventionService; import eu.eudat.data.DescriptionTemplateEntity; +import eu.eudat.data.UserDescriptionTemplateEntity; import eu.eudat.model.DescriptionTemplate; import eu.eudat.model.builder.DescriptionTemplateBuilder; import eu.eudat.model.deleter.DescriptionTemplateDeleter; @@ -50,6 +53,7 @@ public class DescriptionTemplateServiceImpl implements DescriptionTemplateServic private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionTemplateServiceImpl.class)); private final EntityManager entityManager; + private final UserScope userScope; private final AuthorizationService authorizationService; @@ -64,14 +68,15 @@ public class DescriptionTemplateServiceImpl implements DescriptionTemplateServic @Autowired public DescriptionTemplateServiceImpl( EntityManager entityManager, - AuthorizationService authorizationService, + UserScope userScope, AuthorizationService authorizationService, DeleterFactory deleterFactory, BuilderFactory builderFactory, ConventionService conventionService, MessageSource messageSource, - XmlHandlingService xmlHandlingService, + XmlHandlingService xmlHandlingService, FieldDataHelperServiceProvider fieldDataHelperServiceProvider) { this.entityManager = entityManager; + this.userScope = userScope; this.authorizationService = authorizationService; this.deleterFactory = deleterFactory; this.builderFactory = builderFactory; @@ -112,11 +117,24 @@ public class DescriptionTemplateServiceImpl implements DescriptionTemplateServic this.entityManager.merge(data); else this.entityManager.persist(data); + + if (!isUpdate) this.addOwner(data); this.entityManager.flush(); return this.builderFactory.builder(DescriptionTemplateBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(BaseFieldSet.build(fields, DescriptionTemplate._id), data); } + + private void addOwner(DescriptionTemplateEntity descriptionTemplateEntity) throws InvalidApplicationException { + UserDescriptionTemplateEntity data = new UserDescriptionTemplateEntity(); + data.setId(UUID.randomUUID()); + data.setIsActive(IsActive.Active); + data.setCreatedAt(Instant.now()); + data.setRole(UserDescriptionTemplateRole.Owner); + data.setUser(userScope.getUserId()); + data.setDescriptionTemplate(descriptionTemplateEntity.getId()); + this.entityManager.persist(data); + } private @NotNull DefinitionEntity buildDefinitionEntity(DefinitionPersist persist){ DefinitionEntity data = new DefinitionEntity(); diff --git a/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/UserDatasetProfileDao.java b/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/UserDatasetProfileDao.java index bcfe96c03..9367fd3f2 100644 --- a/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/UserDatasetProfileDao.java +++ b/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/UserDatasetProfileDao.java @@ -1,12 +1,12 @@ package eu.eudat.data.dao.entities; +import eu.eudat.data.UserDescriptionTemplateEntity; import eu.eudat.data.dao.DatabaseAccessLayer; -import eu.eudat.data.old.UserDatasetProfile; import java.util.UUID; /** * Created by ikalyvas on 2/8/2018. */ -public interface UserDatasetProfileDao extends DatabaseAccessLayer { +public interface UserDatasetProfileDao extends DatabaseAccessLayer { } diff --git a/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/UserDatasetProfileDaoImpl.java b/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/UserDatasetProfileDaoImpl.java index b11ee4f72..56ddb29c4 100644 --- a/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/UserDatasetProfileDaoImpl.java +++ b/dmp-backend/data/src/main/java/eu/eudat/data/dao/entities/UserDatasetProfileDaoImpl.java @@ -1,8 +1,8 @@ package eu.eudat.data.dao.entities; +import eu.eudat.data.UserDescriptionTemplateEntity; import eu.eudat.data.dao.DatabaseAccess; import eu.eudat.data.dao.databaselayer.service.DatabaseService; -import eu.eudat.data.old.UserDatasetProfile; import eu.eudat.queryable.QueryableList; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.scheduling.annotation.Async; @@ -13,41 +13,41 @@ import java.util.UUID; import java.util.concurrent.CompletableFuture; @Component("userDatasetProfileDao") -public class UserDatasetProfileDaoImpl extends DatabaseAccess implements UserDatasetProfileDao { +public class UserDatasetProfileDaoImpl extends DatabaseAccess implements UserDatasetProfileDao { @Autowired - public UserDatasetProfileDaoImpl(DatabaseService databaseService) { + public UserDatasetProfileDaoImpl(DatabaseService databaseService) { super(databaseService); } @Override - public UserDatasetProfile createOrUpdate(UserDatasetProfile item) { - return this.getDatabaseService().createOrUpdate(item, UserDatasetProfile.class); + public UserDescriptionTemplateEntity createOrUpdate(UserDescriptionTemplateEntity item) { + return this.getDatabaseService().createOrUpdate(item, UserDescriptionTemplateEntity.class); } @Override - public UserDatasetProfile find(UUID id) throws InvalidApplicationException { - return this.getDatabaseService().getQueryable(UserDatasetProfile.class).where((builder, root) -> builder.equal(root.get("id"), id)).getSingleOrDefault(); + public UserDescriptionTemplateEntity find(UUID id) throws InvalidApplicationException { + return this.getDatabaseService().getQueryable(UserDescriptionTemplateEntity.class).where((builder, root) -> builder.equal(root.get("id"), id)).getSingleOrDefault(); } @Override - public void delete(UserDatasetProfile item) { + public void delete(UserDescriptionTemplateEntity item) { this.getDatabaseService().delete(item); } @Override - public QueryableList asQueryable() { - return this.getDatabaseService().getQueryable(UserDatasetProfile.class); + public QueryableList asQueryable() { + return this.getDatabaseService().getQueryable(UserDescriptionTemplateEntity.class); } @Async @Override - public CompletableFuture createOrUpdateAsync(UserDatasetProfile item) { + public CompletableFuture createOrUpdateAsync(UserDescriptionTemplateEntity item) { return CompletableFuture.supplyAsync(() -> this.createOrUpdate(item)); } @Override - public UserDatasetProfile find(UUID id, String hint) { + public UserDescriptionTemplateEntity find(UUID id, String hint) { throw new UnsupportedOperationException(); } } diff --git a/dmp-backend/web/src/main/java/eu/eudat/controllers/Admin.java b/dmp-backend/web/src/main/java/eu/eudat/controllers/Admin.java index ecfc624b9..f1b69db73 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/controllers/Admin.java +++ b/dmp-backend/web/src/main/java/eu/eudat/controllers/Admin.java @@ -2,13 +2,13 @@ package eu.eudat.controllers; import eu.eudat.authorization.Permission; import eu.eudat.commons.enums.DescriptionTemplateStatus; +import eu.eudat.commons.enums.UserDescriptionTemplateRole; import eu.eudat.commons.scope.user.UserScope; import eu.eudat.data.DescriptionTemplateEntity; -import eu.eudat.data.old.UserDatasetProfile; +import eu.eudat.data.UserDescriptionTemplateEntity; import eu.eudat.data.old.UserInfo; import eu.eudat.data.query.items.table.datasetprofile.DatasetProfileTableRequestItem; import eu.eudat.exceptions.datasetprofile.DatasetProfileNewVersionException; -import eu.eudat.exceptions.datasetprofile.DatasetProfileWithDatasetsExeption; import eu.eudat.logic.managers.AdminManager; import eu.eudat.logic.managers.DatasetProfileManager; import eu.eudat.logic.managers.MetricsManager; @@ -82,11 +82,11 @@ public class Admin extends BaseController { modelDefinition.setVersion((short) 0); DescriptionTemplateEntity descriptionTemplateEntity = this.getApiContext().getOperationsContext().getDatabaseRepository().getDatasetProfileDao().createOrUpdate(modelDefinition); - UserDatasetProfile userDatasetProfile = new UserDatasetProfile(); - userDatasetProfile.setDatasetProfile(descriptionTemplateEntity); + UserDescriptionTemplateEntity userDatasetProfile = new UserDescriptionTemplateEntity(); + userDatasetProfile.setDescriptionTemplate(descriptionTemplateEntity.getId()); UserInfo userInfo = getApiContext().getOperationsContext().getDatabaseRepository().getUserInfoDao().find(this.userScope.getUserId()); - userDatasetProfile.setUser(userInfo); - userDatasetProfile.setRole(0); + userDatasetProfile.setUser(userInfo.getId()); + userDatasetProfile.setRole(UserDescriptionTemplateRole.Owner); getApiContext().getOperationsContext().getDatabaseRepository().getUserDatasetProfileDao().createOrUpdate(userDatasetProfile); datasetProfileManager.storeDatasetProfileUsers(descriptionTemplateEntity, profile); @@ -211,11 +211,11 @@ public class Admin extends BaseController { if (id == null) { modelDefinition = AdminManager.generateViewStyleDefinition(datasetProfileEntity, getApiContext(), descriptionTemplateTypeService); DescriptionTemplateEntity descriptionTemplateEntity = this.getApiContext().getOperationsContext().getDatabaseRepository().getDatasetProfileDao().createOrUpdate(modelDefinition); - UserDatasetProfile userDatasetProfile = new UserDatasetProfile(); - userDatasetProfile.setDatasetProfile(descriptionTemplateEntity); + UserDescriptionTemplateEntity userDatasetProfile = new UserDescriptionTemplateEntity(); + userDatasetProfile.setDescriptionTemplate(descriptionTemplateEntity.getId()); UserInfo userInfo = getApiContext().getOperationsContext().getDatabaseRepository().getUserInfoDao().find(userScope.getUserId()); - userDatasetProfile.setUser(userInfo); - userDatasetProfile.setRole(0); + userDatasetProfile.setUser(userInfo.getId()); + userDatasetProfile.setRole(UserDescriptionTemplateRole.Owner); getApiContext().getOperationsContext().getDatabaseRepository().getUserDatasetProfileDao().createOrUpdate(userDatasetProfile); } else { modelDefinition = datasetProfileManager.createNewVersionDatasetProfile(id, datasetProfileEntity); diff --git a/dmp-backend/web/src/main/java/eu/eudat/logic/managers/DatasetProfileManager.java b/dmp-backend/web/src/main/java/eu/eudat/logic/managers/DatasetProfileManager.java index 76bcb8b2f..5a96b7a77 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/logic/managers/DatasetProfileManager.java +++ b/dmp-backend/web/src/main/java/eu/eudat/logic/managers/DatasetProfileManager.java @@ -1,10 +1,12 @@ package eu.eudat.logic.managers; import eu.eudat.authorization.Permission; +import eu.eudat.commons.enums.IsActive; +import eu.eudat.commons.enums.UserDescriptionTemplateRole; import eu.eudat.commons.scope.user.UserScope; +import eu.eudat.data.UserDescriptionTemplateEntity; import eu.eudat.data.dao.criteria.DatasetProfileCriteria; import eu.eudat.data.DescriptionTemplateEntity; -import eu.eudat.data.old.UserDatasetProfile; import eu.eudat.data.old.UserInfo; import eu.eudat.data.query.items.item.datasetprofile.DatasetProfileAutocompleteRequest; import eu.eudat.data.query.items.table.datasetprofile.DatasetProfileTableRequestItem; @@ -21,6 +23,7 @@ import eu.eudat.logic.utilities.documents.helpers.FileEnvelope; import eu.eudat.logic.utilities.documents.xml.datasetProfileXml.ExportXmlBuilderDatasetProfile; import eu.eudat.logic.utilities.documents.xml.datasetProfileXml.ImportXmlBuilderDatasetProfile; import eu.eudat.commons.types.descriptiontemplate.fielddata.AutoCompleteDataEntity; +import eu.eudat.model.deleter.UserDescriptionTemplateDeleter; import eu.eudat.models.data.datasetprofile.DatasetProfileAutocompleteItem; import eu.eudat.models.data.datasetprofile.DatasetProfileListingModel; import eu.eudat.commons.types.descriptiontemplate.FieldEntity; @@ -28,11 +31,14 @@ import eu.eudat.models.data.externaldataset.ExternalAutocompleteFieldModel; import eu.eudat.models.data.helpers.common.DataTableData; import eu.eudat.models.data.listingmodels.UserInfoListingModel; import eu.eudat.models.data.mail.SimpleMail; +import eu.eudat.query.DescriptionTemplateQuery; import eu.eudat.query.DescriptionTemplateTypeQuery; +import eu.eudat.query.UserDescriptionTemplateQuery; import eu.eudat.queryable.QueryableList; import eu.eudat.service.descriptiontemplatetype.DescriptionTemplateTypeService; import eu.eudat.types.MetricNames; import gr.cite.commons.web.authz.service.AuthorizationService; +import gr.cite.tools.data.deleter.DeleterFactory; import gr.cite.tools.data.query.QueryFactory; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -80,9 +86,10 @@ public class DatasetProfileManager { private final AuthorizationService authorizationService; private final UserScope userScope; private final QueryFactory queryFactory; + private final DeleterFactory deleterFactory; @Autowired - public DatasetProfileManager(ApiContext apiContext, Environment environment, ConfigLoader configLoader, MetricsManager metricsManager, RemoteFetcher remoteFetcher, DescriptionTemplateTypeService descriptionTemplateTypeService, AuthorizationService authorizationService, UserScope userScope, QueryFactory queryFactory) { + public DatasetProfileManager(ApiContext apiContext, Environment environment, ConfigLoader configLoader, MetricsManager metricsManager, RemoteFetcher remoteFetcher, DescriptionTemplateTypeService descriptionTemplateTypeService, AuthorizationService authorizationService, UserScope userScope, QueryFactory queryFactory, DeleterFactory deleterFactory) { this.apiContext = apiContext; this.databaseRepository = apiContext.getOperationsContext().getDatabaseRepository(); this.environment = environment; @@ -93,6 +100,7 @@ public class DatasetProfileManager { this.authorizationService = authorizationService; this.userScope = userScope; this.queryFactory = queryFactory; + this.deleterFactory = deleterFactory; } @Transactional @@ -386,68 +394,89 @@ public class DatasetProfileManager { } public void storeDatasetProfileUsers(DescriptionTemplateEntity entity, eu.eudat.models.data.admin.composite.DatasetProfile model) { + final List userDescriptionTemplateEntities = this.queryFactory.query(UserDescriptionTemplateQuery.class).isActive(IsActive.Active).descriptionTemplateIds(entity.getId()).collect(); if (model.getUsers() != null && !model.getUsers().isEmpty()) { - if (entity.getUsers() == null) { - entity.setUsers(new HashSet<>()); - } - model.getUsers().stream().filter(userInfoListingModel -> entity.getUsers().stream() - .filter(userDatasetProfile -> userDatasetProfile.getUser().getId().equals(userInfoListingModel.getId())).count() == 0) + model.getUsers().stream().filter(userInfoListingModel -> userDescriptionTemplateEntities.stream() + .filter(userDatasetProfile -> userDatasetProfile.getUser().equals(userInfoListingModel.getId())).count() == 0) .forEach(userInfoListingModel -> { - UserDatasetProfile userDatasetProfile1 = new UserDatasetProfile(); - userDatasetProfile1.setDatasetProfile(entity); + UserDescriptionTemplateEntity userDatasetProfile1 = new UserDescriptionTemplateEntity(); + userDatasetProfile1.setDescriptionTemplate(entity.getId()); UserInfo userInfo1 = null; try { userInfo1 = apiContext.getOperationsContext().getDatabaseRepository().getUserInfoDao().find(userInfoListingModel.getId()); } catch (InvalidApplicationException e) { throw new RuntimeException(e); } - userDatasetProfile1.setUser(userInfo1); - userDatasetProfile1.setRole(1); + userDatasetProfile1.setUser(userInfo1.getId()); + userDatasetProfile1.setRole(UserDescriptionTemplateRole.Member); apiContext.getOperationsContext().getDatabaseRepository().getUserDatasetProfileDao().createOrUpdate(userDatasetProfile1); sendJoinMail(userDatasetProfile1); }); - entity.getUsers().stream().filter(userDatasetProfile -> model.getUsers().stream() - .filter(userInfoListingModel -> userDatasetProfile.getUser().getId().equals(userInfoListingModel.getId())).count() > 0 - && userDatasetProfile.getRole() == 2).forEach(userDatasetProfile -> { - userDatasetProfile.setRole(1); - apiContext.getOperationsContext().getDatabaseRepository().getUserDatasetProfileDao().createOrUpdate(userDatasetProfile); - sendJoinMail(userDatasetProfile); - }); +// userDescriptionTemplateEntities.stream().filter(userDatasetProfile -> model.getUsers().stream() +// .filter(userInfoListingModel -> userDatasetProfile.getUser().equals(userInfoListingModel.getId())).count() > 0 +// && userDatasetProfile.getRole() == UserDescriptionTemplateRole.Saved2).forEach(userDatasetProfile -> { +// userDatasetProfile.setRole(UserDescriptionTemplateRole.Member); +// apiContext.getOperationsContext().getDatabaseRepository().getUserDatasetProfileDao().createOrUpdate(userDatasetProfile); +// sendJoinMail(userDatasetProfile); +// }); } - if (entity.getUsers() != null && !entity.getUsers().isEmpty()) { - entity.getUsers().stream().filter(userDatasetProfile -> model.getUsers().stream() - .filter(userInfoListingModel -> userDatasetProfile.getUser().getId().equals(userInfoListingModel.getId())).count() == 0) + if (userDescriptionTemplateEntities != null && !userDescriptionTemplateEntities.isEmpty()) { + List toDelete = new ArrayList<>(); + + userDescriptionTemplateEntities.stream().filter(userDatasetProfile -> model.getUsers().stream() + .filter(userInfoListingModel -> userDatasetProfile.getUser().equals(userInfoListingModel.getId())).count() == 0) .forEach(userDatasetProfile -> { - userDatasetProfile.setRole(2); + toDelete.add(userDatasetProfile); apiContext.getOperationsContext().getDatabaseRepository().getUserDatasetProfileDao().createOrUpdate(userDatasetProfile); }); + try { + this.deleterFactory.deleter(UserDescriptionTemplateDeleter.class).delete(toDelete); + } catch (InvalidApplicationException e) { + throw new RuntimeException(e); + } + } } @Transactional public void retrieveUsers(DescriptionTemplateEntity entity, eu.eudat.models.data.admin.composite.DatasetProfile model) { - if (entity.getUsers() != null && !entity.getUsers().isEmpty()) { - model.setUsers(entity.getUsers().stream().filter(userDatasetProfile -> userDatasetProfile.getRole() < 2).map(userDatasetProfile -> { + final List userDescriptionTemplateEntities = this.queryFactory.query(UserDescriptionTemplateQuery.class).isActive(IsActive.Active).descriptionTemplateIds(entity.getId()).collect(); + if (userDescriptionTemplateEntities != null && !userDescriptionTemplateEntities.isEmpty()) { + model.setUsers(userDescriptionTemplateEntities.stream().filter(userDatasetProfile -> userDatasetProfile.getRole().getValue() < 2).map(userDatasetProfile -> { + UserInfo user = null; + try { + user = this.apiContext.getOperationsContext().getDatabaseRepository().getUserInfoDao().find(userDatasetProfile.getUser()); + } catch (InvalidApplicationException e) { + throw new RuntimeException(e); + } UserInfoListingModel userInfoListingModel = new UserInfoListingModel(); - userInfoListingModel.setId(userDatasetProfile.getUser().getId()); - userInfoListingModel.setName(userDatasetProfile.getUser().getName()); - userInfoListingModel.setEmail(userDatasetProfile.getUser().getEmail()); - userInfoListingModel.setRole(userDatasetProfile.getRole()); + userInfoListingModel.setId(user.getId()); + userInfoListingModel.setName(user.getName()); + userInfoListingModel.setEmail(user.getEmail()); + userInfoListingModel.setRole(userDatasetProfile.getRole().getValue()); return userInfoListingModel; }).collect(Collectors.toList())); } } - private void sendJoinMail(UserDatasetProfile userDatasetProfile) { + private void sendJoinMail(UserDescriptionTemplateEntity userDatasetProfile) { SimpleMail mail = new SimpleMail(); - mail.setSubject(environment.getProperty("admin.mail.subject").replace( "{templateName}", userDatasetProfile.getDatasetProfile().getLabel())); + UserInfo user = null; + try { + user = this.apiContext.getOperationsContext().getDatabaseRepository().getUserInfoDao().find(userDatasetProfile.getUser()); + } catch (InvalidApplicationException e) { + throw new RuntimeException(e); + } + DescriptionTemplateEntity descriptionTemplate = this.queryFactory.query(DescriptionTemplateQuery.class).isActive(IsActive.Active).ids(userDatasetProfile.getDescriptionTemplate()).first(); + + mail.setSubject(environment.getProperty("admin.mail.subject").replace( "{templateName}", descriptionTemplate.getLabel())); String content = apiContext.getUtilitiesService().getMailService().getMailTemplateContent(environment.getProperty("email.dataset.template")); - content = content.replace("{recipient}", userDatasetProfile.getUser().getName()); - content = content.replace("{templateName}", userDatasetProfile.getDatasetProfile().getLabel()); + content = content.replace("{recipient}", user.getName()); + content = content.replace("{templateName}", descriptionTemplate.getLabel()); content = content.replace("{host}", this.environment.getProperty("dmp.domain")); - content = content.replace("{templateID}", userDatasetProfile.getDatasetProfile().getId().toString()); + content = content.replace("{templateID}", descriptionTemplate.getId().toString()); mail.setContent(content); - mail.setTo(userDatasetProfile.getUser().getEmail()); + mail.setTo(user.getEmail()); try { apiContext.getUtilitiesService().getMailService().sendSimpleMail(mail); } catch (Exception ex) { diff --git a/dmp-db-scema/updates/00.01.011_Align_UserDescriptionTemplate_table.sql b/dmp-db-scema/updates/00.01.011_Align_UserDescriptionTemplate_table.sql new file mode 100644 index 000000000..7735e159c --- /dev/null +++ b/dmp-db-scema/updates/00.01.011_Align_UserDescriptionTemplate_table.sql @@ -0,0 +1,29 @@ +ALTER TABLE public."UserDatasetProfile" RENAME TO "UserDescriptionTemplate"; + +ALTER TABLE public."UserDescriptionTemplate" RENAME usr TO "user"; + +ALTER TABLE public."UserDescriptionTemplate" RENAME "descriptionTemplate" TO description_template; + +ALTER TABLE public."UserDescriptionTemplate" ALTER COLUMN "role" TYPE smallint; +ALTER TABLE public."UserDescriptionTemplate" ALTER COLUMN "role" SET NOT NULL; + +ALTER TABLE public."UserDescriptionTemplate" ADD COLUMN updated_at timestamp without time zone; + +ALTER TABLE public."UserDescriptionTemplate" ADD COLUMN created_at timestamp without time zone; + +ALTER TABLE public."UserDescriptionTemplate" ADD COLUMN is_active smallint; + +UPDATE public."UserDescriptionTemplate" SET is_active = 1; + +UPDATE public."UserDescriptionTemplate" SET is_active = 0 where role = 2; +UPDATE public."UserDescriptionTemplate" SET role = 1 where is_active = 0; + +ALTER TABLE public."UserDescriptionTemplate" ALTER COLUMN is_active SET NOT NULL; + +UPDATE public."UserDescriptionTemplate" SET updated_at = now() at time zone 'utc'; + +ALTER TABLE public."UserDescriptionTemplate" ALTER COLUMN updated_at SET NOT NULL; + +UPDATE public."UserDescriptionTemplate" SET created_at = now() at time zone 'utc'; + +ALTER TABLE public."UserDescriptionTemplate" ALTER COLUMN created_at SET NOT NULL; \ No newline at end of file