LunaticJsonRawDataMongoAdapter.java

package fr.insee.genesis.infrastructure.adapter;

import fr.insee.genesis.Constants;
import fr.insee.genesis.domain.model.surveyunit.GroupedInterrogation;
import fr.insee.genesis.domain.model.surveyunit.Mode;
import fr.insee.genesis.domain.model.surveyunit.rawdata.LunaticJsonRawDataModel;
import fr.insee.genesis.domain.ports.spi.LunaticJsonRawDataPersistencePort;
import fr.insee.genesis.infrastructure.document.rawdata.LunaticJsonRawDataDocument;
import fr.insee.genesis.infrastructure.mappers.GroupedInterrogationDocumentMapper;
import fr.insee.genesis.infrastructure.mappers.LunaticJsonRawDataDocumentMapper;
import fr.insee.genesis.infrastructure.repository.LunaticJsonMongoDBRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

import java.time.Instant;
import java.time.LocalDateTime;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@Slf4j
@Service
@Qualifier("lunaticJsonMongoAdapter")
public class LunaticJsonRawDataMongoAdapter implements LunaticJsonRawDataPersistencePort {

    private final LunaticJsonMongoDBRepository repository;
    private final MongoTemplate mongoTemplate;

    public LunaticJsonRawDataMongoAdapter(LunaticJsonMongoDBRepository repository, MongoTemplate mongoTemplate) {
        this.repository = repository;
        this.mongoTemplate = mongoTemplate;
    }

    @Override
    public void save(LunaticJsonRawDataModel rawData) {
        LunaticJsonRawDataDocument doc = LunaticJsonRawDataDocumentMapper.INSTANCE.modelToDocument(rawData);
        repository.insert(doc);
    }

    @Override
    public Set<String> findDistinctQuestionnaireIdsByNullProcessDate(){
        return new HashSet<>(repository.findDistinctQuestionnaireIdByProcessDateIsNull());
    }

    @Override
    public Set<Mode> findModesByQuestionnaire(String questionnaireId) {
        return new HashSet<>(repository.findModesByQuestionnaireId(questionnaireId));
    }

    @Override
    public List<LunaticJsonRawDataModel> findRawDataByQuestionnaireId(String questionnaireId, Mode mode, List<String> interrogationIdList) {
        List<LunaticJsonRawDataDocument> rawDataDocs = repository.findByQuestionnaireModeAndInterrogations(questionnaireId, mode, interrogationIdList);
        return LunaticJsonRawDataDocumentMapper.INSTANCE.listDocumentToListModel(rawDataDocs);
    }

    @Override
    public Page<LunaticJsonRawDataModel> findRawDataByQuestionnaireId(String questionnaireId, Pageable pageable) {
        Page<LunaticJsonRawDataDocument> rawDataDocsPage =  repository.findByQuestionnaireId(questionnaireId, pageable);
        List<LunaticJsonRawDataModel> modelList = LunaticJsonRawDataDocumentMapper.INSTANCE.listDocumentToListModel(rawDataDocsPage.getContent());
        return new PageImpl<>(modelList, rawDataDocsPage.getPageable(), rawDataDocsPage.getTotalElements());
    }

    @Override
    public List<LunaticJsonRawDataModel> findRawDataByInterrogationId(String interrogationId) {
        List<LunaticJsonRawDataDocument> rawDataDocs = repository.findByInterrogationId(interrogationId);
        return LunaticJsonRawDataDocumentMapper.INSTANCE.listDocumentToListModel(rawDataDocs);
    }

    @Override
    public void updateProcessDates(String questionnaireId, Set<String> interrogationIds) {
        mongoTemplate.updateMulti(
                Query.query(Criteria.where("questionnaireId").is(questionnaireId).and("interrogationId").in(interrogationIds))
                , new Update().set("processDate", LocalDateTime.now())
                , Constants.MONGODB_LUNATIC_RAWDATA_COLLECTION_NAME
        );
    }

    @Override
    public Set<String> findDistinctQuestionnaireIds() {
        List<String> ids = mongoTemplate.query(LunaticJsonRawDataDocument.class)
                    .distinct("questionnaireId")
                    .as(String.class)
                    .all();
        return ids.stream()
                    .filter(id -> id != null && !id.isBlank())
                    .collect(java.util.stream.Collectors.toSet());
        }

    @Override
    public Page<LunaticJsonRawDataModel> findByCampaignIdAndDate(String campaignId, Instant startDt, Instant  endDt, Pageable pageable) {
        Page<LunaticJsonRawDataDocument> rawDataDocsPage =  repository.findByCampaignIdAndRecordDateBetween(campaignId,startDt,endDt,pageable);
        List<LunaticJsonRawDataModel> modelList = LunaticJsonRawDataDocumentMapper.INSTANCE.listDocumentToListModel(rawDataDocsPage.getContent());
        return new PageImpl<>(modelList, rawDataDocsPage.getPageable(), rawDataDocsPage.getTotalElements());
    }

    @Override
    public long countRawResponsesByQuestionnaireId(String questionnaireId) {
        return repository.countByQuestionnaireId(questionnaireId);
    }

    @Override
    public List<GroupedInterrogation> findProcessedIdsGroupedByQuestionnaireSince(LocalDateTime since){
        return GroupedInterrogationDocumentMapper.INSTANCE.listDocumentToListModel(repository.aggregateRawGrouped(since));
    }

    @Override
    public List<GroupedInterrogation> findUnprocessedIds() {
        return GroupedInterrogationDocumentMapper.INSTANCE.listDocumentToListModel(repository.aggregateRawGroupedWithNullProcessDate());
    }

    @Override
    public Set<String> findUnprocessedInterrogationIdsByCollectionInstrumentId(String collectionInstrumentId) {
        Set<String> interrogationIds = new HashSet<>();

        repository.aggregateRawGroupedWithNullProcessDate(collectionInstrumentId).forEach(
                groupedInterrogationDocument -> interrogationIds.addAll(groupedInterrogationDocument.getInterrogationIds())
        );

        return interrogationIds;
    }

    @Override
    public boolean existsByInterrogationId(String interrogationId) {
        return repository.existsByInterrogationId(interrogationId);
    }

    @Override
    public long countDistinctInterrogationIdsByQuestionnaireId(String questionnaireId) {
        Long count = repository.countDistinctInterrogationIdsByQuestionnaireId(questionnaireId);
        return count != null ? count : 0;
    }

}