fiscad/src/main/java/io/gmss/fiscad/service/EntityFromPayLoadService.java

package io.gmss.fiscad.service;

import io.gmss.fiscad.controllers.rfu.metier.ImpositionsTfuController;
import io.gmss.fiscad.entities.decoupage.*;
import io.gmss.fiscad.entities.infocad.metier.*;
import io.gmss.fiscad.entities.infocad.parametre.*;
import io.gmss.fiscad.entities.rfu.metier.*;
import io.gmss.fiscad.entities.rfu.parametre.*;
import io.gmss.fiscad.entities.user.AvoirFonction;
import io.gmss.fiscad.entities.user.Fonction;
import io.gmss.fiscad.entities.user.Profile;
import io.gmss.fiscad.entities.user.User;
import io.gmss.fiscad.enums.StatutEnquete;
import io.gmss.fiscad.exceptions.BadRequestException;
import io.gmss.fiscad.exceptions.NotFoundException;
import io.gmss.fiscad.paylaods.request.crudweb.*;
import io.gmss.fiscad.persistence.repositories.decoupage.*;
import io.gmss.fiscad.persistence.repositories.infocad.metier.*;
import io.gmss.fiscad.persistence.repositories.infocad.parametre.*;
import io.gmss.fiscad.persistence.repositories.rfu.metier.*;
import io.gmss.fiscad.persistence.repositories.rfu.parametre.BaremRfuNonBatiRepository;
import io.gmss.fiscad.persistence.repositories.rfu.parametre.BaremRfuRepository;
import io.gmss.fiscad.persistence.repositories.rfu.parametre.CaracteristiqueRepository;
import io.gmss.fiscad.persistence.repositories.rfu.parametre.ExerciceRepository;
import io.gmss.fiscad.persistence.repositories.user.AvoirFonctionRepository;
import io.gmss.fiscad.persistence.repositories.user.ProfileRepository;
import io.gmss.fiscad.persistence.repositories.user.UserRepository;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.Optional;

@AllArgsConstructor
@Service
public class EntityFromPayLoadService {
    private final EnqueteRepository enqueteRepository;
    private final TypePieceRepository typePieceRepository;
    private final PieceRepository pieceRepository;
    private final CaracteristiqueRepository caracteristiqueRepository;
    private final ModeAcquisitionRepository modeAcquisitionRepository;
    private final PersonneRepository personneRepository;
    private final SourceDroitRepository sourceDroitRepository;
    private final StructureRepository structureRepository;
    private final EnqueteBatimentRepository enqueteBatimentRepository;
    private final EnqueteUniteLogementRepository enqueteUniteLogementRepository;
    private final DeclarationNcRepository declarationNcRepository;
    private final ParcelleRepository parcelleRepository;
    private final BatimentRepository batimentRepository;
    private final UniteLogementRepository uniteLogementRepository;
    private final SituationMatrimonialeRepository situationMatrimonialeRepository;
    private final NationaliteRepository nationaliteRepository;
    private final ProfessionRepository professionRepository;
    private final TypePersonneRepository typePersonneRepository;
    private final CommuneRepository communeRepository;
    private final FonctionRepository fonctionRepository;
    private final SecteurRepository secteurRepository;
    private final UserRepository userRepository;
    private final ProfileRepository profileRepository;
    private final SectionRepository sectionRepository;
    private final ArrondissementRepository arrondissementRepository;
    private final QuartierRepository quartierRepository;
    private final CaracteristiqueBatimentRepository caracteristiqueBatimentRepository;
    private final CaracteristiqueParcelleRepository caracteristiqueParcelleRepository;
    private final CaracteristiqueUniteLogementRepository caracteristiqueUniteLogementRepository;
    private final UploadRepository uploadRepository;
    private final SecteurDecoupageRepository secteurDecoupageRepository;
    private final AvoirFonctionRepository avoirFonctionRepository;
    private final EnqueteActiviteRepository enqueteActiviteRepository;
    private final ExerciceRepository exerciceRepository ;
    private final BaremRfuRepository baremRfuRepository ;
    private final BaremRfuNonBatiRepository baremRfuNonBatiRepository ;
    private final ImpositionsTfuRepository impositionsTfuRepository ;
    private final RueRepository rueRepository ;
    private final NatureDomaineRepository natureDomaineRepository ;
    private final TypeDomaineRepository typeDomaineRepository ;
    private final CommuneCentreAssignationRepository communeCentreAssignationRepository ;


    public CaracteristiqueParcelle getCaracteristiqueParcelleFromPayLoadWeb(CaracteristiqueParcellePayloadWeb caracteristiqueParcellePayloadWeb){
        CaracteristiqueParcelle caracteristiqueParcelle=new CaracteristiqueParcelle();
        if(caracteristiqueParcellePayloadWeb.getId()!=null)
            caracteristiqueParcelle = caracteristiqueParcelleRepository.findById(caracteristiqueParcellePayloadWeb.getId()).orElse(new CaracteristiqueParcelle());

        Optional<Enquete> optionalEnquete=Optional.empty();
        Optional<Caracteristique> optionalCaracteristique=Optional.empty();

        if(caracteristiqueParcellePayloadWeb.getEnqueteId()!=null)
            optionalEnquete=enqueteRepository.findById(caracteristiqueParcellePayloadWeb.getEnqueteId());
        if(caracteristiqueParcellePayloadWeb.getCaracteristiqueId()!=null)
            optionalCaracteristique=caracteristiqueRepository.findById(caracteristiqueParcellePayloadWeb.getCaracteristiqueId());

        caracteristiqueParcelle.setId(caracteristiqueParcellePayloadWeb.getId());
        caracteristiqueParcelle.setEnquete(optionalEnquete.orElse(null));
        caracteristiqueParcelle.setCaracteristique(optionalCaracteristique.orElse(null));
        caracteristiqueParcelle.setValeur(caracteristiqueParcellePayloadWeb.getValeur());
        return caracteristiqueParcelle;
    }


    public CaracteristiqueBatiment getCaracteristiqueBatimentFromPayLoadWeb(CaracteristiqueBatimentPayloadWeb caracteristiqueBatimentPayloadWeb){
        CaracteristiqueBatiment caracteristiqueBatiment=new CaracteristiqueBatiment();
        if(caracteristiqueBatimentPayloadWeb.getId()!=null)
            caracteristiqueBatiment = caracteristiqueBatimentRepository.findById(caracteristiqueBatimentPayloadWeb.getId()).orElse(new CaracteristiqueBatiment());

        Optional<EnqueteBatiment> optionalEnqueteBatiment=Optional.empty();
        Optional<Caracteristique> optionalCaracteristique=Optional.empty();

        if(caracteristiqueBatimentPayloadWeb.getEnqueteBatimentId()!=null)
            optionalEnqueteBatiment=enqueteBatimentRepository.findById(caracteristiqueBatimentPayloadWeb.getEnqueteBatimentId());

        System.out.println("CARACT ID" + caracteristiqueBatimentPayloadWeb.getCaracteristiqueId());
        if(caracteristiqueBatimentPayloadWeb.getCaracteristiqueId()!=null)
            optionalCaracteristique=caracteristiqueRepository.findById(caracteristiqueBatimentPayloadWeb.getCaracteristiqueId());

        caracteristiqueBatiment.setId(caracteristiqueBatimentPayloadWeb.getId());
        caracteristiqueBatiment.setEnqueteBatiment(optionalEnqueteBatiment.orElse(null));
        caracteristiqueBatiment.setCaracteristique(optionalCaracteristique.orElse(null));
        caracteristiqueBatiment.setValeur(caracteristiqueBatimentPayloadWeb.getValeur());
        caracteristiqueBatiment.setObservation(caracteristiqueBatimentPayloadWeb.getObservation());
        return caracteristiqueBatiment;
    }


