commit avant gitea

src/main/java/io/gmss/fiscad/controllers/synchronisation/SynchronisationController.java

@@ -208,7 +208,6 @@ public class SynchronisationController {
     public ResponseEntity<?> syncActeurConcerne(@RequestBody List<ActeurConcernePayLoad> piecePayLoads) {
         try {
             return new ResponseEntity<>(
-                    //new ApiResponse<>(true, null, "Liste des acteurs concernes synchronisée avec succès."),
                     new ApiResponse<>(true, synchronisationService.syncActeurConcerne(piecePayLoads), "Liste des acteurs concernes synchronisée avec succès."),
                     HttpStatus.OK
             );
@@ -228,6 +227,57 @@ public class SynchronisationController {
         }
     }
 
+
+    @PostMapping("/enquete-activite")
+    @PreAuthorize("hasRole('ADMIN') or hasRole('SUPERVISEUR') or hasRole('ENQUETEUR')")
+    public ResponseEntity<?> syncEnqueteActivite(@RequestBody List<EnqueteActivitePayload> enqueteActivitePayloads) {
+        try {
+            return new ResponseEntity<>(
+                    //new ApiResponse<>(true, null, "Liste des pièces synchronisée avec succès."),
+                    new ApiResponse<>(true, synchronisationService.syncEnqueteActivite(enqueteActivitePayloads), "Liste des activités synchronisée avec succès."),
+                    HttpStatus.OK
+            );
+        } catch (HttpClientErrorException.MethodNotAllowed e) {
+            logger.error(e.getLocalizedMessage());
+            return new ResponseEntity<>(new ApiResponse(false, null, "Method POST/GET is required."), HttpStatus.OK);
+        } catch (NotFoundException | BadRequestException | MyFileNotFoundException | ResourceNotFoundException |
+                 FileStorageException e) {
+            logger.error(e.getLocalizedMessage());
+            return new ResponseEntity<>(new ApiResponse(false, null, e.getMessage()), HttpStatus.OK);
+        } catch (NullPointerException e) {
+            logger.error(e.getLocalizedMessage());
+            return new ResponseEntity<>(new ApiResponse(false, null, "Null value has been detected {" + e.getMessage() + "}."), HttpStatus.OK);
+        } catch (Exception e) {
+            logger.error(e.getLocalizedMessage());
+            return new ResponseEntity<>(new ApiResponse(false, null, "An error has been occur and the content is {" + e.getMessage() + "}."), HttpStatus.OK);
+        }
+    }
+
+    @PostMapping("/declaraction-nc")
+    @PreAuthorize("hasRole('ADMIN') or hasRole('SUPERVISEUR') or hasRole('ENQUETEUR')")
+    public ResponseEntity<?> syncDeclarationNc(@RequestBody List<DeclarationNcPayload> declarationNcPayloads) {
+        try {
+            return new ResponseEntity<>(
+                    new ApiResponse<>(true, synchronisationService.syncDeclarationNc(declarationNcPayloads), "Liste des activités synchronisée avec succès."),
+                    HttpStatus.OK
+            );
+        } catch (HttpClientErrorException.MethodNotAllowed e) {
+            logger.error(e.getLocalizedMessage());
+            return new ResponseEntity<>(new ApiResponse(false, null, "Method POST/GET is required."), HttpStatus.OK);
+        } catch (NotFoundException | BadRequestException | MyFileNotFoundException | ResourceNotFoundException |
+                 FileStorageException e) {
+            logger.error(e.getLocalizedMessage());
+            return new ResponseEntity<>(new ApiResponse(false, null, e.getMessage()), HttpStatus.OK);
+        } catch (NullPointerException e) {
+            logger.error(e.getLocalizedMessage());
+            return new ResponseEntity<>(new ApiResponse(false, null, "Null value has been detected {" + e.getMessage() + "}."), HttpStatus.OK);
+        } catch (Exception e) {
+            logger.error(e.getLocalizedMessage());
+            return new ResponseEntity<>(new ApiResponse(false, null, "An error has been occur and the content is {" + e.getMessage() + "}."), HttpStatus.OK);
+        }
+    }
+
+
     //@PostMapping("/files")
 //    @PostMapping(path = "/files")
 //    @PreAuthorize("hasRole('ADMIN') or hasRole('SUPERVISEUR') or hasRole('ENQUETEUR')")
@@ -365,11 +415,6 @@ public class SynchronisationController {
         }
     }
 
-    /**
-     * Liste des API pour la synchronisation des données liées à FISCAD
-     * Fait le mercredi 15 janvier 2025 à 09h21
-     * MERCI DE NE PAS TOUCHER A CE BLOC DE CODE
-     */
 
     @PostMapping(path = "/batiment")
     @PreAuthorize("hasRole('ADMIN') or hasRole('SUPERVISEUR') or hasRole('ENQUETEUR')")

src/main/java/io/gmss/fiscad/entities/infocad/metier/Enquete.java

@@ -9,6 +9,7 @@ import io.gmss.fiscad.entities.BaseEntity;
 import io.gmss.fiscad.entities.decoupage.Arrondissement;
 import io.gmss.fiscad.entities.infocad.parametre.Bloc;
 import io.gmss.fiscad.entities.infocad.parametre.NatureDomaine;
+import io.gmss.fiscad.entities.infocad.parametre.Personne;
 import io.gmss.fiscad.entities.rfu.metier.CaracteristiqueParcelle;
 import io.gmss.fiscad.entities.rfu.metier.EnqueteBatiment;
 import io.gmss.fiscad.entities.rfu.metier.EnqueteUniteLogement;
@@ -18,6 +19,7 @@ import io.gmss.fiscad.entities.rfu.parametre.ZoneRfu;
 import io.gmss.fiscad.entities.user.User;
 import io.gmss.fiscad.enums.StatusEnquete;
 import io.gmss.fiscad.enums.StatutEnregistrement;
+import io.gmss.fiscad.repositories.infocad.parametre.PersonneRepository;
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
 import lombok.Data;
@@ -76,6 +78,10 @@ public class Enquete extends BaseEntity implements Serializable {
     @ManyToOne
     private Equipe equipe;
 
+    @JsonIgnore
+    @ManyToOne
+    private Personne personne ;
+
     @JsonIgnore
     @ManyToOne
     private ZoneRfu zoneRfu;

src/main/java/io/gmss/fiscad/entities/metadata/MobileDataDeclarationNc.java

@@ -0,0 +1,32 @@
+package io.gmss.fiscad.entities.metadata;
+
+import com.vladmihalcea.hibernate.type.json.JsonBinaryType;
+import io.gmss.fiscad.entities.BaseEntity;
+import io.gmss.fiscad.paylaods.request.DeclarationNcPayload;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+import org.hibernate.annotations.Type;
+
+import java.io.Serializable;
+
+@Entity
+@Getter
+@Setter
+@Table(
+        indexes = {
+                @Index(name = "idx_terminal_external_bat", columnList = "terminalId, externalKey")
+        }
+)
+public class MobileDataDeclarationNc extends BaseEntity implements Serializable {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    private Long terminalId;
+    private Long externalKey;
+    @Type(JsonBinaryType.class)
+    @Column(columnDefinition = "jsonb")
+    private DeclarationNcPayload declarationNcPayload ;
+    @Column(columnDefinition = "boolean default false")
+    private boolean traiter;
+}

src/main/java/io/gmss/fiscad/entities/metadata/MobileDataEnqueteActivite.java

@@ -0,0 +1,33 @@
+package io.gmss.fiscad.entities.metadata;
+
+import com.vladmihalcea.hibernate.type.json.JsonBinaryType;
+import io.gmss.fiscad.entities.BaseEntity;
+import io.gmss.fiscad.paylaods.request.BatimentPaylaod;
+import io.gmss.fiscad.paylaods.request.EnqueteActivitePayload;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+import org.hibernate.annotations.Type;
+
+import java.io.Serializable;
+
+@Entity
+@Getter
+@Setter
+@Table(
+        indexes = {
+                @Index(name = "idx_terminal_external_bat", columnList = "terminalId, externalKey")
+        }
+)
+public class MobileDataEnqueteActivite extends BaseEntity implements Serializable {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    private Long terminalId;
+    private Long externalKey;
+    @Type(JsonBinaryType.class)
+    @Column(columnDefinition = "jsonb")
+    private EnqueteActivitePayload enqueteActivitePayload ;
+    @Column(columnDefinition = "boolean default false")
+    private boolean traiter;
+}

src/main/java/io/gmss/fiscad/entities/rfu/metier/DeclarationNc.java

@@ -44,6 +44,12 @@ public class DeclarationNc extends BaseEntity implements Serializable {
     @JsonIgnore
     @ManyToOne
     private Enquete enquete;
+    private Long  enqueteExternalKey;
+
+    @JsonIgnore
+    @ManyToOne
+    private Personne personne ;
+    private Long  personneExternalKey;
 
     @JsonIgnore
     @ManyToOne

src/main/java/io/gmss/fiscad/entities/rfu/metier/EnqueteActivite.java

@@ -51,9 +51,9 @@ public class EnqueteActivite extends BaseEntity implements Serializable {
 
     @Column(columnDefinition = "false")
     private boolean estDeclarer;
-
     private String nc;
-
+    private Long ChiffreAffaire;
+    private String NumeroRccm;
     @OneToOne
     private Personne personne;
     private Long personneExternalKey;
@@ -92,8 +92,6 @@ public class EnqueteActivite extends BaseEntity implements Serializable {
     @JsonIgnore
     private StatutEnregistrement statutEnregistrement;
 
-
-
     //@JsonManagedReference   ///pour couper la récurcivité
     //@OneToMany(mappedBy = "enqueteBatiment")
     //private List<CaracteristiqueBatiment> caracteristiqueBatiments;

src/main/java/io/gmss/fiscad/enums/TypeObjet.java

@@ -14,6 +14,8 @@ public enum TypeObjet {
     ENQUETEUNITELOGEMENT,
     CARACTERISTIQUEPARCELLE,
     CARACTERISTIQUEBATIMENT,
-    CARACTERISTIQUEUNITELOGEMENT
+    CARACTERISTIQUEUNITELOGEMENT,
+    ENQUETEACTIVITE,
+    DECLARATIONNC
 }
 

src/main/java/io/gmss/fiscad/implementations/synchronisation/SynchronisationServiceImpl.java

@@ -101,6 +101,8 @@ public class SynchronisationServiceImpl implements SynchronisationService {
     private final ParcelleAsyncWorker parcelleAsyncWorker;
     private final PieceAsyncWorker pieceAsyncWorker;
     private final UniteLogementAsyncWorker uniteLogementAsyncWorker;
+    private final MobileDataEnqueteActiviteRepository mobileDataEnqueteActiviteRepository;
+    private final MobileDataDeclarationNcRepository mobileDataDeclarationNcRepository;
     private final UploadAsyncWorker uploadAsyncWorker;
     @Value("${io.gmss.fiscad.profile}")
     private String profile;
@@ -311,6 +313,35 @@ public class SynchronisationServiceImpl implements SynchronisationService {
 
         return syncResponses;
     }
+
+    @Override
+    public List<SyncResponse> syncEnqueteActivite(List<EnqueteActivitePayload> enqueteActivitePayloads) {
+        List<SyncResponse> syncResponses = new ArrayList<>();
+        if (enqueteActivitePayloads == null) {
+            SyncResponse syncResponse = new SyncResponse(null,
+                    null, false, "Aucune activité à synchroniser");
+            syncResponses.add(syncResponse);
+            return syncResponses;
+        }
+        syncResponses = saveMobileData(enqueteActivitePayloads, TypeObjet.ENQUETEACTIVITE);
+
+        return syncResponses;
+    }
+
+    @Override
+    public List<SyncResponse> syncDeclarationNc(List<DeclarationNcPayload> declarationNcPayloads) {
+        List<SyncResponse> syncResponses = new ArrayList<>();
+        if (declarationNcPayloads == null) {
+            SyncResponse syncResponse = new SyncResponse(null,
+                    null, false, "Aucun acteur concerné à synchroniser");
+            syncResponses.add(syncResponse);
+            return syncResponses;
+        }
+        syncResponses = saveMobileData(declarationNcPayloads, TypeObjet.DECLARATIONNC);
+
+        return syncResponses;
+    }
+
     @Override
     public SyncResponse syncFiles(MultipartFile file,
                                   Long idBackend,
@@ -465,16 +496,14 @@ public class SynchronisationServiceImpl implements SynchronisationService {
 
     private <T> List<SyncResponse> saveMobileData(List<T> payloads, TypeObjet typeObjet, MultipartFile file) {
         List<SyncResponse> syncResponses = new ArrayList<>();
-        System.out.println("==SYNCHRONISATION== : "+typeObjet.toString());
+        System.out.println(" ==SYNCHRONISATION== : " + typeObjet.toString());
         switch (typeObjet) {
             case PERSONNE -> {
                 payloads.forEach(payLoad -> {
                     PersonnePayLoad personnePayLoad = (PersonnePayLoad) payLoad;
                     try {
                         MobileDataPersonne mobileDataPersonne = new MobileDataPersonne();
-
                         Optional<MobileDataPersonne> optionalMobileDataPersonne = Optional.empty();
-                       // personnePayLoad.setIdBackend(null);
                         if (personnePayLoad.getIdBackend() != null) {
                             optionalMobileDataPersonne = mobileDataPersonneRepository.findById(personnePayLoad.getIdBackend());
                             if (optionalMobileDataPersonne.isPresent()) {
@@ -1079,6 +1108,90 @@ public class SynchronisationServiceImpl implements SynchronisationService {
                     }
                 });
             }
+
+            case ENQUETEACTIVITE -> {
+                payloads.forEach(payLoad -> {
+                    EnqueteActivitePayload enqueteActivitePayload = (EnqueteActivitePayload) payLoad;
+                    try {
+                        MobileDataEnqueteActivite mobileDataEnqueteActivite = new MobileDataEnqueteActivite();
+
+                        Optional<MobileDataEnqueteActivite> optionalMobileDataEnqueteActivite = Optional.empty();
+
+                        if (enqueteActivitePayload.getIdBackend() != null) {
+                            optionalMobileDataEnqueteActivite = mobileDataEnqueteActiviteRepository.findById(enqueteActivitePayload.getIdBackend());
+                            if (optionalMobileDataEnqueteActivite.isPresent()) {
+                                mobileDataEnqueteActivite = optionalMobileDataEnqueteActivite.get();
+                            }
+                        } else {
+                            optionalMobileDataEnqueteActivite = mobileDataEnqueteActiviteRepository.findFirstByTerminalIdAndExternalKey(enqueteActivitePayload.getTerminalId(), enqueteActivitePayload.getExternalKey());
+                            if (optionalMobileDataEnqueteActivite.isPresent()) {
+                                mobileDataEnqueteActivite = optionalMobileDataEnqueteActivite.get();
+                            }
+                        }
+                        mobileDataEnqueteActivite.setTerminalId(enqueteActivitePayload.getTerminalId());
+                        mobileDataEnqueteActivite.setExternalKey(enqueteActivitePayload.getExternalKey());
+                        mobileDataEnqueteActivite.setTraiter(false);
+                        mobileDataEnqueteActivite.setEnqueteActivitePayload(enqueteActivitePayload);
+                        mobileDataEnqueteActivite = mobileDataEnqueteActiviteRepository.save(mobileDataEnqueteActivite);
+                        SyncResponse syncResponse = new SyncResponse();
+                        syncResponse.setObservation("Synchronisation effectuée avec succès pour " + TypeObjet.ENQUETEACTIVITE.toString());
+                        syncResponse.setExternalKey(enqueteActivitePayload.getExternalKey());
+                        syncResponse.setSynchronise(true);
+                        syncResponse.setIdBackend(mobileDataEnqueteActivite.getId());
+                        syncResponses.add(syncResponse);
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                        SyncResponse syncResponse = new SyncResponse();
+                        syncResponse.setObservation("Synchronisation échouée pour " + TypeObjet.ENQUETEACTIVITE.toString());
+                        syncResponse.setExternalKey(enqueteActivitePayload.getExternalKey());
+                        syncResponse.setSynchronise(false);
+                        syncResponse.setIdBackend(enqueteActivitePayload.getIdBackend());
+                        syncResponses.add(syncResponse);
+                    }
+                });
+            }
+
+            case DECLARATIONNC -> {
+                payloads.forEach(payLoad -> {
+                    DeclarationNcPayload declarationNcPayload = (DeclarationNcPayload) payLoad;
+                    try {
+                        MobileDataDeclarationNc mobileDataDeclarationNc = new MobileDataDeclarationNc();
+
+                        Optional<MobileDataDeclarationNc> optionalMobileDataDeclarationNc = Optional.empty();
+
+                        if (declarationNcPayload.getIdBackend() != null) {
+                            optionalMobileDataDeclarationNc = mobileDataDeclarationNcRepository.findById(declarationNcPayload.getIdBackend());
+                            if (optionalMobileDataDeclarationNc.isPresent()) {
+                                mobileDataDeclarationNc = optionalMobileDataDeclarationNc.get();
+                            }
+                        } else {
+                            optionalMobileDataDeclarationNc = mobileDataDeclarationNcRepository.findFirstByTerminalIdAndExternalKey(declarationNcPayload.getTerminalId(), declarationNcPayload.getExternalKey());
+                            if (optionalMobileDataDeclarationNc.isPresent()) {
+                                mobileDataDeclarationNc = optionalMobileDataDeclarationNc.get();
+                            }
+                        }
+                        mobileDataDeclarationNc.setTerminalId(declarationNcPayload.getTerminalId());
+                        mobileDataDeclarationNc.setExternalKey(declarationNcPayload.getExternalKey());
+                        mobileDataDeclarationNc.setTraiter(false);
+                        mobileDataDeclarationNc.setDeclarationNcPayload(declarationNcPayload);
+                        mobileDataDeclarationNc = mobileDataDeclarationNcRepository.save(mobileDataDeclarationNc);
+                        SyncResponse syncResponse = new SyncResponse();
+                        syncResponse.setObservation("Synchronisation effectuée avec succès pour " + TypeObjet.DECLARATIONNC.toString());
+                        syncResponse.setExternalKey(declarationNcPayload.getExternalKey());
+                        syncResponse.setSynchronise(true);
+                        syncResponse.setIdBackend(mobileDataDeclarationNc.getId());
+                        syncResponses.add(syncResponse);
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                        SyncResponse syncResponse = new SyncResponse();
+                        syncResponse.setObservation("Synchronisation échouée pour " + TypeObjet.DECLARATIONNC.toString());
+                        syncResponse.setExternalKey(declarationNcPayload.getExternalKey());
+                        syncResponse.setSynchronise(false);
+                        syncResponse.setIdBackend(declarationNcPayload.getIdBackend());
+                        syncResponses.add(syncResponse);
+                    }
+                });
+            }
         }
         return syncResponses;
     }

src/main/java/io/gmss/fiscad/interfaces/synchronisation/SynchronisationService.java

@@ -44,6 +44,8 @@ public interface SynchronisationService {
     public List<SyncResponse> syncPiece(List<PiecePayLoad> piecePayLoads);
 
     public List<SyncResponse> syncActeurConcerne(List<ActeurConcernePayLoad> acteurConcernePayLoads);
+    public List<SyncResponse> syncEnqueteActivite(List<EnqueteActivitePayload> enqueteActivitePayloads);
+    public List<SyncResponse> syncDeclarationNc(List<DeclarationNcPayload> declarationNcPayloads);
 
     public SyncResponse syncFiles(MultipartFile file,
                                   Long idBackend,

src/main/java/io/gmss/fiscad/paylaods/request/DeclarationNcPayload.java

@@ -0,0 +1,29 @@
+package io.gmss.fiscad.paylaods.request;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import io.gmss.fiscad.deserializer.LocalDateDeserializer;
+import io.gmss.fiscad.entities.infocad.metier.Enquete;
+import io.gmss.fiscad.entities.infocad.metier.Tpe;
+import io.gmss.fiscad.entities.infocad.parametre.Structure;
+import io.gmss.fiscad.enums.StatutEnregistrement;
+import jakarta.persistence.*;
+import lombok.Data;
+
+import java.time.LocalDate;
+
+@Data
+public class DeclarationNcPayload {
+    private Long idBackend;
+    private Long externalKey;
+    private Long terminalId;
+    private boolean synchronise;
+    private String observation;
+    private LocalDate dateDerniereDeclaration;
+    private String nc;
+    private Long structureId;
+    private Long enqueteId;
+    private Long personneId;
+    private Long userId;
+}

src/main/java/io/gmss/fiscad/paylaods/request/EnqueteActivitePayload.java

@@ -0,0 +1,44 @@
+package io.gmss.fiscad.paylaods.request;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import io.gmss.fiscad.deserializer.LocalDateDeserializer;
+import io.gmss.fiscad.entities.infocad.metier.Enquete;
+import io.gmss.fiscad.entities.infocad.metier.Parcelle;
+import io.gmss.fiscad.entities.infocad.metier.Tpe;
+import io.gmss.fiscad.entities.infocad.parametre.Personne;
+import io.gmss.fiscad.entities.infocad.parametre.Profession;
+import io.gmss.fiscad.entities.infocad.parametre.Structure;
+import io.gmss.fiscad.entities.rfu.metier.Batiment;
+import io.gmss.fiscad.entities.rfu.metier.UniteLogement;
+import jakarta.persistence.Column;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToOne;
+import lombok.Data;
+
+import java.time.LocalDate;
+
+@Data
+public class EnqueteActivitePayload {
+    private Long idBackend;
+    private Long externalKey;
+    private Long terminalId;
+    private Long ChiffreAffaire;
+    private String NumeroRccm;
+    private boolean synchronise;
+    private String observation;
+    private LocalDate dateDemarrage;
+    private LocalDate dateFin;
+    private LocalDate dateEnquete;
+    private boolean estDeclarer;
+    private String nc;
+    private Long enqueteId;
+    private Long structureId;
+    private Long personneId;
+    private Long batimentId;
+    private Long parcelleId;
+    private Long uniteLogementId;
+    private Long professionId;
+    private Long userId;
+}

src/main/java/io/gmss/fiscad/paylaods/request/PersonnePayLoad.java

@@ -1,5 +1,6 @@
 package io.gmss.fiscad.paylaods.request;
 
+import io.gmss.fiscad.entities.infocad.parametre.Personne;
 import io.gmss.fiscad.enums.Categorie;
 import jakarta.persistence.EnumType;
 import jakarta.persistence.Enumerated;
@@ -31,6 +32,7 @@ public class PersonnePayLoad {
     private String observation;
     private boolean synchronise;
     private Long terminalId;
+    private Long personneId;
 
     /////////////////////////////
     @ColumnDefault("0")
@@ -50,7 +52,7 @@ public class PersonnePayLoad {
 
     @Override
     public String toString() {
-        return "PersonnePayLoad{" +
+        return "PersonnePayLoad{ " +
                 "idBackend=" + idBackend +
                 ", ifu='" + ifu + '\'' +
                 ", externalKey=" + externalKey +

src/main/java/io/gmss/fiscad/repositories/metadata/MobileDataDeclarationNcRepository.java

@@ -0,0 +1,15 @@
+package io.gmss.fiscad.repositories.metadata;
+
+import io.gmss.fiscad.entities.metadata.MobileDataDeclarationNc;
+import io.gmss.fiscad.entities.rfu.metier.DeclarationNc;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface MobileDataDeclarationNcRepository extends JpaRepository<MobileDataDeclarationNc, Long> {
+    //Optional<MobileDataEnquete> findByEnquetePayLoad_TerminalIdAndEnquetePayLoad_ExternalKey(Long terminalId,Long externalKey);
+    Optional<MobileDataDeclarationNc> findFirstByTerminalIdAndExternalKey(Long terminalId,Long ExternalKey);
+
+    List<MobileDataDeclarationNc> findAllByTraiterIsFalseAndTerminalId(Long TerminalId);
+}

src/main/java/io/gmss/fiscad/repositories/metadata/MobileDataEnqueteActiviteRepository.java

@@ -0,0 +1,12 @@
+package io.gmss.fiscad.repositories.metadata;
+
+import io.gmss.fiscad.entities.metadata.MobileDataEnqueteActivite;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface MobileDataEnqueteActiviteRepository extends JpaRepository<MobileDataEnqueteActivite, Long> {
+    Optional<MobileDataEnqueteActivite> findFirstByTerminalIdAndExternalKey(Long terminalId,Long ExternalKey);
+    List<MobileDataEnqueteActivite> findAllByTraiterIsFalseAndTerminalId(Long TerminalId);
+}

src/main/java/io/gmss/fiscad/repositories/rfu/metier/EnqueteActiviteRepository.java

@@ -11,10 +11,10 @@ import java.util.Optional;
 
 
 public interface EnqueteActiviteRepository extends JpaRepository<EnqueteActivite, Long> {
-    Optional<EnqueteBatiment> findByMobileDataId(Long id);
+    Optional<EnqueteActivite> findByMobileDataId(Long id);
-    Optional<EnqueteBatiment> findFirstByExternalKeyAndTerminal_Id(Long externalKey, Long TerminalId);
+    Optional<EnqueteActivite> findFirstByExternalKeyAndTerminal_Id(Long externalKey, Long TerminalId);
 
-    List<EnqueteBatiment> findAllByEnquete_Id(Long enqueteId);
+    List<EnqueteActivite> findAllByEnquete_Id(Long enqueteId);
 
     void deleteAllByEnquete_Id(Long idEnquete);
 }

src/main/java/io/gmss/fiscad/service/worker/DeclarationNcAsyncWorker.java

@@ -0,0 +1,142 @@
+package io.gmss.fiscad.service.worker;
+
+import io.gmss.fiscad.entities.infocad.metier.Enquete;
+import io.gmss.fiscad.entities.infocad.metier.Tpe;
+import io.gmss.fiscad.entities.infocad.parametre.Personne;
+import io.gmss.fiscad.entities.infocad.parametre.Structure;
+import io.gmss.fiscad.entities.metadata.MobileDataDeclarationNc;
+import io.gmss.fiscad.entities.rfu.metier.Batiment;
+import io.gmss.fiscad.entities.rfu.metier.DeclarationNc;
+import io.gmss.fiscad.entities.user.User;
+import io.gmss.fiscad.enums.TypeObjet;
+import io.gmss.fiscad.paylaods.request.DeclarationNcPayload;
+import io.gmss.fiscad.repositories.infocad.metier.EnqueteRepository;
+import io.gmss.fiscad.repositories.infocad.metier.TpeRepository;
+import io.gmss.fiscad.repositories.infocad.parametre.PersonneRepository;
+import io.gmss.fiscad.repositories.infocad.parametre.StructureRepository;
+import io.gmss.fiscad.repositories.metadata.MobileDataDeclarationNcRepository;
+import io.gmss.fiscad.repositories.rfu.metier.BatimentRepository;
+import io.gmss.fiscad.repositories.rfu.metier.DeclarationNcRepository;
+import io.gmss.fiscad.repositories.user.UserRepository;
+import io.gmss.fiscad.service.LogService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+public class DeclarationNcAsyncWorker {
+    private final TpeRepository tpeRepository;
+    private final MobileDataDeclarationNcRepository mobileDataDeclarationNcRepository;
+    private final EnqueteRepository enqueteRepository;
+    private final DeclarationNcRepository declarationNcRepository;
+    private final UserRepository userRepository;
+    private final PersonneRepository personneRepository;
+    private final BatimentRepository batimentRepository;
+    private final StructureRepository structureRepository;
+    private final LogService logService;
+    //@Async("declarationNcExecutor")
+    public void traitementAsyncDeclarationNc(MobileDataDeclarationNc mobileDataDeclarationNc) {
+        DeclarationNcPayload declarationNcPayload = mobileDataDeclarationNc.getDeclarationNcPayload();
+
+        try {
+            if (declarationNcPayload.getTerminalId() == null) {
+                logService.logTraiementAsync(TypeObjet.DECLARATIONNC, "Problème de terminal", "terminal non fourni : ", mobileDataDeclarationNc.getId());
+                return;
+            } else {
+                Optional<Tpe> optionalTpe = tpeRepository.findById(declarationNcPayload.getTerminalId());
+                if (optionalTpe.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.DECLARATIONNC, "Problème de terminal", "terminal inexistant : ", mobileDataDeclarationNc.getId());
+                    return;
+                }
+            }
+
+            if (declarationNcPayload.getEnqueteId() == null) {
+                logService.logTraiementAsync(TypeObjet.DECLARATIONNC, "Problème de enquete", "enquete non fourni : ", mobileDataDeclarationNc.getId());
+                return;
+            } else {
+                Optional<Enquete> optionalEnquete = enqueteRepository.findFirstByExternalKeyAndTerminal_Id(declarationNcPayload.getEnqueteId(), declarationNcPayload.getTerminalId());
+                if (optionalEnquete.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.DECLARATIONNC, "Problème de enquete", "L'enquete précisée n'existe pas : ", mobileDataDeclarationNc.getId());
+                    return;
+                }
+            }
+
+
+            if (declarationNcPayload.getPersonneId() == null) {
+                logService.logTraiementAsync(TypeObjet.DECLARATIONNC, "Problème de contribuable", "Contribuable non fourni : ", mobileDataDeclarationNc.getId());
+                return;
+            } else {
+                Optional<Personne> optionalPersonne = personneRepository.findFirstByExternalKeyAndTerminal_Id(declarationNcPayload.getPersonneId(), declarationNcPayload.getTerminalId());
+                if (optionalPersonne.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.DECLARATIONNC, "Problème de contribuable", "Le contribuable précisé n'existe pas : ", mobileDataDeclarationNc.getId());
+                    return;
+                }
+            }
+
+
+
+            if (declarationNcPayload.getStructureId() == null) {
+                logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de centre d'impôts", "centre d'impôt non fourni : ", mobileDataDeclarationNc.getId());
+                return;
+            } else {
+                Optional<Structure> optionalStructure = structureRepository.findById(declarationNcPayload.getStructureId());
+                if (optionalStructure.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de centre d'impôts", "Le centre d'impôt précisé n'existe pas : ", mobileDataDeclarationNc.getId());
+
+                }
+            }
+
+            DeclarationNc declarationNc = new DeclarationNc();
+            Optional<DeclarationNc> optionalDeclarationNc= Optional.empty();
+            optionalDeclarationNc = declarationNcRepository.findByMobileDataId(mobileDataDeclarationNc.getId());
+            if (optionalDeclarationNc.isPresent()) {
+                declarationNc = optionalDeclarationNc.get();
+            }else {
+                optionalDeclarationNc = declarationNcRepository.findFirstByExternalKeyAndTerminal_Id(declarationNcPayload.getExternalKey(),declarationNcPayload.getTerminalId());
+                if (optionalDeclarationNc.isPresent()) {
+                    declarationNc = optionalDeclarationNc.get();
+                }
+            }
+            declarationNc.setMobileDataId(mobileDataDeclarationNc.getId());
+            declarationNc = getDeclarationNcFromDeclarationNcPayLoad(declarationNc, declarationNcPayload);
+            declarationNcRepository.save(declarationNc);
+            mobileDataDeclarationNc.setTraiter(true);
+            mobileDataDeclarationNcRepository.save(mobileDataDeclarationNc);
+        } catch (Exception e) {
+            logService.logTraiementAsync(TypeObjet.DECLARATIONNC, "Problème de inattendu", e.getMessage(), mobileDataDeclarationNc.getId());
+        }
+    }
+
+
+    private DeclarationNc getDeclarationNcFromDeclarationNcPayLoad(DeclarationNc declarationNc, DeclarationNcPayload declarationNcPayload) {
+        declarationNc.setDateDerniereDeclaration(declarationNcPayload.getDateDerniereDeclaration());
+        declarationNc.setNc(declarationNcPayload.getNc());
+        declarationNc.setExternalKey(declarationNcPayload.getExternalKey());
+        declarationNc.setEnqueteExternalKey(declarationNcPayload.getEnqueteId());
+        declarationNc.setPersonneExternalKey(declarationNcPayload.getPersonneId());
+        declarationNc.setEnqueteExternalKey(declarationNcPayload.getEnqueteId());
+
+        if (declarationNcPayload.getPersonneId() != null) {
+            Optional<Personne> optionalPersonne = personneRepository.findFirstByExternalKeyAndTerminal_Id(declarationNcPayload.getPersonneId(), declarationNcPayload.getTerminalId());
+            declarationNc.setPersonne(optionalPersonne.orElse(null));
+        }
+
+        if (declarationNcPayload.getEnqueteId() != null) {
+            Optional<Enquete> optionalEnquete = enqueteRepository.findFirstByExternalKeyAndTerminal_Id(declarationNcPayload.getEnqueteId(), declarationNcPayload.getTerminalId());
+            declarationNc.setEnquete(optionalEnquete.orElse(null));
+        }
+        if (declarationNcPayload.getTerminalId() != null) {
+            Optional<Tpe> optionalTpe = tpeRepository.findById(declarationNcPayload.getTerminalId());
+            declarationNc.setTerminal(optionalTpe.orElse(null));
+        }
+
+        if (declarationNcPayload.getStructureId()!= null) {
+            Optional<Structure> optionalStructure = structureRepository.findById(declarationNcPayload.getStructureId());
+            declarationNc.setStructure(optionalStructure.orElse(null));
+        }
+
+        return declarationNc;
+    }
+}

src/main/java/io/gmss/fiscad/service/worker/EnqueteActiviteAsyncWorker.java

@@ -0,0 +1,216 @@
+package io.gmss.fiscad.service.worker;
+
+import io.gmss.fiscad.entities.infocad.metier.Enquete;
+import io.gmss.fiscad.entities.infocad.metier.Parcelle;
+import io.gmss.fiscad.entities.infocad.metier.Tpe;
+import io.gmss.fiscad.entities.infocad.parametre.Personne;
+import io.gmss.fiscad.entities.infocad.parametre.Profession;
+import io.gmss.fiscad.entities.infocad.parametre.Profession;
+import io.gmss.fiscad.entities.infocad.parametre.Structure;
+import io.gmss.fiscad.entities.metadata.MobileDataEnqueteActivite;
+import io.gmss.fiscad.entities.rfu.metier.Batiment;
+import io.gmss.fiscad.entities.rfu.metier.EnqueteActivite;
+import io.gmss.fiscad.entities.rfu.metier.UniteLogement;
+import io.gmss.fiscad.entities.user.User;
+import io.gmss.fiscad.enums.TypeObjet;
+import io.gmss.fiscad.paylaods.request.EnqueteActivitePayload;
+import io.gmss.fiscad.repositories.infocad.metier.EnqueteRepository;
+import io.gmss.fiscad.repositories.infocad.metier.ParcelleRepository;
+import io.gmss.fiscad.repositories.infocad.metier.TpeRepository;
+import io.gmss.fiscad.repositories.infocad.parametre.PersonneRepository;
+import io.gmss.fiscad.repositories.infocad.parametre.ProfessionRepository;
+import io.gmss.fiscad.repositories.infocad.parametre.StructureRepository;
+import io.gmss.fiscad.repositories.metadata.MobileDataEnqueteActiviteRepository;
+import io.gmss.fiscad.repositories.rfu.metier.BatimentRepository;
+import io.gmss.fiscad.repositories.rfu.metier.EnqueteActiviteRepository;
+import io.gmss.fiscad.repositories.rfu.metier.UniteLogementRepository;
+import io.gmss.fiscad.repositories.user.UserRepository;
+import io.gmss.fiscad.service.LogService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+public class EnqueteActiviteAsyncWorker {
+    private final TpeRepository tpeRepository;
+    private final MobileDataEnqueteActiviteRepository mobileDataEnqueteActiviteRepository;
+    private final EnqueteRepository enqueteRepository;
+    private final EnqueteActiviteRepository enqueteActiviteRepository;
+    private final UserRepository userRepository;
+    private final ProfessionRepository professionRepository;
+    private final StructureRepository structureRepository;
+    private final ParcelleRepository parcelleRepository;
+    private final BatimentRepository batimentRepository;
+    private final UniteLogementRepository uniteLogementRepository;
+    private final PersonneRepository personneRepository;
+    private final LogService logService;
+    //@Async("enqueteActiviteExecutor")
+    public void traitementAsyncEnqueteActivite(MobileDataEnqueteActivite mobileDataEnqueteActivite) {
+        EnqueteActivitePayload enqueteActivitePayload = mobileDataEnqueteActivite.getEnqueteActivitePayload();
+
+        try {
+            if (enqueteActivitePayload.getTerminalId() == null) {
+                logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de terminal", "terminal non fourni : ", mobileDataEnqueteActivite.getId());
+                return;
+            } else {
+                Optional<Tpe> optionalTpe = tpeRepository.findById(enqueteActivitePayload.getTerminalId());
+                if (optionalTpe.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de terminal", "terminal inexistant : ", mobileDataEnqueteActivite.getId());
+                    return;
+                }
+            }
+
+            if (enqueteActivitePayload.getEnqueteId() == null) {
+                logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de enquete", "enquete non fourni : ", mobileDataEnqueteActivite.getId());
+                return;
+            } else {
+                Optional<Enquete> optionalEnquete = enqueteRepository.findFirstByExternalKeyAndTerminal_Id(enqueteActivitePayload.getEnqueteId(), enqueteActivitePayload.getTerminalId());
+                if (optionalEnquete.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de profession", "L'enquete précisée n'existe pas : ", mobileDataEnqueteActivite.getId());
+                    return;
+                }
+            }
+
+
+            if (enqueteActivitePayload.getProfessionId() == null) {
+                logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de profession", "profession non fourni : ", mobileDataEnqueteActivite.getId());
+                return;
+            } else {
+                Optional<Profession> optionalProfession = professionRepository.findById(enqueteActivitePayload.getProfessionId());
+                if (optionalProfession.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de profession", "Le profession précisée n'existe pas : ", mobileDataEnqueteActivite.getId());
+                    return;
+                }
+            }
+
+            if (enqueteActivitePayload.getStructureId() == null) {
+                logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de centre d'impôts", "centre d'impôt non fourni : ", mobileDataEnqueteActivite.getId());
+                return;
+            } else {
+                Optional<Structure> optionalStructure = structureRepository.findById(enqueteActivitePayload.getStructureId());
+                if (optionalStructure.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de centre d'impôts", "Le centre d'impôt précisé n'existe pas : ", mobileDataEnqueteActivite.getId());
+                    return;
+                }
+            }
+
+            if  (enqueteActivitePayload.getParcelleId() == null) {
+                logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de Parcelle", "parcelle non fournie : ", mobileDataEnqueteActivite.getId());
+                return;
+            } else {
+                Optional<Parcelle> optionalParcelle = parcelleRepository.findById(enqueteActivitePayload.getParcelleId());
+                if (optionalParcelle.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de Parcelle", "La parcelle précisée n'existe pas : ", mobileDataEnqueteActivite.getId());
+                    return;
+                }
+            }
+
+            if  (enqueteActivitePayload.getPersonneId() == null) {
+                logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de Parcelle", "parcelle non fournie : ", mobileDataEnqueteActivite.getId());
+                return;
+            } else {
+                Optional<Personne> optionalPersonne = personneRepository.findById(enqueteActivitePayload.getPersonneId());
+                if (optionalPersonne.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de Constribuable", "La contribuable précisé n'existe pas : ", mobileDataEnqueteActivite.getId());
+                    return;
+                }
+            }
+
+            if (enqueteActivitePayload.getBatimentId() != null) {
+                Optional<Batiment> optionalBatiment = batimentRepository.findById(enqueteActivitePayload.getBatimentId());
+                if (optionalBatiment.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de Contribuable", "Le contribuable précisé n'existe pas : ", mobileDataEnqueteActivite.getId());
+                    return ;
+                }
+            }
+
+            if (enqueteActivitePayload.getUniteLogementId() != null) {
+                Optional<UniteLogement> optionalUniteLogement = uniteLogementRepository.findById(enqueteActivitePayload.getUniteLogementId());
+                if (optionalUniteLogement.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de Unité de logement", "L'unité de logement précisée n'existe pas : ", mobileDataEnqueteActivite.getId());
+                    return;
+                }
+            }
+
+
+            EnqueteActivite enqueteActivite = new EnqueteActivite();
+            Optional<EnqueteActivite> optionalEnqueteActivite= Optional.empty();
+            optionalEnqueteActivite = enqueteActiviteRepository.findByMobileDataId(mobileDataEnqueteActivite.getId());
+            if (optionalEnqueteActivite.isPresent()) {
+                enqueteActivite = optionalEnqueteActivite.get();
+            }else {
+                optionalEnqueteActivite = enqueteActiviteRepository.findFirstByExternalKeyAndTerminal_Id(enqueteActivitePayload.getExternalKey(),enqueteActivitePayload.getTerminalId());
+                if (optionalEnqueteActivite.isPresent()) {
+                    enqueteActivite = optionalEnqueteActivite.get();
+                }
+            }
+            enqueteActivite.setMobileDataId(mobileDataEnqueteActivite.getId());
+            enqueteActivite = getEnqueteActiviteFromEnqueteActivitePayLoad(enqueteActivite, enqueteActivitePayload);
+            enqueteActiviteRepository.save(enqueteActivite);
+            mobileDataEnqueteActivite.setTraiter(true);
+            mobileDataEnqueteActiviteRepository.save(mobileDataEnqueteActivite);
+        } catch (Exception e) {
+            logService.logTraiementAsync(TypeObjet.ENQUETEACTIVITE, "Problème de inattendu", e.getMessage(), mobileDataEnqueteActivite.getId());
+        }
+    }
+
+
+    private EnqueteActivite getEnqueteActiviteFromEnqueteActivitePayLoad(EnqueteActivite enqueteActivite, EnqueteActivitePayload enqueteActivitePayload) {
+        enqueteActivite.setDateEnquete(enqueteActivitePayload.getDateEnquete());
+        enqueteActivite.setNc(enqueteActivitePayload.getNc());
+        enqueteActivite.setExternalKey(enqueteActivitePayload.getExternalKey());
+        enqueteActivite.setEnqueteExternalKey(enqueteActivitePayload.getEnqueteId());
+        enqueteActivite.setChiffreAffaire(enqueteActivitePayload.getChiffreAffaire());
+        enqueteActivite.setDateDemarrage(enqueteActivitePayload.getDateDemarrage());
+        enqueteActivite.setDateFin(enqueteActivitePayload.getDateFin());
+        enqueteActivite.setNumeroRccm(enqueteActivitePayload.getNumeroRccm());
+        enqueteActivite.setEstDeclarer(enqueteActivitePayload.isEstDeclarer());
+        enqueteActivite.setPersonneExternalKey(enqueteActivitePayload.getPersonneId());
+        enqueteActivite.setParcelleExternalKey(enqueteActivitePayload.getParcelleId());
+        enqueteActivite.setBatimentExternalKey(enqueteActivitePayload.getBatimentId());
+        enqueteActivite.setUniteLogementExternalKey(enqueteActivitePayload.getUniteLogementId());
+
+        if (enqueteActivitePayload.getProfessionId() != null) {
+            Optional<Profession> optionalProfession = professionRepository.findById(enqueteActivitePayload.getProfessionId());
+            enqueteActivite.setProfession(optionalProfession.orElse(null));
+        }
+
+        if (enqueteActivitePayload.getStructureId() != null) {
+            Optional<Structure> optionalStructure = structureRepository.findById(enqueteActivitePayload.getStructureId());
+            enqueteActivite.setStructure(optionalStructure.orElse(null));
+        }
+
+        if (enqueteActivitePayload.getEnqueteId() != null) {
+            Optional<Enquete> optionalEnquete = enqueteRepository.findFirstByExternalKeyAndTerminal_Id(enqueteActivitePayload.getEnqueteId(), enqueteActivitePayload.getTerminalId());
+            enqueteActivite.setEnquete(optionalEnquete.orElse(null));
+        }
+        if (enqueteActivitePayload.getTerminalId() != null) {
+            Optional<Tpe> optionalTpe = tpeRepository.findById(enqueteActivitePayload.getTerminalId());
+            enqueteActivite.setTerminal(optionalTpe.orElse(null));
+        }
+
+        if (enqueteActivitePayload.getPersonneId() != null) {
+            Optional<Personne> optionalPersonne = personneRepository.findFirstByExternalKeyAndTerminal_Id(enqueteActivitePayload.getPersonneId(), enqueteActivitePayload.getTerminalId());
+            enqueteActivite.setPersonne(optionalPersonne.orElse(null));
+        }
+
+        if (enqueteActivitePayload.getParcelleId() != null) {
+            Optional<Parcelle> optionalParcelle = parcelleRepository.findFirstByExternalKeyAndTerminal_Id(enqueteActivitePayload.getParcelleId(), enqueteActivitePayload.getTerminalId());
+            enqueteActivite.setParcelle(optionalParcelle.orElse(null));
+        }
+
+        if (enqueteActivitePayload.getBatimentId() != null) {
+            Optional<Batiment> optionalBatiment = batimentRepository.findFirstByExternalKeyAndTerminal_Id(enqueteActivitePayload.getBatimentId(), enqueteActivitePayload.getTerminalId());
+            enqueteActivite.setBatiment(optionalBatiment.orElse(null));
+        }
+
+        if (enqueteActivitePayload.getUniteLogementId() != null) {
+            Optional<UniteLogement> optionalUniteLogement = uniteLogementRepository.findFirstByExternalKeyAndTerminal_Id(enqueteActivitePayload.getUniteLogementId(), enqueteActivitePayload.getTerminalId());
+            enqueteActivite.setUniteLogement(optionalUniteLogement.orElse(null));
+        }
+
+        return enqueteActivite;
+    }
+}

src/main/java/io/gmss/fiscad/service/worker/EnqueteAsyncWorker.java

@@ -47,6 +47,7 @@ public class EnqueteAsyncWorker {
     private final CaracteristiqueUniteLogementRepository caracteristiqueUniteLogementRepository;
     private final UniteLogementRepository uniteLogementRepository;
     private final BatimentRepository batimentRepository;
+    private final PersonneRepository personneRepository;
     private final LogService logService;
     //@Async("enqueteExecutor")
     public void traitementAsyncEnquete(MobileDataEnquete mobileDataEnquete) {
@@ -62,6 +63,7 @@ public class EnqueteAsyncWorker {
                     return;
                 }
             }
+
             deleteFromCodeParcelle(enquetePayLoad.getCodeParcelle());
 
             if (enquetePayLoad.getUserId() == null) {
@@ -75,6 +77,18 @@ public class EnqueteAsyncWorker {
                 }
             }
 
+
+            if (enquetePayLoad.getPersonneId() == null) {
+                logService.logTraiementAsync(TypeObjet.ENQUETE, "Problème de contribuable", "Le contribuable n'est pas précisée: ", mobileDataEnquete.getId());
+                return;
+            } else {
+                Optional<Personne> optionalPersonne = personneRepository.findById(enquetePayLoad.getPersonneId());
+                if (optionalPersonne.isEmpty()) {
+                    logService.logTraiementAsync(TypeObjet.ENQUETE, "Problème de contribuable", "Le contribuable  précisé n'existe pas : ", mobileDataEnquete.getId());
+                    return;
+                }
+            }
+
             if (enquetePayLoad.getZoneRfuId() != null)  {
                 Optional<ZoneRfu> optionalZoneRfu = zoneRfuRepository.findById(enquetePayLoad.getZoneRfuId());
                 if (optionalZoneRfu.isEmpty()) {
@@ -125,7 +139,6 @@ public class EnqueteAsyncWorker {
     }
 
     private Enquete getEnqueteFromEnquetePayLoad(Enquete enquete, EnquetePayLoad enquetePayLoad) {
-
         if (enquetePayLoad.getUserId() != null) {
             Optional<User> optionalUser = userRepository.findById(enquetePayLoad.getUserId());
             enquete.setUser(optionalUser.orElse(null));
@@ -135,16 +148,22 @@ public class EnqueteAsyncWorker {
             enquete.setZoneRfu(optionalZoneRfu.orElse(null));
         }
 
+        //TODO recherche de parcelle à revoir
         if (enquetePayLoad.getParcelleId() != null) {
             Optional<Parcelle> optionalParcelle = parcelleRepository.findFirstByNupProvisoire(enquetePayLoad.getCodeParcelle());
-            //Optional<Parcelle> optionalParcelle = parcelleRepository.findFirstByExternalKeyAndTerminal_Id(enquetePayLoad.getParcelleId(), enquetePayLoad.getTerminalId());
             enquete.setParcelle(optionalParcelle.orElse(null));
         }
+
         if (enquetePayLoad.getBlocId() != null) {
             Optional<Bloc> optionalBloc = blocRepository.findById(enquetePayLoad.getBlocId());
             enquete.setBloc(optionalBloc.orElse(null));
         }
 
+        if (enquetePayLoad.getPersonneId() != null) {
+            Optional<Personne> optionalPersonne = personneRepository.findFirstByExternalKeyAndTerminal_Id(enquetePayLoad.getPersonneId(),enquetePayLoad.getTerminalId());
+            enquete.setPersonne(optionalPersonne.orElse(null));
+        }
+
         if (enquetePayLoad.getTerminalId() != null) {
             Optional<Tpe> optionalTpe = tpeRepository.findById(enquetePayLoad.getTerminalId());
             enquete.setTerminal(optionalTpe.orElse(null));

src/main/resources/application-dgi.properties

@@ -1,5 +1,6 @@
 server.port=8282
-io.gmss.fiscad.profile=DGI
+#io.gmss.fiscad.profile=${IO_GMSS_FISCAD_PROFILE}
+io.gmss.fiscad.profile=dgi
 # TEST ENV
 #spring.datasource.url=jdbc:postgresql://vmi792116.contaboserver.net:5599/dgi_db
 #spring.datasource.username=infocad_user
@@ -8,3 +9,8 @@ io.gmss.fiscad.profile=DGI
 spring.datasource.url=jdbc:postgresql://localhost:5432/fiscad_dgi
 spring.datasource.username=infocad_user
 spring.datasource.password=W5fwD({9*q53
+
+# PROD ENV
+#spring.datasource.url=${SPRING_DATASOURCE_URL}
+#spring.datasource.username=${SPRING_DATASOURCE_USERNAME}
+#spring.datasource.password=${SPRING_DATASOURCE_PASSWORD}

src/main/resources/application.properties

@@ -1,5 +1,6 @@
-spring.profiles.active=${SPRING_PROFILES_ACTIVE}
+#spring.profiles.active=${SPRING_PROFILES_ACTIVE}
 #spring.profiles.active=abomey
+spring.profiles.active=dgi
 spring.jpa.properties.hibernate.id.new_generator_mappings=false
 spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true
 spring.jpa.open-in-view=false