237 lines
13 KiB
Java
237 lines
13 KiB
Java
package eu.eudat.model.builder.commonmodels.dmp;
|
|
|
|
import eu.eudat.authorization.AuthorizationFlags;
|
|
import eu.eudat.commonmodels.enums.DmpAccessType;
|
|
import eu.eudat.commonmodels.enums.DmpStatus;
|
|
import eu.eudat.commonmodels.models.DmpUserModel;
|
|
import eu.eudat.commonmodels.models.EntityDoiModel;
|
|
import eu.eudat.commonmodels.models.FileEnvelopeModel;
|
|
import eu.eudat.commonmodels.models.UserModel;
|
|
import eu.eudat.commonmodels.models.description.DescriptionModel;
|
|
import eu.eudat.commonmodels.models.dmp.DmpModel;
|
|
import eu.eudat.commonmodels.models.dmpblueprint.DmpBlueprintModel;
|
|
import eu.eudat.commonmodels.models.dmpreference.DmpReferenceModel;
|
|
import eu.eudat.commons.JsonHandlingService;
|
|
import eu.eudat.commons.enums.IsActive;
|
|
import eu.eudat.commons.types.dmp.DmpPropertiesEntity;
|
|
import eu.eudat.convention.ConventionService;
|
|
import eu.eudat.data.*;
|
|
import eu.eudat.model.*;
|
|
import eu.eudat.model.builder.commonmodels.*;
|
|
import eu.eudat.model.builder.commonmodels.description.DescriptionCommonModelBuilder;
|
|
import eu.eudat.model.builder.commonmodels.dmpblueprint.DmpBlueprintCommonModelBuilder;
|
|
import eu.eudat.model.builder.commonmodels.dmpreference.DmpReferenceCommonModelBuilder;
|
|
import eu.eudat.query.*;
|
|
import gr.cite.tools.data.builder.BuilderFactory;
|
|
import gr.cite.tools.data.query.Ordering;
|
|
import gr.cite.tools.data.query.QueryFactory;
|
|
import gr.cite.tools.exception.MyApplicationException;
|
|
import gr.cite.tools.fieldset.BaseFieldSet;
|
|
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 DmpCommonModelBuilder extends BaseCommonModelBuilder<DmpModel, DmpEntity> {
|
|
|
|
private final QueryFactory queryFactory;
|
|
|
|
private final BuilderFactory builderFactory;
|
|
private final JsonHandlingService jsonHandlingService;
|
|
private FileEnvelopeModel pdfFile;
|
|
private FileEnvelopeModel rdaJsonFile;
|
|
private String repositoryId;
|
|
private boolean disableDescriptions;
|
|
private EnumSet<AuthorizationFlags> authorize = EnumSet.of(AuthorizationFlags.None);
|
|
|
|
@Autowired
|
|
public DmpCommonModelBuilder(ConventionService conventionService,
|
|
QueryFactory queryFactory,
|
|
BuilderFactory builderFactory, JsonHandlingService jsonHandlingService) {
|
|
super(conventionService, new LoggerService(LoggerFactory.getLogger(DmpCommonModelBuilder.class)));
|
|
this.queryFactory = queryFactory;
|
|
this.builderFactory = builderFactory;
|
|
this.jsonHandlingService = jsonHandlingService;
|
|
}
|
|
|
|
public DmpCommonModelBuilder authorize(EnumSet<AuthorizationFlags> values) {
|
|
this.authorize = values;
|
|
return this;
|
|
}
|
|
|
|
public DmpCommonModelBuilder setPdfFile(FileEnvelopeModel pdfFile) {
|
|
this.pdfFile = pdfFile;
|
|
return this;
|
|
}
|
|
|
|
public DmpCommonModelBuilder setRdaJsonFile(FileEnvelopeModel rdaJsonFile) {
|
|
this.rdaJsonFile = rdaJsonFile;
|
|
return this;
|
|
}
|
|
|
|
public DmpCommonModelBuilder setRepositoryId(String repositoryId) {
|
|
this.repositoryId = repositoryId;
|
|
return this;
|
|
}
|
|
|
|
public DmpCommonModelBuilder setDisableDescriptions(boolean disableDescriptions) {
|
|
this.disableDescriptions = disableDescriptions;
|
|
return this;
|
|
}
|
|
|
|
|
|
private boolean useSharedStorage;
|
|
public DmpCommonModelBuilder useSharedStorage(boolean useSharedStorage) {
|
|
this.useSharedStorage = useSharedStorage;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
protected List<CommonModelBuilderItemResponse<DmpModel, DmpEntity>> buildInternal(List<DmpEntity> data) throws MyApplicationException {
|
|
this.logger.debug("building for {}", Optional.ofNullable(data).map(List::size).orElse(0));
|
|
if (data == null || data.isEmpty()) return new ArrayList<>();
|
|
|
|
List<CommonModelBuilderItemResponse<DmpModel, DmpEntity>> models = new ArrayList<>();
|
|
|
|
Map<UUID, List<DmpReferenceModel>> dmpReferencesMap = this.collectDmpReferences(data);
|
|
Map<UUID, List<DmpUserModel>> dmpUsersMap = this.collectDmpUsers(data);
|
|
Map<UUID, List<DescriptionModel>> descriptionsMap = this.disableDescriptions ? null : this.collectDmpDescriptions(data);
|
|
Map<UUID, List<EntityDoiModel>> entityDois = this.collectDmpEntityDois(data);
|
|
Map<UUID, UserModel> creators = this.collectCreators(data);
|
|
Map<UUID, DmpBlueprintModel> dmpBlueprints = this.collectDmpBlueprints(data);
|
|
|
|
for (DmpEntity d : data) {
|
|
DmpModel m = new DmpModel();
|
|
m.setId(d.getId());
|
|
m.setLabel(d.getLabel());
|
|
m.setVersion(d.getVersion());
|
|
m.setDescription(d.getDescription());
|
|
m.setFinalizedAt(d.getFinalizedAt());
|
|
m.setCreatedAt(d.getCreatedAt());
|
|
m.setLanguage(d.getLanguage());
|
|
switch (d.getStatus()){
|
|
case Finalized -> m.setStatus(DmpStatus.Finalized);
|
|
case Draft -> m.setStatus(DmpStatus.Draft);
|
|
default -> throw new MyApplicationException("unrecognized type " + d.getStatus());
|
|
}
|
|
if (entityDois != null && !entityDois.isEmpty() && entityDois.containsKey(d.getId())) m.setEntityDois(entityDois.get(d.getId()));
|
|
if (creators != null && !creators.isEmpty() && d.getCreatorId() != null && creators.containsKey(d.getCreatorId())) m.setCreator(creators.get(d.getCreatorId()));
|
|
if (dmpBlueprints != null && !dmpBlueprints.isEmpty() && d.getBlueprintId() != null && dmpBlueprints.containsKey(d.getBlueprintId())) m.setDmpBlueprint(dmpBlueprints.get(d.getBlueprintId()));
|
|
if (d.getProperties() != null){
|
|
//TODO Update with the new logic of property definition
|
|
DmpPropertiesEntity propertyDefinition = this.jsonHandlingService.fromJsonSafe(DmpPropertiesEntity.class, d.getProperties());
|
|
m.setProperties(this.builderFactory.builder(DmpPropertiesCommonModelBuilder.class).authorize(this.authorize).build(propertyDefinition));
|
|
}
|
|
m.setPublicAfter(d.getPublicAfter());
|
|
m.setUpdatedAt(d.getUpdatedAt());
|
|
m.setPdfFile(this.pdfFile);
|
|
m.setRdaJsonFile(this.rdaJsonFile);
|
|
if (d.getVersion() > (short)1) m.setPreviousDOI(this.getPreviousDOI(d.getGroupId(), d.getId()));
|
|
switch (d.getAccessType()){
|
|
case Public -> m.setAccessType(DmpAccessType.Public);
|
|
case Restricted -> m.setAccessType(DmpAccessType.Restricted);
|
|
case null -> m.setAccessType(null);
|
|
default -> throw new MyApplicationException("unrecognized type " + d.getAccessType());
|
|
}
|
|
|
|
if (dmpReferencesMap != null && !dmpReferencesMap.isEmpty() && dmpReferencesMap.containsKey(d.getId())) m.setReferences(dmpReferencesMap.get(d.getId()));
|
|
if (dmpUsersMap != null && !dmpUsersMap.isEmpty() && dmpUsersMap.containsKey(d.getId())) m.setUsers(dmpUsersMap.get(d.getId()));
|
|
if (descriptionsMap != null && !descriptionsMap.isEmpty() && descriptionsMap.containsKey(d.getId())) m.setDescriptions(descriptionsMap.get(d.getId()));
|
|
|
|
models.add(new CommonModelBuilderItemResponse<>(m, d));
|
|
}
|
|
this.logger.debug("build {} items", Optional.of(models).map(List::size).orElse(0));
|
|
|
|
return models;
|
|
}
|
|
|
|
private String getPreviousDOI(UUID dmpGroup, UUID currentDmpId) {
|
|
if (repositoryId == null || repositoryId.isEmpty()) throw new MyApplicationException("repositoryId required");
|
|
|
|
//GK: Step one get the previous version of the Data management plan
|
|
DmpQuery dmpQuery = this.queryFactory.query(DmpQuery.class);
|
|
dmpQuery.setOrder(new Ordering().addDescending(Dmp._version));
|
|
List<UUID> dmpIds = dmpQuery.groupIds(dmpGroup).excludedIds(currentDmpId).isActive(IsActive.Active).collectAs(new BaseFieldSet().ensure(Dmp._id)).stream().map(DmpEntity::getId).toList();
|
|
|
|
//GK: Step two get it's doiEntity
|
|
List<EntityDoiEntity> dois = this.queryFactory.query(EntityDoiQuery.class).repositoryIds(repositoryId).entityIds(dmpIds).isActive(IsActive.Active).collectAs(new BaseFieldSet().ensure(EntityDoi._entityId, EntityDoi._doi));
|
|
for(UUID uuid: dmpIds) {
|
|
EntityDoiEntity doiEntity = dois.stream().filter(x -> x.getEntityId().equals(uuid)).findFirst().orElse(null);
|
|
if (doiEntity != null) return doiEntity.getDoi();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private Map<UUID, List<DmpUserModel>> collectDmpUsers(List<DmpEntity> data) throws MyApplicationException {
|
|
this.logger.debug("checking related - {}", DmpUser.class.getSimpleName());
|
|
|
|
Map<UUID, List<DmpUserModel>> itemMap;
|
|
DmpUserQuery query = this.queryFactory.query(DmpUserQuery.class).isActives(IsActive.Active).authorize(this.authorize).dmpIds(data.stream().map(DmpEntity::getId).distinct().collect(Collectors.toList()));
|
|
itemMap = this.builderFactory.builder(DmpUserCommonModelBuilder.class).authorize(this.authorize).asMasterKey(query, DmpUserEntity::getDmpId);
|
|
|
|
return itemMap;
|
|
}
|
|
|
|
private Map<UUID, List<DmpReferenceModel>> collectDmpReferences(List<DmpEntity> data) throws MyApplicationException {
|
|
this.logger.debug("checking related - {}", DmpReference.class.getSimpleName());
|
|
|
|
Map<UUID, List<DmpReferenceModel>> itemMap;
|
|
DmpReferenceQuery query = this.queryFactory.query(DmpReferenceQuery.class).isActives(IsActive.Active).authorize(this.authorize).dmpIds(data.stream().map(DmpEntity::getId).distinct().collect(Collectors.toList()));
|
|
itemMap = this.builderFactory.builder(DmpReferenceCommonModelBuilder.class).authorize(this.authorize).asMasterKey(query, DmpReferenceEntity::getDmpId);
|
|
|
|
return itemMap;
|
|
}
|
|
|
|
private Map<UUID, List<DescriptionModel>> collectDmpDescriptions(List<DmpEntity> data) throws MyApplicationException {
|
|
if (data.isEmpty()) return null;
|
|
this.logger.debug("checking related - {}", Description.class.getSimpleName());
|
|
|
|
Map<UUID, List<DescriptionModel>> itemMap;
|
|
DescriptionQuery query = this.queryFactory.query(DescriptionQuery.class).isActive(IsActive.Active).authorize(this.authorize).dmpIds(data.stream().map(DmpEntity::getId).distinct().collect(Collectors.toList()));
|
|
itemMap = this.builderFactory.builder(DescriptionCommonModelBuilder.class).setRepositoryId(repositoryId).useSharedStorage(useSharedStorage).authorize(this.authorize).asMasterKey(query, DescriptionEntity::getDmpId);
|
|
|
|
return itemMap;
|
|
}
|
|
|
|
private Map<UUID, List<EntityDoiModel>> collectDmpEntityDois(List<DmpEntity> data) throws MyApplicationException {
|
|
if (data.isEmpty()) return null;
|
|
this.logger.debug("checking related - {}", EntityDoi.class.getSimpleName());
|
|
|
|
Map<UUID, List<EntityDoiModel>> itemMap;
|
|
EntityDoiQuery query = this.queryFactory.query(EntityDoiQuery.class).isActive(IsActive.Active).authorize(this.authorize).entityIds(data.stream().map(DmpEntity::getId).distinct().collect(Collectors.toList()));
|
|
itemMap = this.builderFactory.builder(EntityDoiCommonModelBuilder.class).authorize(this.authorize).asMasterKey(query, EntityDoiEntity::getEntityId);
|
|
|
|
return itemMap;
|
|
}
|
|
|
|
private Map<UUID, UserModel> collectCreators(List<DmpEntity> data) throws MyApplicationException {
|
|
if (data.isEmpty())
|
|
return null;
|
|
this.logger.debug("checking related - {}", UserModel.class.getSimpleName());
|
|
|
|
Map<UUID, UserModel> itemMap;
|
|
UserQuery q = this.queryFactory.query(UserQuery.class).isActive(IsActive.Active).authorize(this.authorize).ids(data.stream().filter(x-> x.getCreatorId() != null).map(DmpEntity::getCreatorId).distinct().collect(Collectors.toList()));
|
|
itemMap = this.builderFactory.builder(UserCommonModelBuilder.class).authorize(this.authorize).asForeignKey(q, UserEntity::getId);
|
|
return itemMap;
|
|
}
|
|
|
|
private Map<UUID, DmpBlueprintModel> collectDmpBlueprints(List<DmpEntity> data) throws MyApplicationException {
|
|
if (data.isEmpty())
|
|
return null;
|
|
this.logger.debug("checking related - {}", DmpBlueprintModel.class.getSimpleName());
|
|
|
|
Map<UUID, DmpBlueprintModel> itemMap;
|
|
DmpBlueprintQuery q = this.queryFactory.query(DmpBlueprintQuery.class).isActive(IsActive.Active).authorize(this.authorize).ids(data.stream().filter(x-> x.getBlueprintId() != null).map(DmpEntity::getBlueprintId).distinct().collect(Collectors.toList()));
|
|
itemMap = this.builderFactory.builder(DmpBlueprintCommonModelBuilder.class).authorize(this.authorize).asForeignKey(q, DmpBlueprintEntity::getId);
|
|
return itemMap;
|
|
}
|
|
|
|
}
|