    public CaracteristiqueUniteLogement getCaracteristiqueUniteLogementFromPayLoadWeb(CaracteristiqueUniteLogementPayloadWeb caracteristiqueUniteLogementPayloadWeb){
        CaracteristiqueUniteLogement caracteristiqueUniteLogement=new CaracteristiqueUniteLogement();
        Optional<EnqueteUniteLogement> optionalEnqueteUniteLogement=Optional.empty();
        Optional<Caracteristique> optionalCaracteristique=Optional.empty();

        if(caracteristiqueUniteLogementPayloadWeb.getId()!=null)
            caracteristiqueUniteLogement = caracteristiqueUniteLogementRepository.findById(caracteristiqueUniteLogementPayloadWeb.getId()).orElse(new CaracteristiqueUniteLogement());


        if(caracteristiqueUniteLogementPayloadWeb.getEnqueteUniteLogementId()!=null)
            optionalEnqueteUniteLogement=enqueteUniteLogementRepository.findById(caracteristiqueUniteLogementPayloadWeb.getEnqueteUniteLogementId());

        if(caracteristiqueUniteLogementPayloadWeb.getCaracteristiqueId()!=null)
            optionalCaracteristique=caracteristiqueRepository.findById(caracteristiqueUniteLogementPayloadWeb.getCaracteristiqueId());

        caracteristiqueUniteLogement.setId(caracteristiqueUniteLogementPayloadWeb.getId());
        caracteristiqueUniteLogement.setEnqueteUniteLogement(optionalEnqueteUniteLogement.orElse(null));
        caracteristiqueUniteLogement.setCaracteristique(optionalCaracteristique.orElse(null));
        caracteristiqueUniteLogement.setValeur(caracteristiqueUniteLogementPayloadWeb.getValeur());
        caracteristiqueUniteLogement.setObservation(caracteristiqueUniteLogementPayloadWeb.getObservation());
        return caracteristiqueUniteLogement;
    }


    public Piece getPieceFromPayLoadWeb(PiecePayLoadWeb piecePayLoadWeb){
        Piece piece=new Piece();
        Optional<Enquete> optionalEnquete=Optional.empty();
        Optional<TypePiece> optionalTypePiece=Optional.empty();
        Optional<SourceDroit> optionalSourceDroit=Optional.empty();
        Optional<ModeAcquisition> optionalModeAcquisition=Optional.empty();
        Optional<Personne> optionalPersonne=Optional.empty();
        Optional<EnqueteBatiment> optionalEnqueteBatiment=Optional.empty();
        Optional<EnqueteUniteLogement> optionalEnqueteUniteLogement=Optional.empty();
        if(piecePayLoadWeb.getId()!=null)
            piece = pieceRepository.findById(piecePayLoadWeb.getId()).orElse(new Piece());


        if(piecePayLoadWeb.getEnqueteId()!=null)
            optionalEnquete=enqueteRepository.findById(piecePayLoadWeb.getEnqueteId());

        if(piecePayLoadWeb.getTypePieceId()!=null)
            optionalTypePiece=typePieceRepository.findById(piecePayLoadWeb.getTypePieceId());

        if(piecePayLoadWeb.getSourceDroitId()!=null)
            optionalSourceDroit=sourceDroitRepository.findById(piecePayLoadWeb.getSourceDroitId());

        if(piecePayLoadWeb.getModeAcquisitionId()!=null)
            optionalModeAcquisition=modeAcquisitionRepository.findById(piecePayLoadWeb.getModeAcquisitionId());

        if(piecePayLoadWeb.getPersonneId()!=null)
            optionalPersonne=personneRepository.findById(piecePayLoadWeb.getPersonneId());

        if(piecePayLoadWeb.getEnqueteBatimentId()!=null)
            optionalEnqueteBatiment=enqueteBatimentRepository.findById(piecePayLoadWeb.getEnqueteBatimentId());

        if(piecePayLoadWeb.getEnqueteUniteLogementId()!=null)
            optionalEnqueteUniteLogement=enqueteUniteLogementRepository.findById(piecePayLoadWeb.getEnqueteUniteLogementId());

        piece.setId(piecePayLoadWeb.getId());
        piece.setEnquete(optionalEnquete.orElse(null));
        piece.setEnqueteBatiment(optionalEnqueteBatiment.orElse(null));
        piece.setEnqueteUniteLogement(optionalEnqueteUniteLogement.orElse(null));
        piece.setTypePiece(optionalTypePiece.orElse(null));
        piece.setSourceDroit(optionalSourceDroit.orElse(null));
        piece.setModeAcquisition(optionalModeAcquisition.orElse(null));
        piece.setPersonne(optionalPersonne.orElse(null));
        piece.setDateExpiration(piecePayLoadWeb.getDateExpiration());
        piece.setDateEtablissement(piecePayLoadWeb.getDateEtablissement());
        piece.setObservation(piecePayLoadWeb.getObservation());
        piece.setNumeroPiece(piecePayLoadWeb.getNumeroPiece());
        return piece ;
    }

    public DeclarationNc getDeclarationNcFromPayLoadWeb(DeclarationNcPayloadWeb declarationNcPayloadWeb){
        DeclarationNc declarationNc=new DeclarationNc();
        Optional<Personne> optionalPersonne=Optional.empty();
        Optional<Structure> optionalStructure=Optional.empty();
        if(declarationNcPayloadWeb.getId()!=null)
            declarationNc = declarationNcRepository.findById(declarationNcPayloadWeb.getId()).orElse(new DeclarationNc());


       if(declarationNcPayloadWeb.getPersonneId()!=null)
            optionalPersonne=personneRepository.findById(declarationNcPayloadWeb.getPersonneId());
        if(declarationNcPayloadWeb.getStructureId()!=null)
            optionalStructure=structureRepository.findById(declarationNcPayloadWeb.getStructureId());
        declarationNc.setId(declarationNcPayloadWeb.getId());
        declarationNc.setStructure(optionalStructure.orElse(null));
        declarationNc.setPersonne(optionalPersonne.orElse(null));
        declarationNc.setNc(declarationNcPayloadWeb.getNc());
        declarationNc.setDateDerniereDeclaration(declarationNcPayloadWeb.getDateDerniereDeclaration());
        declarationNc.setDateDeclarationNc(declarationNcPayloadWeb.getDateDeclarationNc());
        return declarationNc ;
    }

