argos/dmp-backend/core/src/main/java/eu/eudat/elastic/elasticbuilder/DmpElasticBuilder.java

package eu.eudat.elastic.elasticbuilder;

import eu.eudat.commons.enums.IsActive;
import eu.eudat.convention.ConventionService;
import eu.eudat.data.*;
import eu.eudat.elastic.data.DmpElasticEntity;
import eu.eudat.elastic.data.nested.*;
import eu.eudat.elastic.elasticbuilder.nested.*;
import eu.eudat.model.DmpReference;
import eu.eudat.query.*;
import gr.cite.tools.data.builder.BuilderFactory;
import gr.cite.tools.data.query.QueryFactory;
import gr.cite.tools.exception.MyApplicationException;
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 DmpElasticBuilder extends BaseElasticBuilder<DmpElasticEntity, DmpEntity> {

    private final QueryFactory queryFactory;
    private final BuilderFactory builderFactory;
    
    @Autowired
    public DmpElasticBuilder(
            ConventionService conventionService, QueryFactory queryFactory, BuilderFactory builderFactory) {
        super(conventionService, new LoggerService(LoggerFactory.getLogger(DmpElasticBuilder.class)));
        this.queryFactory = queryFactory;
        this.builderFactory = builderFactory;
    }

    @Override
    public List<DmpElasticEntity> build(List<DmpEntity> data) throws MyApplicationException {
        if (data == null)
            return new ArrayList<>();

        Map<UUID, List<NestedReferenceElasticEntity>> referenceElasticEntityMap = this.collectDmpReferences(data);
        Map<UUID, List<NestedDescriptionElasticEntity>> descriptionElasticEntityMap = this.collectDescriptions(data);
        Map<UUID, List<NestedCollaboratorElasticEntity>> collaboratorElasticEntityMap = this.collectCollaborators(data);
        Map<UUID, List<NestedDoiElasticEntity>> doiElasticEntityMap = this.collectDois(data);
        
        List<DmpElasticEntity> models = new ArrayList<>();
        for (DmpEntity d : data) {
            DmpElasticEntity m = new DmpElasticEntity();
            m.setId(d.getId());
            m.setLabel(d.getLabel());
            m.setDescription(d.getDescription());
            m.setVersion(d.getVersion());
            m.setVersionStatus(d.getVersionStatus());
            m.setStatus(d.getStatus());
            m.setAccessType(d.getAccessType());
            m.setLanguage(d.getLanguage());
            m.setBlueprintId(d.getBlueprintId());
            m.setGroupId(d.getGroupId());
            if (d.getFinalizedAt() != null) {
                m.setFinalizedAt(Date.from(d.getFinalizedAt()));
            }
            if (d.getTenantId() != null) {
                m.setTenantId(d.getTenantId());
            }
            if (referenceElasticEntityMap != null) m.setReferences(referenceElasticEntityMap.getOrDefault(d.getId(), null));
            if (descriptionElasticEntityMap != null) m.setDescriptions(descriptionElasticEntityMap.getOrDefault(d.getId(), null));
            if (collaboratorElasticEntityMap != null) m.setCollaborators(collaboratorElasticEntityMap.getOrDefault(d.getId(), null));
            if (doiElasticEntityMap != null) m.setDois(doiElasticEntityMap.getOrDefault(d.getId(), null));
            models.add(m);
        }
        this.logger.debug("build {} items", Optional.of(models).map(List::size).orElse(0));
        return models;
    }

    private Map<UUID, List<NestedReferenceElasticEntity>> collectDmpReferences(List<DmpEntity> data) throws MyApplicationException {
        if (data.isEmpty()) return null;
        this.logger.debug("checking related - {}", DmpReference.class.getSimpleName());

        DmpReferenceQuery associationQuery = this.queryFactory.query(DmpReferenceQuery.class).dmpIds(data.stream().map(DmpEntity::getId).collect(Collectors.toList())).isActives(IsActive.Active);
        List<DmpReferenceEntity> associationEntities = associationQuery.collect();
        
        ReferenceQuery query = this.queryFactory.query(ReferenceQuery.class).isActive(IsActive.Active).ids(associationEntities.stream().map(DmpReferenceEntity::getReferenceId).distinct().collect(Collectors.toList()));
        Map<UUID, NestedReferenceElasticEntity> itemMapById = this.builderFactory.builder(NestedReferenceElasticBuilder.class).asForeignKey(query, NestedReferenceElasticEntity::getId);

        Map<UUID, List<NestedReferenceElasticEntity>> itemMap = new HashMap<>();
        for (DmpReferenceEntity associationEntity : associationEntities){
            if (!itemMap.containsKey(associationEntity.getDmpId())) itemMap.put(associationEntity.getDmpId(), new ArrayList<>());
            NestedReferenceElasticEntity item = itemMapById.getOrDefault(associationEntity.getReferenceId(), null);
            if (item != null) itemMap.get(associationEntity.getDmpId()).add(item);
        }

        return itemMap;
    }

    private Map<UUID, List<NestedDescriptionElasticEntity>> collectDescriptions(List<DmpEntity> data) throws MyApplicationException {
        if (data.isEmpty())
            return null;
        this.logger.debug("checking related - {}", DescriptionEntity.class.getSimpleName());

        Map<UUID, List<NestedDescriptionElasticEntity>> itemMap;
        DescriptionQuery q = this.queryFactory.query(DescriptionQuery.class).isActive(IsActive.Active).dmpSubQuery(this.queryFactory.query(DmpQuery.class).ids(data.stream().map(DmpEntity::getId).distinct().collect(Collectors.toList())));
        itemMap = this.builderFactory.builder(NestedDescriptionElasticBuilder.class).asMasterKey(q, NestedDescriptionElasticEntity::getDmpId);

        return itemMap;
    }

    private Map<UUID, List<NestedCollaboratorElasticEntity>> collectCollaborators(List<DmpEntity> data) throws MyApplicationException {
        if (data.isEmpty())
            return null;
        this.logger.debug("checking related - {}", DmpUserEntity.class.getSimpleName());

        DmpUserQuery associationQuery = this.queryFactory.query(DmpUserQuery.class).dmpIds(data.stream().map(DmpEntity::getId).collect(Collectors.toList())).isActives(IsActive.Active);
        List<DmpUserEntity> associationEntities = associationQuery.collect();

        Map<UUID, NestedCollaboratorElasticEntity> itemMapById = this.builderFactory.builder(NestedCollaboratorElasticBuilder.class).asForeignKey(associationEntities, NestedCollaboratorElasticEntity::getId);

        Map<UUID, List<NestedCollaboratorElasticEntity>> itemMap = new HashMap<>();
        for (DmpUserEntity associationEntity : associationEntities){
            if (!itemMap.containsKey(associationEntity.getId())) itemMap.put(associationEntity.getDmpId(), new ArrayList<>());
            NestedCollaboratorElasticEntity item = itemMapById.getOrDefault(associationEntity.getId(), null);
            if (item != null) itemMap.get(associationEntity.getDmpId()).add(item);
        }
        return itemMap;
    }

    private Map<UUID, List<NestedDoiElasticEntity>> collectDois(List<DmpEntity> data) throws MyApplicationException {
        if (data.isEmpty())
            return null;
        this.logger.debug("checking related - {}", EntityDoiEntity.class.getSimpleName());

        EntityDoiQuery associationQuery = this.queryFactory.query(EntityDoiQuery.class).entityIds(data.stream().map(DmpEntity::getId).collect(Collectors.toList())).isActive(IsActive.Active);
        List<EntityDoiEntity> associationEntities = associationQuery.collect();

        Map<UUID, NestedDoiElasticEntity> itemMapById = this.builderFactory.builder(NestedDoiElasticBuilder.class).asForeignKey(associationEntities, NestedDoiElasticEntity::getId);

        Map<UUID, List<NestedDoiElasticEntity>> itemMap = new HashMap<>();
        for (EntityDoiEntity associationEntity : associationEntities){
            if (!itemMap.containsKey(associationEntity.getId())) itemMap.put(associationEntity.getEntityId(), new ArrayList<>());
            NestedDoiElasticEntity item = itemMapById.getOrDefault(associationEntity.getId(), null);
            if (item != null) itemMap.get(associationEntity.getEntityId()).add(item);
        }
        return itemMap;
    }
}