~fstephanie/sources_fdx_api.git

package com.megatim.apifdxweb.core.impl.helper;
 
import com.megatim.apifdxweb.core.ifaces.helper.DataConsumptionOperations;
import com.megatim.apifdxweb.core.ifaces.helper.RoutingChecker;
import com.megatim.apifdxweb.dao.impl.audit.AuditActionsParticicipantsQuery;
import com.megatim.apifdxweb.dao.impl.audit.AuditActionsParticipantRepository;
import com.megatim.apifdxweb.model.audit.AuditActionsParticipant;
import com.megatim.apifdxweb.tools.AppContext;
import com.megatim.commons.tools.exceptions.ApplicationServerException;
import com.megatim.fdxcommons.core.ifaces.helper.DataInMemoryHandler;
import com.megatim.fdxcommons.model.enumeration.CriteriaLogicConnector;
import com.megatim.fdxcommons.model.enumeration.Operateur;
import com.megatim.fdxcommons.model.pojo.CriteriaEntityFromView;
import com.megatim.fdxcommons.model.pojo.PageData;
import com.megatim.fdxcommons.tools.database.connection.DBConnection;
import com.megatim.fdxcommons.tools.database.queries.metadata.QueryCriterion;
import com.megatim.fdxcommons.tools.database.queries.metadata.SelectQueryResult;
import com.megatim.fdxcommons.tools.database.tables.DateActionColumnDefinition;
import com.megatim.fdxcommons.tools.database.tables.FdxApiTable;
import com.megatim.fdxcommons.tools.database.tables.FdxTableRow;
import com.megatim.fdxcommons.tools.database.tables.IndexColumnDefinition;
import com.megatim.fdxcommons.tools.exceptions.CommonApplicationServerException;
import com.megatim.fdxcommons.tools.exceptions.CommonRessourceNotFoundException;
import com.megatim.fdxcommons.tools.utils.CriteriaEntityFromViewToQueryCriterion;
import java.sql.Connection;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import javax.ejb.EJB;
import javax.enterprise.context.Dependent;
import javax.inject.Inject;
import javax.sql.DataSource;
 
/**
 *
 * @author Gabuntu
 */
@Dependent
public class DataConsumptionOperationsImpl implements DataConsumptionOperations {
 
    @Resource(lookup = AppContext.JNDI_NAME)
    private DataSource dataSource;
 
    @Inject
    private DataInMemoryHandler dataInMemoryHandler;
 
    @Inject
    private RoutingChecker routingChecker;
 
    @EJB
    private AuditActionsParticipantRepository auditActionsParticipantRepository;
 
