package com.megatim.fdxconsultation.core.impl.helper;
|
|
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.referentiel.Referentiel;
|
import com.megatim.fdxcommons.tools.exceptions.CommonApplicationValidationException;
|
import com.megatim.fdxconsultation.core.ifaces.integration.ColumnDefinitionManager;
|
import com.megatim.fdxconsultation.core.ifaces.helper.TableauBordHandler;
|
import com.megatim.fdxconsultation.core.ifaces.stats.CriteriaEntityPersistedManager;
|
import com.megatim.fdxconsultation.core.ifaces.stats.TableConfigurationManager;
|
import com.megatim.fdxconsultation.core.ifaces.stats.TableauBordColumnManager;
|
import com.megatim.fdxconsultation.core.ifaces.stats.TableauBordManager;
|
import com.megatim.fdxconsultation.model.dto.stats.TableConfigurationDto;
|
import com.megatim.fdxconsultation.model.dto.stats.TableauBordDto;
|
import com.megatim.fdxconsultation.model.enums.TypeConfigurationTableauBord;
|
import com.megatim.fdxconsultation.model.mappers.MapStructMapper;
|
import com.megatim.fdxconsultation.model.stats.CriteriaEntityPersisted;
|
import com.megatim.fdxconsultation.model.stats.TableConfiguration;
|
import com.megatim.fdxconsultation.model.stats.TableauBord;
|
import com.megatim.fdxconsultation.model.stats.TableauBordColumn;
|
import com.megatim.fdxconsultation.model.enums.TypeResultatConfiguration;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Set;
|
import java.util.logging.Level;
|
import java.util.logging.Logger;
|
import javax.enterprise.context.Dependent;
|
import javax.inject.Inject;
|
|
/**
|
*
|
* @author ASUS
|
*/
|
@Dependent
|
public class TableauBordHandlerImpl implements TableauBordHandler {
|
|
@Inject
|
private MapStructMapper mapper;
|
|
@Inject
|
com.megatim.fdxcommons.model.mappers.MapStructMapper commonMapper;
|
|
@Inject
|
private ColumnDefinitionManager columnDefinitionManager;
|
|
@Inject
|
private CriteriaEntityPersistedManager criteriaEntityPersistedManager;
|
|
@Inject
|
TableauBordManager tableauBordManager;
|
|
@Inject
|
private TableConfigurationManager tableConfigurationManager;
|
|
@Inject
|
private TableauBordColumnManager tableauBordColumnManager;
|
|
@Override
|
public void reconduireTableauBordValides(Referentiel previousRef, Referentiel newRef, Set<String> typeFichiersToMigrate) {
|
List<TableauBord> prevRefTableauBords = tableauBordManager.findByReferentiel(previousRef.getVersion());
|
|
try {
|
for (TableauBord t : prevRefTableauBords) {
|
if (typeFichiersToMigrate.contains(t.getTypeFichier().getCode())) {
|
createNewTableauBord(t, newRef);
|
}
|
}
|
} catch (Exception ex) {
|
ex.printStackTrace();
|
}
|
}
|
|
@Override
|
public TableauBordDto tableauBordToTableauBordDto(TableauBord tableauBord) {
|
TableauBordDto dto = new TableauBordDto();
|
|
dto.setId(tableauBord.getId());
|
dto.setDescription(tableauBord.getDescription());
|
dto.setTypeFichier(commonMapper.typeFichierToTypeFichierSlimDto(tableauBord.getTypeFichier()));
|
dto.setTypeConfiguration(tableauBord.getTypeConfiguration());
|
|
Set<TableConfigurationDto> tableConfigurationDtos = new HashSet<>();
|
tableauBord.getTableConfigurations().stream().forEach(t -> tableConfigurationDtos.add(tableConfigurationToTableConfigurationDto(t)));
|
dto.setTableConfigurations(tableConfigurationDtos);
|
|
return dto;
|
}
|
|
/**
|
* Méthode permettant de passer de TableauBordDto à TableauBord
|
*
|
* @param dto
|
* @param referentiel
|
* @return
|
*/
|
@Override
|
public TableauBord tableauBordDtoToTableauBord(TableauBordDto dto, Referentiel referentiel) {
|
TableauBord tableauBord = new TableauBord();
|
|
tableauBord.setDescription(dto.getDescription());
|
tableauBord.setTypeFichier(commonMapper.typeFichierSlimDtoToTypeFichier(dto.getTypeFichier()));
|
tableauBord.setReferentiel(referentiel);
|
|
Set<TableConfiguration> tableConfigurations = new HashSet<>();
|
dto.getTableConfigurations().stream().forEach(t -> tableConfigurations.add(tableConfigurationDtoToTableConfiguration(t, dto.getTypeFichier().getCode(), referentiel.getVersion())));
|
tableauBord.setTableConfigurations(tableConfigurations);
|
|
return tableauBord;
|
}
|
|
@Override
|
public TableConfigurationDto tableConfigurationToTableConfigurationDto(TableConfiguration tableConf) {
|
TableConfigurationDto dto = new TableConfigurationDto();
|
dto.setCriterion(criteriaEntityPersistedToCriteriaEntityFromView(tableConf.getCriterion()));
|
dto.setColor(tableConf.getColor());
|
dto.setFonctionAggregation(tableConf.getFonctionAggregation());
|
dto.setGroupingColumns(mapper.setTableauBordColumnToSetTableauBordColumnDto(tableConf.getGroupingColumns()));
|
dto.setLibelle(tableConf.getLibelle());
|
dto.setTargetedColumn(mapper.tableauBordColumnToTableauBordColumnDto(tableConf.getTargetedColumn()));
|
dto.setTypeResultatConfiguration(tableConf.getTypeResultatConfiguration());
|
dto.setColor(tableConf.getColor());
|
|
return dto;
|
}
|
|
@Override
|
public void stopIfUserSpecificTableauBordExists(String codeTypeFichier, String referentielVersion, String userName) throws CommonApplicationValidationException, Exception {
|
|
CriteriaEntityFromView criterion = new CriteriaEntityFromView();
|
criterion.setCriteriaLogicConnector(CriteriaLogicConnector.AND);
|
criterion.setSubCriterias(Arrays.asList(
|
new CriteriaEntityFromView("typeFichier.code", codeTypeFichier, Operateur.EQUALS),
|
new CriteriaEntityFromView("user.userName", userName, Operateur.EQUALS),
|
new CriteriaEntityFromView("referentiel.version", referentielVersion, Operateur.EQUALS),
|
new CriteriaEntityFromView("typeConfiguration", TypeConfigurationTableauBord.USER_SPECIFIC, Operateur.EQUALS)));
|
|
List<TableauBord> tb = tableauBordManager.findAll(criterion, Arrays.asList(), Arrays.asList());
|
if (tb.stream().findFirst().isPresent()) {
|
throw new CommonApplicationValidationException("Une configuration existe déjà pour le typefichier " + codeTypeFichier + ", l'utilisateur" + userName + " et le référentiel " + referentielVersion);
|
}
|
}
|
|
@Override
|
public void stopIfGlobaleTableauBordExists(String codeTypeFichier, String referentielVersion) throws Exception {
|
|
CriteriaEntityFromView criterion = new CriteriaEntityFromView();
|
criterion.setCriteriaLogicConnector(CriteriaLogicConnector.AND);
|
criterion.setSubCriterias(Arrays.asList(
|
new CriteriaEntityFromView("typeFichier.code", codeTypeFichier, Operateur.EQUALS),
|
new CriteriaEntityFromView("referentiel.version", referentielVersion, Operateur.EQUALS),
|
new CriteriaEntityFromView("typeConfiguration", TypeConfigurationTableauBord.GLOBAL, Operateur.EQUALS)
|
));
|
|
if (tableauBordManager.findAll(criterion, Arrays.asList(), Arrays.asList()).stream().findFirst().isPresent()) {
|
throw new CommonApplicationValidationException("Une configuration existe déjà pour ce typefichier et ce référentiel");
|
}
|
}
|
|
private void createNewTableauBord(TableauBord t, Referentiel referentiel) throws Exception {
|
|
try {
|
if (t.getTypeConfiguration().equals(TypeConfigurationTableauBord.USER_SPECIFIC)) {
|
stopIfUserSpecificTableauBordExists(t.getTypeFichier().getCode(), referentiel.getVersion(), t.getUser().getUserName());
|
} else {
|
stopIfGlobaleTableauBordExists(t.getTypeFichier().getCode(), referentiel.getVersion());
|
}
|
TableauBord tableauBord = tableauBord(t, referentiel);
|
tableauBordManager.save(tableauBord);
|
} catch (Exception ex) {
|
Logger.getLogger(TableauBordHandlerImpl.class.getSimpleName()).log(Level.SEVERE, ex.getMessage(), ex);
|
}
|
}
|
|
private TableauBord tableauBord(TableauBord t, Referentiel referentiel) {
|
TableauBord tableauBord = new TableauBord();
|
tableauBord.setReferentiel(referentiel);
|
tableauBord.setTypeFichier(t.getTypeFichier());
|
tableauBord.setDescription(t.getDescription());
|
tableauBord.setUser(t.getUser());
|
tableauBord.setTypeConfiguration(t.getTypeConfiguration());
|
|
for (TableConfiguration tc : t.getTableConfigurations()) {
|
TableConfiguration tableConf = new TableConfiguration();
|
tableConf.setLibelle(tc.getLibelle());
|
tableConf.setFonctionAggregation(tc.getFonctionAggregation());
|
tableConf.setTargetedColumn(newTableauBordColumn(tc.getTargetedColumn()));
|
tableConf.setTypeResultatConfiguration(tc.getTypeResultatConfiguration());
|
tableConf.setFonctionAggregationCriterion(tc.getFonctionAggregationCriterion());
|
|
CriteriaEntityPersisted cr = reconductCriteria(tc.getCriterion());
|
tableConf.setCriterion(cr);
|
|
for (TableauBordColumn tbc : tc.getGroupingColumns()) {
|
tableConf.getGroupingColumns().add(newTableauBordColumn(tbc));
|
}
|
tableauBord.getTableConfigurations().add(tableConf);
|
}
|
|
return tableauBord;
|
}
|
|
private TableauBordColumn newTableauBordColumn(TableauBordColumn column) {
|
if (column == null) {
|
return null;
|
}
|
TableauBordColumn newColumn = new TableauBordColumn();
|
newColumn.setName(column.getName());
|
newColumn.setTypeDonnee(column.getTypeDonnee());
|
|
return newColumn;
|
}
|
|
private TableConfiguration tableConfigurationDtoToTableConfiguration(TableConfigurationDto dto, String codeTypeFichier, String referentielVersion) {
|
TableConfiguration tableConf = new TableConfiguration();
|
tableConf.setFonctionAggregation(dto.getFonctionAggregation());
|
tableConf.setLibelle(dto.getLibelle());
|
tableConf.setColor(dto.getColor());
|
tableConf.setTargetedColumn(mapper.tableauBordColumnDtoToTableauBordColumn(dto.getTargetedColumn()));
|
tableConf.setGroupingColumns(mapper.setTableauBordColumnDtoToSetTableauBordColumn(dto.getGroupingColumns()));
|
tableConf.setTypeResultatConfiguration(dto.getTypeResultatConfiguration() != null ? dto.getTypeResultatConfiguration() : TypeResultatConfiguration.RECAPITULATIF);
|
|
CriteriaEntityPersisted criterionPersisted = criteriaEntityPersistedManager.constructCriteriaPersisted(codeTypeFichier, referentielVersion, dto.getCriterion());
|
tableConf.setCriterion(criterionPersisted);
|
|
return tableConf;
|
}
|
|
private CriteriaEntityPersisted reconductCriteria(CriteriaEntityPersisted criterion) {
|
|
if (criterion != null) {
|
|
if (!criterion.getSubCriterias().isEmpty()) {
|
|
CriteriaEntityPersisted finalCriterion = new CriteriaEntityPersisted();
|
List<CriteriaEntityPersisted> subCriteria = new ArrayList<>(criterion.getSubCriterias());
|
criterion.setSubCriterias(new ArrayList<>());
|
subCriteria.stream().forEach(c -> finalCriterion.getSubCriterias().add(reconductCriteria(c)));
|
|
return finalCriterion;
|
|
} else {
|
|
CriteriaEntityPersisted finalCriterion = new CriteriaEntityPersisted();
|
finalCriterion.setNomColonne(criterion.getNomColonne());
|
finalCriterion.setOperateur(criterion.getOperateur());
|
finalCriterion.setCriteriaLogicConnector(criterion.getCriteriaLogicConnector());
|
|
finalCriterion.setCriteriaDateListValue(criterion.getCriteriaDateListValue());
|
finalCriterion.setCriteriaDateLowerBound(criterion.getCriteriaDateLowerBound());
|
finalCriterion.setCriteriaDateUpperBound(criterion.getCriteriaDateUpperBound());
|
finalCriterion.setCriteriaDateValue(criterion.getCriteriaDateValue());
|
|
finalCriterion.setCriteriaNumericListValue(criterion.getCriteriaNumericListValue());
|
finalCriterion.setCriteriaNumericValue(criterion.getCriteriaNumericValue());
|
finalCriterion.setCriteriaNumericLowerBound(criterion.getCriteriaNumericLowerBound());
|
finalCriterion.setCriteriaNumericUpperBound(criterion.getCriteriaNumericUpperBound());
|
|
finalCriterion.setCriteriaStringListValue(criterion.getCriteriaStringListValue());
|
finalCriterion.setCriteriaStringValue(criterion.getCriteriaStringValue());
|
finalCriterion.setCriteriaStringLowerBound(criterion.getCriteriaStringLowerBound());
|
finalCriterion.setCriteriaStringUpperBound(criterion.getCriteriaStringUpperBound());
|
|
return finalCriterion;
|
}
|
|
} else {
|
|
return null;
|
|
}
|
}
|
|
}
|