    public Upload getUploadFromPayLoadWeb(UploadPayLoadWeb uploadPayLoadWeb){
        Upload upload=new Upload();
        Optional<Piece> optionalPiece=Optional.empty() ;
        Optional<DeclarationNc> optionalDeclarationNc=Optional.empty();
        Optional<Personne> optionalPersonne=Optional.empty();
        Optional<EnqueteBatiment> optionalEnqueteBatiment=Optional.empty();
        Optional<EnqueteUniteLogement> optionalEnqueteUniteLogement=Optional.empty();
        if(uploadPayLoadWeb.getId()!=null)
            upload = uploadRepository.findById(uploadPayLoadWeb.getId()).orElse(new Upload());

//        if(uploadPayLoadWeb.getEnqueteId()!=null)
//            optionalEnquete=enqueteRepository.findById(uploadPayLoadWeb.getEnqueteId());
        if(uploadPayLoadWeb.getDeclarationNcId()!=null)
            optionalDeclarationNc = declarationNcRepository.findById(uploadPayLoadWeb.getDeclarationNcId());
        if(uploadPayLoadWeb.getPersonneId()!=null)
            optionalPersonne=personneRepository.findById(uploadPayLoadWeb.getPersonneId());
        if(uploadPayLoadWeb.getEnqueteBatimentId()!=null)
            optionalEnqueteBatiment=enqueteBatimentRepository.findById(uploadPayLoadWeb.getEnqueteBatimentId());
        if(uploadPayLoadWeb.getEnqueteUniteLogementId()!=null)
            optionalEnqueteUniteLogement=enqueteUniteLogementRepository.findById(uploadPayLoadWeb.getEnqueteUniteLogementId());

        if(uploadPayLoadWeb.getPieceId()!=null)
            optionalPiece=pieceRepository.findById(uploadPayLoadWeb.getPieceId());


        upload.setId(uploadPayLoadWeb.getId());
        upload.setPiece(optionalPiece.orElse(null));
        //upload.setEnqueteId(uploadPayLoadWeb.getEnqueteId());
        upload.setEnqueteBatiment(optionalEnqueteBatiment.orElse(null));
        upload.setPersonne(optionalPersonne.orElse(null));
        upload.setEnqueteUniteLogement(optionalEnqueteUniteLogement.orElse(null));
        upload.setRename(uploadPayLoadWeb.getRename());
        upload.setDescription(uploadPayLoadWeb.getDescription());
        upload.setReference(uploadPayLoadWeb.getReference());
        upload.setDeclarationNc(optionalDeclarationNc.orElse(null));
        upload.setFileName(uploadPayLoadWeb.getName());
        upload.setName(uploadPayLoadWeb.getName());
        return upload ;
    }

    public Batiment getBatimentFromPayLoadWeb(BatimentPaylaodWeb batimentPaylaodWeb){
        Batiment batiment=new Batiment();
        Optional<Parcelle> optionalParcelle=Optional.empty();
        if(batimentPaylaodWeb.getId()!=null)
            batiment = batimentRepository.findById(batimentPaylaodWeb.getId()).orElse(new Batiment());

        if (batimentPaylaodWeb.getCategorieBatimentId() != null) {
            CategorieBatiment categorieBatiment = new CategorieBatiment();
            categorieBatiment.setId(batimentPaylaodWeb.getCategorieBatimentId());
            batiment.setCategorieBatiment(categorieBatiment);
        }

        if(batimentPaylaodWeb.getParcelleId()!=null)
            optionalParcelle=parcelleRepository.findById(batimentPaylaodWeb.getParcelleId());

        batiment.setId(batimentPaylaodWeb.getId());
        batiment.setParcelle(optionalParcelle.orElse(null));
        batiment.setId(batimentPaylaodWeb.getId());
        batiment.setCode(batimentPaylaodWeb.getCode());
        batiment.setNub(batimentPaylaodWeb.getNub());
        batiment.setSuperficieAuSol(batimentPaylaodWeb.getSuperficieAuSol());
        batiment.setSuperficieLouee(batimentPaylaodWeb.getSuperficieLouee());
        batiment.setDateConstruction(batimentPaylaodWeb.getDateConstruction());

        return batiment ;
    }


    public Section getSectionFromPayLoadWeb(SectionPaylaodWeb sectionPaylaodWeb){
        Section section =new Section();
        Optional<Structure> optionalStructure = Optional.empty();
        if(sectionPaylaodWeb.getId()!=null)
            section = sectionRepository.findById(sectionPaylaodWeb.getId()).orElse(new Section());


        if(sectionPaylaodWeb.getStructureId()!=null)
            optionalStructure=structureRepository.findById(sectionPaylaodWeb.getStructureId());

        section.setId(sectionPaylaodWeb.getId());
        section.setStructure(optionalStructure.orElse(null));
        section.setCode(sectionPaylaodWeb.getCode());
        section.setNom(sectionPaylaodWeb.getNom());
        return section ;
    }

    public Structure getStructureFromPayLoadWeb(StructurePaylaodWeb structurePaylaodWeb){
        Structure structure =new Structure();
        if(structurePaylaodWeb.getId()!=null)
            structure = structureRepository.findById(structurePaylaodWeb.getId()).orElse(new Structure());

        if (structurePaylaodWeb.getCommuneId() == null) {
            throw new BadRequestException("La commune est obligatoire.");
        }
        Commune commune = communeRepository.findById(structurePaylaodWeb.getCommuneId())
                .orElseThrow(() -> new NotFoundException("Commune inexistante"));
        structure.setCommune(commune);

        structure.setCode(structurePaylaodWeb.getCode());
        structure.setNom(structurePaylaodWeb.getNom());
        structure.setAdresse(structurePaylaodWeb.getAdresse());
        structure.setIfu(structurePaylaodWeb.getIfu());
        structure.setEmail(structurePaylaodWeb.getEmail());
        structure.setTel(structurePaylaodWeb.getTel());
        return structure ;
    }

    public Secteur getSecteurFromPayLoadWeb(SecteurPaylaodWeb secteurPaylaodWeb){
        Secteur secteur =new Secteur();
        Optional<Section> optionalSection = Optional.empty();
        if(secteurPaylaodWeb.getId()!=null)
            secteur = secteurRepository.findById(secteurPaylaodWeb.getId()).orElse(new Secteur());


        if(secteurPaylaodWeb.getSectionId()!=null)
            optionalSection=sectionRepository.findById(secteurPaylaodWeb.getSectionId());

        secteur.setId(secteurPaylaodWeb.getId());
        secteur.setSection(optionalSection.orElse(null));
        secteur.setCode(secteurPaylaodWeb.getCode());
        secteur.setNom(secteurPaylaodWeb.getNom());
        return secteur ;
    }


    public SecteurDecoupage getSecteurDecoupageFromPayLoadWeb(SecteurDecoupagePaylaodWeb secteurDecoupagePaylaodWeb){
        SecteurDecoupage secteurDecoupage =new SecteurDecoupage();
        Optional<Secteur> optionalSecteur = Optional.empty();
        Optional<Arrondissement> optionalArrondissement = Optional.empty();
        Optional<Quartier> optionalQuartier = Optional.empty();
        if(secteurDecoupagePaylaodWeb.getId()!=null)
            secteurDecoupage = secteurDecoupageRepository.findById(secteurDecoupagePaylaodWeb.getId()).orElse(new SecteurDecoupage());


        if(secteurDecoupagePaylaodWeb.getSecteurId()!=null)
            optionalSecteur=secteurRepository.findById(secteurDecoupagePaylaodWeb.getSecteurId());
        if(secteurDecoupagePaylaodWeb.getArrondissementCode()!=null)
            optionalArrondissement=arrondissementRepository.findById(secteurDecoupagePaylaodWeb.getArrondissementId());
        if(secteurDecoupagePaylaodWeb.getQuartierId()!=null)
            optionalQuartier=quartierRepository.findById(secteurDecoupagePaylaodWeb.getQuartierId());

        secteurDecoupage.setId(secteurDecoupagePaylaodWeb.getId());
        secteurDecoupage.setSecteur(optionalSecteur.orElse(null));
        secteurDecoupage.setArrondissement(optionalArrondissement.orElse(null));
        secteurDecoupage.setQuartier(optionalQuartier.orElse(null));
        secteurDecoupage.setDateDebut(secteurDecoupagePaylaodWeb.getDateDebut());
        secteurDecoupage.setDateFin(secteurDecoupagePaylaodWeb.getDateFin());

        return secteurDecoupage ;
    }