    @Override
    public List<Map<String, Object>> loadAll(String codeTypeFichier, String codeParticipant) {
        stopIfNotConsumer(codeTypeFichier, codeParticipant);
 
        try ( Connection connection = new DBConnection(dataSource).connection()) {
 
            connection.setAutoCommit(false);
 
            SelectQueryResult result = selectResult(connection, codeTypeFichier, null);
            performAudit(connection, codeParticipant, codeTypeFichier, result.lastIndexRead());
 
            connection.commit();
 
            return selectedData(result.rows());
        } catch (Exception ex) {
            Logger.getLogger(DataConsumptionOperationsImpl.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
            throw new CommonApplicationServerException();
        }
    }
 
    @Override
    public List<Map<String, Object>> findByCriterias(String codeTypeFichier, CriteriaEntityFromView criterion, String codeParticipant) {
        stopIfNotConsumer(codeTypeFichier, codeParticipant);
 
        try ( Connection connection = new DBConnection(dataSource).connection()) {
 
            SelectQueryResult result = selectResult(connection, codeTypeFichier, new CriteriaEntityFromViewToQueryCriterion(criterion).queryCriterion());
            return selectedData(result.rows());
 
        } catch (Exception ex) {
            Logger.getLogger(DataConsumptionOperationsImpl.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
            throw new CommonApplicationServerException();
        }
    }
 
//    @Override
//    public List<Map<String, Object>> loadAllUpdated(String codeTypeFichier, String codeParticipant) {
//        stopIfNotConsumer(codeTypeFichier, codeParticipant);
//
//        try ( Connection connection = new DBConnection(dataSource).connection()) {
//
//            connection.setAutoCommit(false);
//
//            SelectQueryResult result = selectResult(connection, codeTypeFichier, updatedCriterion(codeTypeFichier, codeParticipant));
//
//            if (!result.rows().isEmpty()) {
//                performAudit(connection, codeParticipant, codeTypeFichier, result.lastIndexRead());
//            }
//            connection.commit();
//            return selectedData(result.rows());
//        } catch (Exception ex) {
//            Logger.getLogger(DataConsumptionOperationsImpl.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
//            throw new CommonApplicationServerException();
//        }
//    }
    @Override
    public List<Map<String, Object>> loadAllAddedAndUpdated(String codeTypeFichier, String codeParticipant) {
        stopIfNotConsumer(codeTypeFichier, codeParticipant);
 
        try ( Connection connection = new DBConnection(dataSource).connection()) {
 
            connection.setAutoCommit(false);
 
            SelectQueryResult result = selectResult(connection, codeTypeFichier, loadedAndUpdatedCriterion(codeTypeFichier, codeParticipant));
 
            if (!result.rows().isEmpty()) {
                performAudit(connection, codeParticipant, codeTypeFichier, result.lastIndexRead());
            }
            connection.commit();
            return selectedData(result.rows());
        } catch (Exception ex) {
            Logger.getLogger(DataConsumptionOperationsImpl.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
            throw new CommonApplicationServerException();
        }
    }
 
    @Override
    public PageData loadAllWithPagination(String codeTypeFichier, String codeParticipant, int pageNumber, int pageSize) {
        stopIfNotConsumer(codeTypeFichier, codeParticipant);
 
        try ( Connection connection = new DBConnection(dataSource).connection()) {
            return getPageData(connection, codeTypeFichier, null, pageNumber, pageSize);
 
        } catch (Exception ex) {
            Logger.getLogger(DataConsumptionOperationsImpl.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
            throw new CommonApplicationServerException();
        }
 
    }
 
    @Override
    public PageData findByCriteriaWithPagination(String codeTypeFichier, CriteriaEntityFromView criterion, String codeParticipant, int pageNumber, int pageSize) {
        stopIfNotConsumer(codeTypeFichier, codeParticipant);
 
        try ( Connection connection = new DBConnection(dataSource).connection()) {
            return getPageData(connection, codeTypeFichier, new CriteriaEntityFromViewToQueryCriterion(criterion).queryCriterion(), pageNumber, pageSize);
 
        } catch (Exception ex) {
            Logger.getLogger(DataConsumptionOperationsImpl.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
            throw new CommonApplicationServerException();
        }
    }
 
    @Override
    public long countAll(String codeTypeFichier, String codeParticipant) {
        stopIfNotConsumer(codeTypeFichier, codeParticipant);
 
        try ( Connection connection = new DBConnection(dataSource).connection()) {
            return count(connection, codeTypeFichier, null);
 
        } catch (Exception ex) {
            Logger.getLogger(DataConsumptionOperationsImpl.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
            throw new CommonApplicationServerException();
        }
    }
 
    @Override
    public long countAllLoadedOrUpdated(String codeTypeFichier, String codeParticipant) {
        stopIfNotConsumer(codeTypeFichier, codeParticipant);
 
        try ( Connection connection = new DBConnection(dataSource).connection()) {
            return count(connection, codeTypeFichier, loadedAndUpdatedCriterion(codeTypeFichier, codeParticipant));
        } catch (Exception ex) {
            Logger.getLogger(DataConsumptionOperationsImpl.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
            throw new CommonApplicationServerException();
        }
    }
 
    private void performAudit(Connection connection, String participantDemandeur, String typeFichierConsulte, int lastReadIndex) throws Exception {
        AuditActionsParticipant auditAction = lastAudit(participantDemandeur, typeFichierConsulte);
        LocalDateTime dateAction = LocalDateTime.now();
 
        if (auditAction == null) {
            auditAction = new AuditActionsParticipant();
            auditAction.setParticipantDemandeur(participantDemandeur);
            auditAction.setTypeFichierConsulte(typeFichierConsulte);
            auditAction.setLastIndexRead(lastReadIndex);
            auditAction.setDateAction(dateAction);
 
            new AuditActionsParticicipantsQuery(connection, auditAction).insert();
 
        } else {
            auditAction.setDateAction(dateAction);
 
            if (lastReadIndex > auditAction.getLastIndexRead()) {
                auditAction.setLastIndexRead(lastReadIndex);
            }
 
            new AuditActionsParticicipantsQuery(connection, auditAction).update();
        }
    }
 
    private AuditActionsParticipant lastAudit(String codeParticipant, String codeTypeFichier) {
        return auditActionsParticipantRepository.lastAudit(codeParticipant, codeTypeFichier);
    }
 
    private long count(Connection connection, String codeTypeFichier, QueryCriterion criterion) {
        try {
 
            return table(connection, codeTypeFichier).count(criterion);
        } catch (Exception ex) {
            throw new ApplicationServerException(ex.getMessage());
        }
    }
 
    private SelectQueryResult selectResult(Connection connection, String codeTypeFichier, QueryCriterion queryCriterion) {
        try {
            return table(connection, codeTypeFichier).selectResult(queryCriterion);
        } catch (Exception ex) {
            throw new ApplicationServerException(ex.getMessage());
        }
    }
 
    private SelectQueryResult selectResult(Connection connection, String codeTypeFichier, QueryCriterion queryCriterion, int pageNumber, int pageSize) {
        try {
            int offset = (pageNumber - 1) * pageSize;
            return table(connection, codeTypeFichier).selectResult(queryCriterion, pageSize, offset);
        } catch (Exception ex) {
            throw new ApplicationServerException(ex.getMessage());
        }
    }
 
    private List<Map<String, Object>> selectedData(List<FdxTableRow> rows) {
        return rows
                .stream()
                .map(r -> {
                    Map<String, Object> result = new HashMap<>();
                    r.getDataColumns().forEach(column -> result.put(column.getName(), column.getValue()));
                    return result;
                })
                .collect(Collectors.toList());
    }
 
    private FdxApiTable table(Connection connection, String codeTypeFichier) {
        return new FdxApiTable(codeTypeFichier, versionReferentiel(), connection);
    }
 
    private String versionReferentiel() {
        return dataInMemoryHandler.getDataInMemory().getReferentielEnCours().getVersion();
    }
 
    private void stopIfNotConsumer(String codeTypeFichier, String connectedParticipant) {
        if (dataInMemoryHandler.getDataInMemory().getReferentielEnCours() == null) {
            throw new CommonRessourceNotFoundException("Aucun référentiel en cours");
        }
        routingChecker.stopIfTypeFichierNotExists(codeTypeFichier, dataInMemoryHandler.getDataInMemory());
        routingChecker.stopIfNotConsumer(codeTypeFichier, dataInMemoryHandler.getDataInMemory(), connectedParticipant);
    }
 
    private PageData getPageData(Connection connection, String codeTypeFichier, QueryCriterion queryCriterion, int pageNumber, int pageSize) {
 
        try {
 
            SelectQueryResult result = selectResult(connection, codeTypeFichier, queryCriterion, pageNumber, pageSize);
 
            List<Map<String, Object>> loadedData = selectedData(result.rows());
            long totalNumberOfElements = table(connection, codeTypeFichier).count(queryCriterion);
 
            PageData pageData = new PageData();
            pageData.setLoadedData(loadedData);
            pageData.setPageNumber(pageNumber);
            pageData.setPageSize(pageSize);
            pageData.setTotalNumberOfElements(totalNumberOfElements);
 
            return pageData;
 
        } catch (Exception ex) {
            throw new ApplicationServerException(ex.getMessage());
        }
    }
 
    private QueryCriterion updatedCriterion(String codeTypeFichier, String codeParticipant) {
        AuditActionsParticipant lastAudit = lastAudit(codeParticipant, codeTypeFichier);
        if (lastAudit != null) {
 
            String dateActionColonne = new DateActionColumnDefinition().name();
 
            return new QueryCriterion(
                    dateActionColonne,
                    lastAudit.getDateAction(),
                    Operateur.GREATER_THAN,
                    null,
                    Arrays.asList()
            );
        } else {
            return null;
        }
    }
 
    private QueryCriterion loadedAndUpdatedCriterion(String codeTypeFichier, String codeParticipant) {
        AuditActionsParticipant lastAudit = lastAudit(codeParticipant, codeTypeFichier);
        if (lastAudit != null) {
 
            String indexColonne = new IndexColumnDefinition().name();
            String dateActionColonne = new DateActionColumnDefinition().name();
 
            return new QueryCriterion(
                    null,
                    null,
                    null,
                    CriteriaLogicConnector.OR,
                    Arrays.asList(
                            new QueryCriterion(
                                    indexColonne,
                                    lastAudit.getLastIndexRead(),
                                    Operateur.GREATER_THAN,
                                    null,
                                    Arrays.asList()
                            ),
                            new QueryCriterion(
                                    dateActionColonne,
                                    lastAudit.getDateAction(),
                                    Operateur.GREATER_THAN,
                                    null,
                                    Arrays.asList()
                            )
                    )
            );
        } else {
            return null;
        }
    }
 
}