ModeleVerreIteHelper.java

package com.sintia.ffl.admin.optique.specifique.isea.helpers;

import com.sintia.ffl.admin.optique.dal.entities.Classe;
import com.sintia.ffl.admin.optique.dal.entities.DistributeurIte;
import com.sintia.ffl.admin.optique.dal.entities.FabricantIte;
import com.sintia.ffl.admin.optique.dal.entities.ModeleVerreIte;
import com.sintia.ffl.admin.optique.dal.entities.TraitementIntegreIte;
import com.sintia.ffl.admin.optique.dal.entities.TypeMateriauIte;
import com.sintia.ffl.admin.optique.dal.entities.TypeVerreIte;
import com.sintia.ffl.admin.optique.dal.entities.VerreTraitIntegresAssoIte;
import com.sintia.ffl.admin.optique.dal.entities.catalogue.*;
import com.sintia.ffl.admin.optique.dal.repositories.ClasseRepository;
import com.sintia.ffl.admin.optique.dal.repositories.catalogue.*;
import com.sintia.ffl.admin.optique.dal.repositories.FabricantIteRepository;
import com.sintia.ffl.admin.optique.dal.repositories.TraitementIntegreIteRepository;
import com.sintia.ffl.admin.optique.dal.repositories.TypeMateriauIteRepository;
import com.sintia.ffl.admin.optique.dal.repositories.TypeSupplementIteRepository;
import com.sintia.ffl.admin.optique.dal.repositories.TypeVerreIteRepository;
import com.sintia.ffl.admin.optique.dal.repositories.VerreTraitIntegresAssoIteRepository;
import com.sintia.ffl.admin.optique.services.services.ModeleVerreIteService;
import com.sintia.ffl.admin.optique.specifique.isea.models.VerreCSV;
import com.sintia.ffl.admin.optique.specifique.isea.models.VerreSupplementAssoCSV;
import com.sintia.ffl.admin.optique.specifique.isea.reporter.ChargementReporter;
import com.sintia.ffl.admin.optique.specifique.isea.utils.Constants;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.ZoneId;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

@Service
@Slf4j
public class ModeleVerreIteHelper {
	
	private static final Logger LOGGER = LoggerFactory.getLogger(ModeleVerreIteHelper.class);
	
	@Autowired
	private ChargementReporter chargementReporter;
	
	@Autowired
	private ModeleVerreIteService modeleVerreCatalogueIteService;
	
	@Autowired
	private ClasseRepository classeRepository;
	
	@Autowired
	private DistributeurCatalogueIteRepository distributeurCatalogueIteRepository;
	
	@Autowired
	private FabricantCatalogueIteRepository fabricantCatalogueIteRepository;
	
	@Autowired
	private TypeMateriauCatalogueIteRepository typeMateriauCatalogueIteRepository;
	
	@Autowired
	private TypeVerreCatalogueIteRepository typeVerreCatalogueIteRepository;
	
	@Autowired
	private VerreTraitIntegresAssoCatalogueIteRepository verreTraitIntegresAssoCatalogueIteRepository;
	
	@Autowired
	private TraitementIntegreCatalogueIteRepository traitementIntegreCatalogueIteRepository;
	
	@Autowired
	private TypeSupplementCatalogueIteRepository typeSupplementCatalogueIteRepository;
	
	
	public void process(List<VerreCSV> verreCSVList, List<VerreSupplementAssoCSV> verreSupplementAssoCSVList,
			String codeFabricant, String codeFournisseur, Date date) {
		
		for(VerreCSV verreCSV : verreCSVList){
			if(verreCSV.getClasseVerre() != null) {
				Classe classe = classeRepository.findByCode(verreCSV.getClasseVerre());
				if (classe != null) {
					try {
						if ("C".equals(verreCSV.getAction()) || "M".equals(verreCSV.getAction())) {
							createOrModifyModeleVerre(verreSupplementAssoCSVList, codeFabricant, codeFournisseur, date,
									verreCSV, classe);
						}
					} catch(Exception e){
						LOGGER.error("Erreur Rencontrée dans le traitement du verre {} cause {}", verreCSV.getCodeVerre(), e.getMessage());
						chargementReporter.addError("Erreur Rencontrée dans le traitement du verre "+verreCSV.getCodeVerre() +" cause "+e.getMessage());
					}
				} else {
					chargementReporter.addError(Constants.TRAITEMENT_ARRETE_CAUSE_CLASSE_INCORRECTE);
					throw new RuntimeException(Constants.TRAITEMENT_ARRETE_CAUSE_CLASSE_INCORRECTE);
				}
			}else {
				chargementReporter.addError(Constants.TRAITEMENT_ARRETE_CAUSE_CLASSE_VERRE_ABSENTE);
				throw new RuntimeException(Constants.TRAITEMENT_ARRETE_CAUSE_CLASSE_VERRE_ABSENTE);
			}
		}
	}
	