    public UniteLogement getUniteLogementFromPayLoadWeb(UniteLogementPaylaodWeb uniteLogementPaylaodWeb){
        UniteLogement uniteLogement=new UniteLogement();
        Optional<Batiment> optionalBatiment=Optional.empty();
        if(uniteLogementPaylaodWeb.getId()!=null)
            uniteLogement = uniteLogementRepository.findById(uniteLogementPaylaodWeb.getId()).orElse(new UniteLogement());

        if (uniteLogementPaylaodWeb.getCategorieBatimentId() != null) {
            CategorieBatiment categorieBatiment = new CategorieBatiment();
            categorieBatiment.setId(uniteLogementPaylaodWeb.getCategorieBatimentId());
            uniteLogement.setCategorieBatiment(categorieBatiment);
        }

        if(uniteLogementPaylaodWeb.getBatimentId()!=null)
            optionalBatiment=batimentRepository.findById(uniteLogementPaylaodWeb.getBatimentId());

        uniteLogement.setBatiment(optionalBatiment.orElse(null));
        uniteLogement.setId(uniteLogementPaylaodWeb.getId());
        uniteLogement.setCode(uniteLogementPaylaodWeb.getCode());
        uniteLogement.setNul(uniteLogementPaylaodWeb.getNul());
        uniteLogement.setSuperficieAuSol(uniteLogementPaylaodWeb.getSuperficieAuSol());
        uniteLogement.setSuperficieLouee(uniteLogementPaylaodWeb.getSuperficieLouee());
        uniteLogement.setDateConstruction(uniteLogementPaylaodWeb.getDateConstruction());
        uniteLogement.setNumeroEtage(uniteLogementPaylaodWeb.getNumeroEtage());
        return uniteLogement ;
    }

    public Fonction getFonctionFromPayLoadWeb(FonctionPaylaodWeb fonctionPaylaodWeb){
        Fonction fonction =new Fonction();
        Optional<Secteur> optionalSecteur=Optional.empty();
        Optional<Section> optionalSection=Optional.empty();
        Optional<Profile> optionalProfile=Optional.empty();
        Optional<User> optionalUser=Optional.empty();
        Optional<Structure> optionalStructure=Optional.empty();
        if(fonctionPaylaodWeb.getId()!=null)
            fonction = fonctionRepository.findById(fonctionPaylaodWeb.getId()).orElse(new Fonction());



        if(fonctionPaylaodWeb.getSecteurId()!=null)
            optionalSecteur=secteurRepository.findById(fonctionPaylaodWeb.getSecteurId());
        if(fonctionPaylaodWeb.getProfileId()!=null)
            optionalProfile=profileRepository.findById(fonctionPaylaodWeb.getProfileId());
        if(fonctionPaylaodWeb.getSectionId()!=null)
            optionalSection=sectionRepository.findById(fonctionPaylaodWeb.getSecteurId());
        if(fonctionPaylaodWeb.getStructureId()!=null)
            optionalStructure=structureRepository.findById(fonctionPaylaodWeb.getStructureId());

        fonction.setSecteur(optionalSecteur.orElse(null));
        fonction.setProfile(optionalProfile.orElse(null));
        fonction.setSection(optionalSection.orElse(null));
        fonction.setStructure(optionalStructure.orElse(null));
        fonction.setProfile(optionalProfile.orElse(null));
        fonction.setId(fonctionPaylaodWeb.getId());
        fonction.setCode(fonctionPaylaodWeb.getCode());
        fonction.setNom(fonctionPaylaodWeb.getNom());
        return fonction;
    }


    public AvoirFonction getAvoirFonctionFromPayLoadWeb(AvoirFonctionPaylaodWeb avoirFonctionPaylaodWeb){
        AvoirFonction avoirFonction =new AvoirFonction();
        Optional<Fonction> optionalFonction=Optional.empty();
        Optional<User> optionalUser=Optional.empty();
        if(avoirFonctionPaylaodWeb.getId()!=null)
            avoirFonction = avoirFonctionRepository.findById(avoirFonctionPaylaodWeb.getId()).orElse(new AvoirFonction());


        if(avoirFonctionPaylaodWeb.getFonctionId()!=null)
            optionalFonction=fonctionRepository.findById(avoirFonctionPaylaodWeb.getFonctionId());
        if(avoirFonctionPaylaodWeb.getUserId()!=null)
            optionalUser=userRepository.findById(avoirFonctionPaylaodWeb.getUserId());

        avoirFonction.setFonction(optionalFonction.orElse(null));
        avoirFonction.setUser(optionalUser.orElse(null));
        avoirFonction.setTitre(avoirFonction.getTitre());
        avoirFonction.setId(avoirFonction.getId());
        avoirFonction.setDateDebut(avoirFonction.getDateDebut());
        avoirFonction.setDateFin(avoirFonction.getDateFin());

        return avoirFonction;
    }


    public Profile getProfileFromPayLoadWeb(ProfilePaylaodWeb profilePaylaodWeb){
        Profile profile =new Profile();
        if(profilePaylaodWeb.getId()!=null)
            profile = profileRepository.findById(profilePaylaodWeb.getId()).orElse(new Profile());

        profile.setDescription(profilePaylaodWeb.getDescription());
        profile.setRoles(profilePaylaodWeb.getRoles());
        profile.setNom(profilePaylaodWeb.getNom());


        return profile;
    }

    public Personne getPersonneFromPayLoadWeb(PersonnePayLoadWeb personnePayLoadWeb){
        Personne personne=new Personne();
        Optional<SituationMatrimoniale> optionalSituationMatrimoniale=Optional.empty();
        Optional<Nationalite> optionalNationalite=Optional.empty();
        Optional<TypePersonne> optionalTypePersonne=Optional.empty();
        Optional<Profession> optionalProfession=Optional.empty();
        Optional<Commune> optionalCommune=Optional.empty();
        if(personnePayLoadWeb.getId()!=null)
            personne = personneRepository.findById(personnePayLoadWeb.getId()).orElse(new Personne());


        if(personnePayLoadWeb.getSituationMatrimonialeId()!=null)
            optionalSituationMatrimoniale=situationMatrimonialeRepository.findById(personnePayLoadWeb.getSituationMatrimonialeId());

        if(personnePayLoadWeb.getProfessionId()!=null)
            optionalProfession=professionRepository.findById(personnePayLoadWeb.getProfessionId());

        if(personnePayLoadWeb.getTypePersonneId()!=null)
            optionalTypePersonne=typePersonneRepository.findById(personnePayLoadWeb.getTypePersonneId());

        if(personnePayLoadWeb.getNationaliteId()!=null)
            optionalNationalite=nationaliteRepository.findById(personnePayLoadWeb.getNationaliteId());
        if(personnePayLoadWeb.getCommuneId()!=null)
            optionalCommune=communeRepository.findById(personnePayLoadWeb.getCommuneId());
        personne.setId(personnePayLoadWeb.getId());
        personne.setSituationMatrimoniale(optionalSituationMatrimoniale.orElse(null));
        personne.setNationalite(optionalNationalite.orElse(null));
        personne.setTypePersonne(optionalTypePersonne.orElse(null));
        personne.setProfession(optionalProfession.orElse(null));
        personne.setCommune(optionalCommune.orElse(null));
        personne.setAdresse(personnePayLoadWeb.getAdresse());
        personne.setAge(personnePayLoadWeb.getAge());
        personne.setCategorie(personnePayLoadWeb.getCategorie());
        personne.setDateNaissanceOuConsti(personnePayLoadWeb.getDateNaissanceOuConsti());
        personne.setIfu(personnePayLoadWeb.getIfu());
        personne.setIndicatifTel1(personnePayLoadWeb.getIndicatifTel1());
        personne.setIndicatifTel2(personnePayLoadWeb.getIndicatifTel2());
        personne.setTel1(personnePayLoadWeb.getTel1());
        personne.setTel2(personnePayLoadWeb.getTel2());
        personne.setLieuNaissance(personnePayLoadWeb.getLieuNaissance());
        personne.setHaveRepresentant(personnePayLoadWeb.getHaveRepresentant());
        personne.setNomJeuneFille(personnePayLoadWeb.getNomJeuneFille());
        personne.setNomMere(personnePayLoadWeb.getNomMere());
        personne.setPrenomMere(personnePayLoadWeb.getPrenomMere());
        personne.setNom(personnePayLoadWeb.getNom());
        personne.setPrenom(personnePayLoadWeb.getPrenom());
        personne.setRaisonSociale(personnePayLoadWeb.getRaisonSociale());
        personne.setNpi(personnePayLoadWeb.getNpi());
        personne.setNumRavip(personnePayLoadWeb.getNumRavip());
        personne.setObservation(personnePayLoadWeb.getObservation());
        personne.setSexe(personnePayLoadWeb.getSexe());
        personne.setEtatIdentificationPersonne(personnePayLoadWeb.getEtatIdentificationPersonne());

        return personne ;
    }


    public EnqueteActivite getEnqueteActivitePayLoadWeb(EnqueteActivitePayLoadWeb enqueteActivitePayLoadWeb){
        EnqueteActivite enqueteActivite=new EnqueteActivite();
        //Optional<Enquete> optionalEnquete=Optional.empty();
        Optional<Structure> optionalStructure=Optional.empty();
        Optional<Personne> optionalPersonne=Optional.empty();
        Optional<Batiment> optionalBatiment=Optional.empty();
        Optional<UniteLogement> optionalUniteLogement=Optional.empty();
        Optional<Parcelle> optionalParcelle=Optional.empty();
        Optional<Profession> optionalProfession=Optional.empty();
        if(enqueteActivitePayLoadWeb.getId()!=null)
            enqueteActivite = enqueteActiviteRepository.findById(enqueteActivitePayLoadWeb.getId()).orElse(new EnqueteActivite());


        if(enqueteActivitePayLoadWeb.getBatimentId()!=null)
            optionalBatiment=batimentRepository.findById(enqueteActivitePayLoadWeb.getBatimentId());

//        if(enqueteActivitePayLoadWeb.getEnqueteId()!=null)
//            optionalEnquete=enqueteRepository.findById(enqueteActivitePayLoadWeb.getEnqueteId());

        if(enqueteActivitePayLoadWeb.getStructureId()!=null)
            optionalStructure=structureRepository.findById(enqueteActivitePayLoadWeb.getStructureId());

        if(enqueteActivitePayLoadWeb.getPersonneId()!=null)
            optionalPersonne=personneRepository.findById(enqueteActivitePayLoadWeb.getPersonneId());

        if(enqueteActivitePayLoadWeb.getUniteLogementId()!=null)
            optionalUniteLogement=uniteLogementRepository.findById(enqueteActivitePayLoadWeb.getUniteLogementId());

        if(enqueteActivitePayLoadWeb.getParcelleId()!=null)
            optionalParcelle=parcelleRepository.findById(enqueteActivitePayLoadWeb.getParcelleId());

        if(enqueteActivitePayLoadWeb.getProfessionId()!=null)
            optionalProfession=professionRepository.findById(enqueteActivitePayLoadWeb.getProfessionId());

        enqueteActivite.setBatiment(optionalBatiment.orElse(null));
        enqueteActivite.setUniteLogement(optionalUniteLogement.orElse(null));
        enqueteActivite.setPersonne(optionalPersonne.orElse(null));
        //enqueteActivite.setEnquete(optionalEnquete.orElse(null));
        enqueteActivite.setProfession(optionalProfession.orElse(null));
        enqueteActivite.setParcelle(optionalParcelle.orElse(null));
        enqueteActivite.setStructure(optionalStructure.orElse(null));
        enqueteActivite.setBatiment(optionalBatiment.orElse(null));
        enqueteActivite.setNc(enqueteActivitePayLoadWeb.getNc());
        enqueteActivite.setDateEnquete(enqueteActivitePayLoadWeb.getDateEnquete());
        enqueteActivite.setEstDeclarer(enqueteActivitePayLoadWeb.isEstDeclarer());
        enqueteActivite.setNumeroRccm(enqueteActivitePayLoadWeb.getNumeroRccm());
        enqueteActivite.setDateDemarrage(enqueteActivitePayLoadWeb.getDateDemarrage());
        enqueteActivite.setDateFin(enqueteActivitePayLoadWeb.getDateFin());
        enqueteActivite.setChiffreAffaire(enqueteActivitePayLoadWeb.getChiffreAffaire());
        return enqueteActivite ;
    }


    public User getUserFromPayLoadWeb(UserPaylaodWeb userPaylaodWeb){
        User user =new User();
        Optional<Structure> optionalStructure = Optional.empty();
        if(userPaylaodWeb.getId()!=null)
            user = userRepository.findById(userPaylaodWeb.getId()).orElse(new User());


        if(userPaylaodWeb.getStructureId()!=null)
            optionalStructure=structureRepository.findById(userPaylaodWeb.getStructureId());

        user.setId(userPaylaodWeb.getId());
        user.setStructure(optionalStructure.orElse(null));
        user.setUsername(userPaylaodWeb.getLogin());
        user.setEmail(userPaylaodWeb.getEmail());
        user.setNom(userPaylaodWeb.getNom());
        user.setPrenom(userPaylaodWeb.getPrenom());
        user.setTel(userPaylaodWeb.getTelephone());
        user.setActive(true);
        user.setResetPassword(true);
        return user ;
    }