	/**
	 * Creation ou modification Enregistrement ModeleVerre
	 * @param verreSupplementAssoCSVList
	 * @param codeFabricant
	 * @param codeFournisseur
	 * @param date
	 * @param verreCSV
	 * @param classe
	 */
	private void createOrModifyModeleVerre(List<VerreSupplementAssoCSV> verreSupplementAssoCSVList, String codeFabricant,
			String codeFournisseur, Date date, VerreCSV verreCSV, Classe classe) {
		ModeleVerreCatalogueIte modeleVerreCatalogueIte = modeleVerreCatalogueIteService.exist(verreCSV.getCodeVerre(), codeFabricant,
				codeFournisseur);
		if (modeleVerreCatalogueIte != null) {
			try {
				modifyModeleVerreIte(date, verreCSV, classe, modeleVerreCatalogueIte);
				chargementReporter.addVerre(verreCSV);
			} catch (Exception e){
				chargementReporter.addError("Erreur Rencontrée dans le traitement du verre "+verreCSV.getCodeVerre() +" cause "+e.getMessage());
			}
		} else {
			try {
				List<VerreSupplementAssoCSV> listCurrentVerreSupplAsso = verreSupplementAssoCSVList.stream()
						.filter(verreSupplementAssoCSV -> verreCSV.getCodeVerre().equals(verreSupplementAssoCSV.getCodeVerre())).collect(Collectors.toList());
				if (listCurrentVerreSupplAsso.stream()
						.anyMatch(verreSupplementAssoCSV -> "Y".equals(verreSupplementAssoCSV.getSupplementInclus()))) {
					List<VerreSupplementAssoCSV> verreSupplementAssoCSVToLoad = listCurrentVerreSupplAsso.stream().filter(verreSupplementAssoCSV -> "Y".equals(verreSupplementAssoCSV.getSupplementInclus()))
							.collect(Collectors.toList());
					createModeleVerreIte(date, verreCSV, classe, verreSupplementAssoCSVToLoad);
				} else
					createModeleVerreIte(date, verreCSV, classe, null);
				
				chargementReporter.addVerre(verreCSV);
			} catch (Exception e){
				chargementReporter.addError("Erreur Rencontrée dans le traitement du verre "+verreCSV.getCodeVerre() +" cause "+e.getMessage());
			}
		}
	}
	
	/**
	 * Modification Enregistrement ModeleVerre
	 * @param date
	 * @param verreCSV
	 * @param classe
	 * @param modeleVerreCatalogueIte
	 */
	private void modifyModeleVerreIte(Date date, VerreCSV verreCSV, Classe classe, ModeleVerreCatalogueIte modeleVerreCatalogueIte) {
		Optional<TypeMateriauCatalogueIte> typeMateriauCatalogueIte = typeMateriauCatalogueIteRepository.findBycOptoTypeMateriau(Integer.valueOf(verreCSV.getMatiere()));
		Optional<TypeVerreCatalogueIte> typeVerreCatalogueIte = typeVerreCatalogueIteRepository.findBycOptoTypeVerre(Integer.valueOf(verreCSV.getGeometrie()));
		// Modification
		ModeleVerreCatalogueIte modeleVerreIteToUpdate = ModeleVerreCatalogueIte.builder().idModeleVerreIte(
						modeleVerreCatalogueIte.getIdModeleVerreIte()).idClasse(classe.getIdClasse())
				.idFabricantIte(modeleVerreCatalogueIte.getIdFabricantIte())
				.idDistributeurIte(modeleVerreCatalogueIte.getIdDistributeurIte())
				.idTypeMateriauIte(typeMateriauCatalogueIte.map(TypeMateriauCatalogueIte::getIdTypeMateriauIte).orElse(null))
				.idTypeVerreIte(typeVerreCatalogueIte.map(TypeVerreCatalogueIte::getIdTypeVerreIte).orElse(null))
				.cModele(modeleVerreCatalogueIte.getCModele())
				.lModele(verreCSV.getNomVerre())
				.nIndice(Short.parseShort(verreCSV.getRefraction()))
				.bSaisie("1")
				.dateCreation(modeleVerreCatalogueIte.getDateCreation()).dateMaj(date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime())
				.codeOptoCodeVerre(modeleVerreCatalogueIte.getCodeOptoCodeVerre()).dateDemandeSupp(null)
				.build();
		modeleVerreCatalogueIteService.modifyOrCreate(modeleVerreIteToUpdate);
	}
	