    public EnqueteUniteLogement getEnqueteUniteLogementFromPayLoadWeb(EnqueteUniteLogementPayloadWeb enqueteUniteLogementPayloadWeb){

        EnqueteUniteLogement eul = new EnqueteUniteLogement();
        if (enqueteUniteLogementPayloadWeb.getId()!=null)
            eul =enqueteUniteLogementRepository.findById(enqueteUniteLogementPayloadWeb.getId()).orElse(new EnqueteUniteLogement());

        Optional<Exercice> optionalExercice = Optional.empty();
        Optional<Personne> optionalPersonne = Optional.empty();
        Optional<UniteLogement> optionalUniteLogement = Optional.empty();
        Optional<User> optionalUser = Optional.empty();

//        if(enqueteUniteLogementPayloadWeb.getExerciceId()!=null)
//            optionalExercice= exerciceRepository.findById(enqueteUniteLogementPayloadWeb.getExerciceId());
//        eul.setExercice(optionalExercice.orElse(null));

        if(enqueteUniteLogementPayloadWeb.getUniteLogementId()!=null)
            optionalUniteLogement= uniteLogementRepository.findById(enqueteUniteLogementPayloadWeb.getUniteLogementId());
        eul.setUniteLogement(optionalUniteLogement.orElse(null));
        if(enqueteUniteLogementPayloadWeb.getPersonneId()!=null)
            optionalPersonne= personneRepository.findById(enqueteUniteLogementPayloadWeb.getPersonneId());
        eul.setPersonne(optionalPersonne.orElse(null));

        if(enqueteUniteLogementPayloadWeb.getEnqueteurId()!=null)
            optionalUser= userRepository.findById(enqueteUniteLogementPayloadWeb.getEnqueteurId());
         eul.setUser(optionalUser.orElse(null));


        if (enqueteUniteLogementPayloadWeb.getExerciceId() != null) {
            Exercice exercice = new Exercice();
            exercice.setId(enqueteUniteLogementPayloadWeb.getExerciceId());
            eul.setExercice(exercice);
        }

        if (enqueteUniteLogementPayloadWeb.getCategorieBatimentId() != null) {
            CategorieBatiment categorieBatiment = new CategorieBatiment();
            categorieBatiment.setId(enqueteUniteLogementPayloadWeb.getCategorieBatimentId());
            eul.setCategorieBatiment(categorieBatiment);
        }

        if (enqueteUniteLogementPayloadWeb.getUsageId() != null) {
            Usage usage = new Usage();
            usage.setId(enqueteUniteLogementPayloadWeb.getUsageId());
            eul.setUsage(usage);
        }


        eul.setId(enqueteUniteLogementPayloadWeb.getId());
        eul.setObservation(enqueteUniteLogementPayloadWeb.getObservation());
        eul.setNbrePiece(enqueteUniteLogementPayloadWeb.getNbrePiece());
        eul.setNbreHabitant(enqueteUniteLogementPayloadWeb.getNbreHabitant());
        eul.setNbreMenage(enqueteUniteLogementPayloadWeb.getNbreMenage());
        eul.setEnLocation(enqueteUniteLogementPayloadWeb.getEnLocation());
        eul.setNbreMoisLocation(enqueteUniteLogementPayloadWeb.getNbreMoisLocation());
        eul.setMontantMensuelLocation(enqueteUniteLogementPayloadWeb.getMontantMensuelLocation());
        eul.setMontantLocatifAnnuelDeclare(enqueteUniteLogementPayloadWeb.getMontantLocatifAnnuelDeclare());
        eul.setValeurUniteLogementEstime(enqueteUniteLogementPayloadWeb.getValeurUniteLogementEstime());
        eul.setValeurUniteLogementReel(enqueteUniteLogementPayloadWeb.getValeurUniteLogementReel());
        eul.setSuperficieLouee(enqueteUniteLogementPayloadWeb.getSuperficieLouee());
        eul.setSuperficieAuSol(enqueteUniteLogementPayloadWeb.getSuperficieAuSol());
        eul.setDateEnquete(enqueteUniteLogementPayloadWeb.getDateEnquete());
        eul.setSbee(enqueteUniteLogementPayloadWeb.getSbee());
        eul.setSoneb(enqueteUniteLogementPayloadWeb.getSoneb());
        eul.setNumCompteurSbee(enqueteUniteLogementPayloadWeb.getNumCompteurSbee());
        eul.setNumCompteurSoneb(enqueteUniteLogementPayloadWeb.getNumCompteurSoneb());
        eul.setDateDebutExemption(enqueteUniteLogementPayloadWeb.getDateDebutExemption());
        eul.setDateFinExemption(enqueteUniteLogementPayloadWeb.getDateFinExemption());
        eul.setRepresentantNom(enqueteUniteLogementPayloadWeb.getRepresentantNom());
        eul.setRepresentantPrenom(enqueteUniteLogementPayloadWeb.getRepresentantPrenom());
        eul.setRepresentantTel(enqueteUniteLogementPayloadWeb.getRepresentantTel());
        eul.setRepresentantNpi(enqueteUniteLogementPayloadWeb.getRepresentantNpi());
        eul.setNombrePiscine(enqueteUniteLogementPayloadWeb.getNombrePiscine());
       // eul.setStatutEnquete(StatutEnquete.EN_COURS);
        //if(!enqueteUniteLogementPayloadWeb.getStatutEnquete().equals(StatutEnquete.DECLARATION)){
            eul.setStatutEnquete(StatutEnquete.EN_COURS);
//        }else{
//            eul.setStatutEnquete(enqueteUniteLogementPayloadWeb.getStatutEnquete());
//        }

        return eul;
    }

    public EnqueteBatiment getEnqueteBatimentFromPayLoadWeb(EnqueteBatimentPayloadWeb enqueteBatimentPayloadWeb){
        EnqueteBatiment enqueteBatiment = new EnqueteBatiment();
        if (enqueteBatimentPayloadWeb.getId()!=null)
            enqueteBatiment=enqueteBatimentRepository.findById(enqueteBatimentPayloadWeb.getId()).orElse(new EnqueteBatiment());

        // ======================
        // Relations (sans hit DB)
        // ======================

        if (enqueteBatimentPayloadWeb.getBatimentId() != null) {
            Batiment batiment = new Batiment();
            batiment.setId(enqueteBatimentPayloadWeb.getBatimentId());
            enqueteBatiment.setBatiment(batiment);
        }

        if (enqueteBatimentPayloadWeb.getPersonneId() != null) {
            Personne personne = new Personne();
            personne.setId(enqueteBatimentPayloadWeb.getPersonneId());
            enqueteBatiment.setPersonne(personne);
        }

        if (enqueteBatimentPayloadWeb.getEnqueteurId() != null) {
            User user = new User();
            user.setId(enqueteBatimentPayloadWeb.getEnqueteurId());
            enqueteBatiment.setUser(user);
        }
        if (enqueteBatimentPayloadWeb.getExerciceId() != null) {
            Exercice exercice = new Exercice();
            exercice.setId(enqueteBatimentPayloadWeb.getExerciceId());
            enqueteBatiment.setExercice(exercice);
        }

        if (enqueteBatimentPayloadWeb.getCategorieBatimentId() != null) {
            CategorieBatiment categorieBatiment = new CategorieBatiment();
            categorieBatiment.setId(enqueteBatimentPayloadWeb.getCategorieBatimentId());
            enqueteBatiment.setCategorieBatiment(categorieBatiment);
        }

        if (enqueteBatimentPayloadWeb.getUsageId() != null) {
            Usage usage = new Usage();
            usage.setId(enqueteBatimentPayloadWeb.getUsageId());
            enqueteBatiment.setUsage(usage);
        }

        // ======================
        // Champs simples
        // ======================

        enqueteBatiment.setId(enqueteBatimentPayloadWeb.getId());
        enqueteBatiment.setObservation(enqueteBatimentPayloadWeb.getObservation());
        enqueteBatiment.setAutreMenuisierie(enqueteBatimentPayloadWeb.getAutreMenuisierie());
        enqueteBatiment.setAutreMur(enqueteBatimentPayloadWeb.getAutreMur());

        enqueteBatiment.setSbee(enqueteBatimentPayloadWeb.isSbee());
        enqueteBatiment.setNumCompteurSbee(enqueteBatimentPayloadWeb.getNumCompteurSbee());
        enqueteBatiment.setSoneb(enqueteBatimentPayloadWeb.isSoneb());
        enqueteBatiment.setNumCompteurSoneb(enqueteBatimentPayloadWeb.getNumCompteurSoneb());

        enqueteBatiment.setNbreLotUnite(enqueteBatimentPayloadWeb.getNbreLotUnite());
        enqueteBatiment.setNbreUniteLocation(enqueteBatimentPayloadWeb.getNbreUniteLocation());
        enqueteBatiment.setNbreMenage(enqueteBatimentPayloadWeb.getNbreMenage());
        enqueteBatiment.setNbreHabitant(enqueteBatimentPayloadWeb.getNbreHabitant());
        enqueteBatiment.setNbreMoisLocation(enqueteBatimentPayloadWeb.getNbreMoisLocation());

        enqueteBatiment.setMontantMensuelLocation(enqueteBatimentPayloadWeb.getMontantMensuelLocation());
        enqueteBatiment.setMontantLocatifAnnuelDeclare(enqueteBatimentPayloadWeb.getMontantLocatifAnnuelDeclare());
        enqueteBatiment.setValeurBatimentEstime(enqueteBatimentPayloadWeb.getValeurBatimentEstime());
        enqueteBatiment.setValeurBatimentReel(enqueteBatimentPayloadWeb.getValeurBatimentReel());

        enqueteBatiment.setSuperficieLouee(enqueteBatimentPayloadWeb.getSuperficieLouee());
        enqueteBatiment.setSuperficieAuSol(enqueteBatimentPayloadWeb.getSuperficieAuSol());

        enqueteBatiment.setDateEnquete(enqueteBatimentPayloadWeb.getDateEnquete());
        enqueteBatiment.setDateDebutExcemption(enqueteBatimentPayloadWeb.getDateDebutExcemption());
        enqueteBatiment.setDateFinExcemption(enqueteBatimentPayloadWeb.getDateFinExcemption());

        enqueteBatiment.setAutreCaracteristiquePhysique(enqueteBatimentPayloadWeb.getAutreCaracteristiquePhysique());

        enqueteBatiment.setNbreEtage(enqueteBatimentPayloadWeb.getNbreEtage());
        enqueteBatiment.setRepresentantNom(enqueteBatimentPayloadWeb.getRepresentantNom());
        enqueteBatiment.setRepresentantPrenom(enqueteBatimentPayloadWeb.getRepresentantPrenom());
        enqueteBatiment.setRepresentantTel(enqueteBatimentPayloadWeb.getRepresentantTel());
        enqueteBatiment.setRepresentantNpi(enqueteBatimentPayloadWeb.getRepresentantNpi());
        enqueteBatiment.setNombrePiscine(enqueteBatimentPayloadWeb.getNombrePiscine());
        //enqueteBatiment.setStatutEnquete(StatutEnquete.EN_COURS);
        //if(!enqueteBatimentPayloadWeb.getStatutEnquete().equals(StatutEnquete.DECLARATION)){
            enqueteBatiment.setStatutEnquete(StatutEnquete.EN_COURS);
//        }else{
//            enqueteBatiment.setStatutEnquete(enqueteBatimentPayloadWeb.getStatutEnquete());
//        }
        return enqueteBatiment;
    }


    public Enquete getEnqueteFromPayLoadWeb(EnquetePayLoadWeb enquetePayLoadWeb){
        Enquete enquete = new Enquete();
        if (enquetePayLoadWeb.getId()!=null)
            enquete=enqueteRepository.findById(enquetePayLoadWeb.getId()).orElse(new Enquete());

        // ======================
        // Relations (sans hit DB)
        // ======================

        if (enquetePayLoadWeb.getParcelleId() != null) {
            Parcelle parcelle = new Parcelle();
            parcelle.setId(enquetePayLoadWeb.getParcelleId());
            enquete.setParcelle(parcelle);
        }

        if (enquetePayLoadWeb.getPersonneId() != null) {
            Personne personne = new Personne();
            personne.setId(enquetePayLoadWeb.getPersonneId());
            enquete.setPersonne(personne);
        }

        if (enquetePayLoadWeb.getEnqueteurId() != null) {
            User user = new User();
            user.setId(enquetePayLoadWeb.getEnqueteurId());
            enquete.setUser(user);
        }

        if (enquetePayLoadWeb.getZoneRfuId() != null) {
            ZoneRfu zoneRfu = new ZoneRfu();
            zoneRfu.setId(enquetePayLoadWeb.getZoneRfuId());
            enquete.setZoneRfu(zoneRfu);
        }

        if (enquetePayLoadWeb.getExerciceId() != null) {
            Exercice exercice = new Exercice();
            exercice.setId(enquetePayLoadWeb.getExerciceId());
            enquete.setExercice(exercice);
        }


        if (enquetePayLoadWeb.getModeAcquisitionId() != null) {
            ModeAcquisition modeAcquisition = new ModeAcquisition();
            modeAcquisition.setId(enquetePayLoadWeb.getModeAcquisitionId());
            enquete.setModeAcquisition(modeAcquisition);
        }



        // ======================
        // Champs simples
        // ======================
        enquete.setDateEnquete(LocalDate.now());
        enquete.setLitige(enquetePayLoadWeb.getLitige());

       // if(!enquetePayLoadWeb.getStatutEnquete().equals(StatutEnquete.DECLARATION)){
            enquete.setStatutEnquete(StatutEnquete.EN_COURS);
//        }else{
//            enquete.setStatutEnquete(enquetePayLoadWeb.getStatutEnquete());
//        }
        enquete.setObservationParticuliere(enquetePayLoadWeb.getObservation());
        enquete.setAutreAdresse(enquetePayLoadWeb.getAutreAdresse());
        enquete.setAutreNumeroTitreFoncier(enquetePayLoadWeb.getAutreNumeroTitreFoncier());
        enquete.setNumeroTitreFoncier(enquetePayLoadWeb.getNumeroTitreFoncier());
        enquete.setDateDebutExcemption(enquetePayLoadWeb.getDateDebutExemption());
        enquete.setDateFinExcemption(enquetePayLoadWeb.getDateFinExemption());
        enquete.setNbreBatiment(enquetePayLoadWeb.getNbreBatiment());
        enquete.setNbrePiscine(enquetePayLoadWeb.getNbrePiscine());
        enquete.setNbreIndivisiaire(enquetePayLoadWeb.getNbreIndivisiaire());
        enquete.setNbreCoProprietaire(enquetePayLoadWeb.getNbreCoProprietaire());
        enquete.setNumEntreeParcelle(enquetePayLoadWeb.getNumEntreeParcelle());
        enquete.setNomRue(enquetePayLoadWeb.getNomRue());
        enquete.setNumRue(enquetePayLoadWeb.getNumRue());
        enquete.setSuperficie(enquetePayLoadWeb.getSuperficie());
        enquete.setMontantMensuelleLocation(enquetePayLoadWeb.getMontantMensuelleLocation());
        enquete.setMontantAnnuelleLocation(enquetePayLoadWeb.getMontantAnnuelleLocation());
        enquete.setValeurParcelleEstime(enquetePayLoadWeb.getValeurParcelleEstime());
        enquete.setValeurParcelleReel(enquetePayLoadWeb.getValeurParcelleReel());
        enquete.setRepresentantNpi(enquetePayLoadWeb.getRepresentantNpi());
        enquete.setRepresentantNom(enquetePayLoadWeb.getRepresentantNom());
        enquete.setRepresentantPrenom(enquetePayLoadWeb.getRepresentantPrenom());
        enquete.setRepresentantTel(enquetePayLoadWeb.getRepresentantTel());
        enquete.setSynchronise(true);

        return enquete;
    }





    public BaremRfuBati getBaremRfuBatiFromPayLoadWeb(BaremRfuBatiPayloadWeb baremRfuBatiPayloadWeb){
        BaremRfuBati baremRfuBati = new BaremRfuBati();
        if (baremRfuBatiPayloadWeb.getId()!=null)
            baremRfuBati=baremRfuRepository.findById(baremRfuBatiPayloadWeb.getId()).orElse(new BaremRfuBati());

        // ======================
        // Relations (sans hit DB)
        // ======================

        if (baremRfuBatiPayloadWeb.getArrondissementId() != null) {
            Arrondissement arrondissement = new Arrondissement();
            arrondissement.setId(baremRfuBatiPayloadWeb.getArrondissementId());
            baremRfuBati.setArrondissement(arrondissement);
        }

        if (baremRfuBatiPayloadWeb.getQuartierId() != null) {
            Quartier quartier = new Quartier();
            quartier.setId(baremRfuBatiPayloadWeb.getQuartierId());
            baremRfuBati.setQuartier(quartier);
        }

        if (baremRfuBatiPayloadWeb.getCategorieBatimentId() != null) {
            CategorieBatiment categorieBatiment = new CategorieBatiment();
            categorieBatiment.setId(baremRfuBatiPayloadWeb.getCategorieBatimentId());
            baremRfuBati.setCategorieBatiment(categorieBatiment);
        }

        baremRfuBati.setTfuMinimum(baremRfuBatiPayloadWeb.getTfuMinimum());
        baremRfuBati.setValeurLocative(baremRfuBatiPayloadWeb.getValeurLocative());
        baremRfuBati.setTfuMetreCarre(baremRfuBatiPayloadWeb.getTfuMetreCarre());



        return baremRfuBati;
    }