	/**
	 * Creation Enregistrement ModeleVerre Et creation Enregistrement VerreTraitementIntegreAsso En fonction des conditions
	 *  Y = indicateur photochromique
	 *  1 = indicateur type de Surface
	 *  Y = supplement inclus
	 *  Y = verre Teinte
	 * @param date
	 * @param verreCSV
	 * @param classe
	 * @param currentVerreSupplAsso
	 */
	private void createModeleVerreIte(Date date, VerreCSV verreCSV, Classe classe, List<VerreSupplementAssoCSV> currentVerreSupplAsso) {
		Optional<DistributeurCatalogueIte> distributeurCatalogueIte = distributeurCatalogueIteRepository.findBycOptoCodeDistributeur(verreCSV.getCodeFournisseur());
		Optional<FabricantCatalogueIte> fabricantCatalogueIte = fabricantCatalogueIteRepository.findBycOptoCodeFabricant(verreCSV.getCodeFabricant());
		Optional<TypeMateriauCatalogueIte> typeMateriauCatalogueIte = typeMateriauCatalogueIteRepository.findBycOptoTypeMateriau(Integer.valueOf(verreCSV.getMatiere()));
		Optional<TypeVerreCatalogueIte> typeVerreCatalogueIte = typeVerreCatalogueIteRepository.findBycOptoTypeVerre(Integer.valueOf(verreCSV.getGeometrie()));
		
		//creation Association Verre Traitement integre Asso
		if ("Y".equals(verreCSV.getPhotochromique())) {
			VerreTraitIntegresAssoCatalogueIte verreTraitIntegresAssoCatalogueIte = initVerreTraitIntegreAssoIte(date, verreCSV);
			verreTraitIntegresAssoCatalogueIte.setIdTraitementIntegreIte(
					traitementIntegreCatalogueIteRepository.findByCodeTraitIntegre("PR")
							.map(TraitementIntegreCatalogueIte::getIdTraitIntegreIte)
							.orElse(null)
			);
			verreTraitIntegresAssoCatalogueIteRepository.save(verreTraitIntegresAssoCatalogueIte);
			
		} else if ("1".equals(verreCSV.getTypeSurface())) {
			VerreTraitIntegresAssoCatalogueIte verreTraitIntegresAssoCatalogueIte = initVerreTraitIntegreAssoIte(date, verreCSV);
			verreTraitIntegresAssoCatalogueIte.setIdTraitementIntegreIte(
					traitementIntegreCatalogueIteRepository.findByCodeTraitIntegre("AS")
							.map(TraitementIntegreCatalogueIte::getIdTraitIntegreIte)
							.orElse(null)
			);
			verreTraitIntegresAssoCatalogueIteRepository.save(verreTraitIntegresAssoCatalogueIte);
			
		} else if(currentVerreSupplAsso != null && !currentVerreSupplAsso.isEmpty()) {
			
			for(VerreSupplementAssoCSV verreSupplementAssoCSV : currentVerreSupplAsso){
				if("M".equals(verreSupplementAssoCSV.getAction()) ||"C".equals(verreSupplementAssoCSV.getAction()) ) {
					TraitementIntegreCatalogueIte traitementIntegreCatalogueIte = traitementIntegreCatalogueIteRepository.findByCodeTraitIntegre(
									typeSupplementCatalogueIteRepository.findBycTypeSupplement(verreSupplementAssoCSV.getTypeSupplement()).get().getCTypeDeTrtSupplementaires())
							.get();
					
					Optional<VerreTraitIntegresAssoCatalogueIte> alreadyExistantVerreTraitIntegresAssoCatalogueIte = verreTraitIntegresAssoCatalogueIteRepository.findBycModeleAndTraitementIntegreIte_codeTraitIntegre(
							verreCSV.getCodeFabricant() + verreCSV.getCodeFournisseur() + verreCSV.getCodeVerre(),
							traitementIntegreCatalogueIte.getCodeTraitIntegre());
					
					if (alreadyExistantVerreTraitIntegresAssoCatalogueIte.isEmpty()) {
						VerreTraitIntegresAssoCatalogueIte verreTraitIntegresAssoCatalogueIte = initVerreTraitIntegreAssoIte(date,
								verreCSV);
						verreTraitIntegresAssoCatalogueIte.setIdTraitementIntegreIte(traitementIntegreCatalogueIte.getIdTraitIntegreIte());
						verreTraitIntegresAssoCatalogueIteRepository.save(verreTraitIntegresAssoCatalogueIte);
					}
				}
			}
			
		} else if("Y".equals(verreCSV.getTeinte())) {
			TraitementIntegreCatalogueIte traitementIntegreCatalogueIte = traitementIntegreCatalogueIteRepository.findByCodeTraitIntegre("CO").get();
			Optional<VerreTraitIntegresAssoCatalogueIte> alreadyExistantVerreTraitIntegresAssoCatalogueIte = verreTraitIntegresAssoCatalogueIteRepository.findBycModeleAndTraitementIntegreIte_codeTraitIntegre(
					verreCSV.getCodeFabricant() + verreCSV.getCodeFournisseur() + verreCSV.getCodeVerre(),
					traitementIntegreCatalogueIte.getCodeTraitIntegre());
			if (alreadyExistantVerreTraitIntegresAssoCatalogueIte.isEmpty()) {
				VerreTraitIntegresAssoCatalogueIte verreTraitIntegresAssoCatalogueIte = initVerreTraitIntegreAssoIte(date, verreCSV);
				verreTraitIntegresAssoCatalogueIte.setIdTraitementIntegreIte(traitementIntegreCatalogueIte.getIdTraitIntegreIte());
				verreTraitIntegresAssoCatalogueIteRepository.save(verreTraitIntegresAssoCatalogueIte);
			}
		}
		ModeleVerreCatalogueIte modeleVerreIteToCreate = ModeleVerreCatalogueIte.builder()
				.idClasse(classe.getIdClasse())
				.idDistributeurIte(distributeurCatalogueIte.map(DistributeurCatalogueIte::getIdDistributeurIte).orElse(null))
				.idFabricantIte(fabricantCatalogueIte.map(FabricantCatalogueIte::getIdFabricantIte).orElse(null))
				.idTypeMateriauIte(typeMateriauCatalogueIte.map(TypeMateriauCatalogueIte::getIdTypeMateriauIte).orElse(null))
				.idTypeVerreIte(typeVerreCatalogueIte.map(TypeVerreCatalogueIte::getIdTypeVerreIte).orElse(null))
				.cModele(verreCSV.getCodeFabricant() + verreCSV.getCodeFournisseur() + verreCSV.getCodeVerre())
				.lModele(verreCSV.getNomVerre())
				.nIndice(Short.parseShort(verreCSV.getRefraction()))
				.bSaisie("1")
				.dateCreation(date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime()).dateMaj(date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime())
				.codeOptoCodeVerre(verreCSV.getCodeVerre()).dateDemandeSupp(null)
				.build();
		modeleVerreCatalogueIteService.modifyOrCreate(modeleVerreIteToCreate);
	}
	
	/**
	 * Construction objet VerreTraitIntegreAsso
	 * @param date
	 * @param verreCSV
	 * @return
	 */
	private VerreTraitIntegresAssoCatalogueIte initVerreTraitIntegreAssoIte(Date date, VerreCSV verreCSV) {
		VerreTraitIntegresAssoCatalogueIte verreTraitIntegresAssoCatalogueIte = new VerreTraitIntegresAssoCatalogueIte();
		verreTraitIntegresAssoCatalogueIte.setCModele(verreCSV.getCodeFabricant()+ verreCSV.getCodeFournisseur()+ verreCSV.getCodeVerre());
		verreTraitIntegresAssoCatalogueIte.setDateCreation(date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime());
		verreTraitIntegresAssoCatalogueIte.setDateMaj(date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime());
		return verreTraitIntegresAssoCatalogueIte;
	}
	
}