    public ImpositionsTfu getImpositionsTfuFromPayLoadWeb(ImpositionsTfuPaylaodWeb impositionsTfuPaylaodWeb){
        ImpositionsTfu impositionsTfu = new ImpositionsTfu();
        if (impositionsTfuPaylaodWeb.getId()!=null)
            impositionsTfu=impositionsTfuRepository.findById(impositionsTfuPaylaodWeb.getId()).orElse(new ImpositionsTfu());

        // ======================
        // Relations (sans hit DB)
        // ======================

        if (impositionsTfuPaylaodWeb.getExerciceId() != null) {
            Exercice exercice = new Exercice();
            exercice.setId(impositionsTfuPaylaodWeb.getExerciceId());
            impositionsTfu.setExercice(exercice);
        }

        if (impositionsTfuPaylaodWeb.getCommuneId() != null) {
            Commune commune = new Commune();
            commune.setId(impositionsTfuPaylaodWeb.getCommuneId());
            impositionsTfu.setCommune(commune);
        }

        if (impositionsTfuPaylaodWeb.getStructureId() != null) {
            Structure structure = new Structure();
            structure.setId(impositionsTfuPaylaodWeb.getStructureId());
            impositionsTfu.setStructure(structure);
        }
        impositionsTfu.setMotif(impositionsTfuPaylaodWeb.getMotif());
        impositionsTfu.setDatePieceAdmin(impositionsTfuPaylaodWeb.getDatePieceAdmin());
        impositionsTfu.setReferencePieceAdmin(impositionsTfuPaylaodWeb.getReferencePieceAdmin());

        return impositionsTfu;
    }



    public BaremRfuNonBati getBaremRfuNonBatiFromPayLoadWeb(BaremRfuNonBatiPayloadWeb baremRfuNonBatiPayloadWeb){
        BaremRfuNonBati baremRfuNonBati = new BaremRfuNonBati();
        if (baremRfuNonBatiPayloadWeb.getId()!=null)
            baremRfuNonBati=baremRfuNonBatiRepository.findById(baremRfuNonBatiPayloadWeb.getId()).orElse(new BaremRfuNonBati());

        // ======================
        // Relations (sans hit DB)
        // ======================

        if (baremRfuNonBatiPayloadWeb.getZoneRfuId() != null) {
            ZoneRfu zoneRfu = new ZoneRfu();
            zoneRfu.setId(baremRfuNonBatiPayloadWeb.getZoneRfuId());
            baremRfuNonBati.setZoneRfu(zoneRfu);
        }

        if (baremRfuNonBatiPayloadWeb.getCommuneId() != null) {
            Commune commune = new Commune();
            commune.setId(baremRfuNonBatiPayloadWeb.getCommuneId());
            baremRfuNonBati.setCommune(commune);
        }

        baremRfuNonBati.setTaux(baremRfuNonBatiPayloadWeb.getTaux());
        baremRfuNonBati.setAuMetreCarre(baremRfuNonBatiPayloadWeb.getAuMetreCarre());
        baremRfuNonBati.setValeurAdministrative(baremRfuNonBatiPayloadWeb.getValeurAdministrative());
        baremRfuNonBati.setValeurAdministrativeMetreCarre(baremRfuNonBatiPayloadWeb.getValeurAdministrativeMetreCarre());

        return baremRfuNonBati;
    }



    public Parcelle getParcelleFromPayload(ParcellePayLoadWeb parcellePayLoadWeb) {
        Parcelle parcelle = new Parcelle();
        if (parcellePayLoadWeb.getId() != null)
            parcelle = parcelleRepository.findById(parcellePayLoadWeb.getId()).orElse(new Parcelle());

        if (parcellePayLoadWeb.getRueId() != null) {
            Optional<Rue> optionalRue = rueRepository.findById(parcellePayLoadWeb.getRueId());
            parcelle.setRue(optionalRue.orElse(null));
        }
        Optional<NatureDomaine> optionalNatureDomaine = natureDomaineRepository.findById(parcellePayLoadWeb.getNatureDomaineId());
        if (optionalNatureDomaine.isPresent()) {
            parcelle.setNatureDomaine(optionalNatureDomaine.orElse(null));
        }
        Optional<Quartier> optionalQuartier = quartierRepository.findById(parcellePayLoadWeb.getQuartierId());
        if (!optionalQuartier.isPresent()) {
            parcelle.setQuartier(optionalQuartier.orElse(null));
        }

        Optional<TypeDomaine> optionalTypeDomaine = typeDomaineRepository.findById(parcellePayLoadWeb.getTypeDomaineId());
        if (!optionalTypeDomaine.isPresent()) {
            parcelle.setTypeDomaine(optionalTypeDomaine.orElse(null));
        }
            parcelle.setP(parcellePayLoadWeb.getP());
            parcelle.setI(parcellePayLoadWeb.getI());
            parcelle.setQ(parcellePayLoadWeb.getQ());
            parcelle.setNup(parcellePayLoadWeb.getNup());
            parcelle.setLatitude(parcellePayLoadWeb.getLatitude());
            parcelle.setLongitude(parcellePayLoadWeb.getLongitude());
            parcelle.setAltitude(parcellePayLoadWeb.getAltitude());
            parcelle.setSituationGeographique(parcellePayLoadWeb.getSituationGeographique());
            parcelle.setNupProvisoire(parcellePayLoadWeb.getNupProvisoire());
            parcelle.setAutreNumeroTitreFoncier(parcellePayLoadWeb.getNumTitreFoncier());
            parcelle.setObservation(parcellePayLoadWeb.getObservation());
            parcelle.setSuperficie(parcellePayLoadWeb.getSuperficie());
            return parcelle;
    }

    public CommuneCentreAssignation getCommuneCentreAssignationFromPayLoadWeb(CommuneCentreAssignationPaylaodWeb communeCentreAssignationPaylaodWeb) {
        CommuneCentreAssignation communeCentreAssignation = new CommuneCentreAssignation();
        if (communeCentreAssignationPaylaodWeb.getId()!=null)
            communeCentreAssignation=communeCentreAssignationRepository.findById(communeCentreAssignationPaylaodWeb.getId()).orElse(new CommuneCentreAssignation());

        if (communeCentreAssignationPaylaodWeb.getPersonneId() != null) {
            Personne personne = new Personne();
            personne.setId(communeCentreAssignationPaylaodWeb.getPersonneId());
            communeCentreAssignation.setPersonne(personne);
        }

//        if (communeCentreAssignationPaylaodWeb.getCommuneId() != null) {
//            Commune commune = new Commune();
//            commune.setId(communeCentreAssignationPaylaodWeb.getCommuneId());
//            communeCentreAssignation.setCommune(commune);
//        }

//        if (communeCentreAssignationPaylaodWeb.getStructureId() != null) {
//            Structure structure = new Structure();
//            structure.setId(communeCentreAssignationPaylaodWeb.getStructureId());
//            communeCentreAssignation.setStructure(structure);
//        }

        if (communeCentreAssignationPaylaodWeb.getParcelleContactId() != null) {
            Parcelle parcelle = new Parcelle();
            parcelle.setId(communeCentreAssignationPaylaodWeb.getParcelleContactId());
            communeCentreAssignation.setParcelle(parcelle);
        }

        return communeCentreAssignation;
    }
}