Merge branch 'anas' into 'master'

Anas

See merge request !1

src/main/java/bmci/esign/backendend/BackendEsignApplication.java

 package bmci.esign.backendend;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
-import com.fasterxml.jackson.databind.util.StdDateFormat;
 import org.modelmapper.ModelMapper;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.context.annotation.Bean;
 
-import javax.annotation.PostConstruct;
-import java.util.TimeZone;
-
 @SpringBootApplication
 public class BackendEsignApplication {
     @Bean
@@ -18,7 +12,6 @@ public class BackendEsignApplication {
         return new ModelMapper();
     }
 
-
     public static void main(String[] args) {
         SpringApplication.run(BackendEsignApplication.class, args);
     }

src/main/java/bmci/esign/backendend/controllers/AuthorityController.java

 package bmci.esign.backendend.controllers;
 
-
 import bmci.esign.backendend.dto.AuthorityDto;
+import bmci.esign.backendend.models.Authority;
 import bmci.esign.backendend.models.ResponseModelStandard;
 import bmci.esign.backendend.services.AuthorityService;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
 
@@ -22,6 +20,14 @@ public class AuthorityController {
     public ResponseModelStandard<List<AuthorityDto>> getAll(){
         return new ResponseModelStandard<>("000", authorityService.getAll());
     }
-
+    @PostMapping("/create")
+    public ResponseModelStandard<Authority> createAuthority(@RequestBody Authority authority) {
+        try {
+             Authority response= authorityService.addAuthority(authority);
+             return new ResponseModelStandard<>("000", response);
+        }catch (Exception e){
+             return new ResponseModelStandard<>("099");
+         }
+    }
 
 }

src/main/java/bmci/esign/backendend/controllers/DemandeController.java

@@ -2,19 +2,23 @@ package bmci.esign.backendend.controllers;
 
 
 import bmci.esign.backendend.dto.DemandeDto;
+import bmci.esign.backendend.dto.request.FilterDto;
+import bmci.esign.backendend.dto.response.DashboardChart;
 import bmci.esign.backendend.models.ResponseModelStandard;
 import bmci.esign.backendend.models.enums.EStatut;
 import bmci.esign.backendend.services.DemandeService;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
 import org.springframework.format.annotation.DateTimeFormat;
 import org.springframework.web.bind.annotation.*;
-
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 
 @RestController
 @RequestMapping("/demande")
+@Slf4j
 public class DemandeController {
 
         @Autowired
@@ -22,12 +26,12 @@ public class DemandeController {
 
         @PostMapping("/add")
         public ResponseModelStandard<Long> addDemande(@RequestBody DemandeDto demandeDto){
-                System.out.println("ggg");
-                System.out.println("ggg");
+                log.info("NEW°DM.... {}",demandeDto.getTypeDocument());
                 try {
                         demandeService.addDemande(demandeDto);
                         return new ResponseModelStandard<>("000");
                 }catch (Exception e){
+                        log.error("EXCEPTION_addDemande Message: {}",e.getMessage(),e);
                         return new ResponseModelStandard<>("099");
                 }
         }
@@ -97,5 +101,26 @@ public class DemandeController {
                 }
         }
 
+    @PostMapping("/signatures")
+    public ResponseModelStandard<Page<DemandeDto>> getDemandesByUser(@RequestBody FilterDto filterDto){
+        try {
+            Page<DemandeDto> demandeDtoList = demandeService.findDemandesByUser(filterDto);
+            return new ResponseModelStandard<>("000",demandeDtoList);
+        }catch (Exception e){
+            return new ResponseModelStandard<>("099");
+        }
+    }
 
+    @GetMapping("/chart")
+    public ResponseModelStandard<List<DashboardChart>> chartSignDemandes(@RequestParam(name = "email") String email){
+         try {
+                 List<DashboardChart> dashboardCharts =demandeService.loadReceivedChart(email);
+                 if(dashboardCharts == null){
+                         return new ResponseModelStandard<>("099","Missing data");
+                 }
+                 return new ResponseModelStandard<>("000", dashboardCharts);
+         }catch (Exception e){
+                 return new ResponseModelStandard<>("099");
+         }
+    }
 }

src/main/java/bmci/esign/backendend/controllers/DestinataireController.java

 package bmci.esign.backendend.controllers;
 
-
+import bmci.esign.backendend.dto.DemandeDto;
 import bmci.esign.backendend.dto.DestinataireDto;
+import bmci.esign.backendend.dto.request.FilterDto;
+import bmci.esign.backendend.dto.response.DashboardChart;
 import bmci.esign.backendend.models.ResponseModelStandard;
 import bmci.esign.backendend.services.DestinataireService;
-import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
@@ -12,10 +14,11 @@ import java.util.List;
 @RestController
 @RequestMapping("/destinataire")
 public class DestinataireController {
+    private final DestinataireService destinataireService;
 
-    @Autowired
-    private DestinataireService destinataireService;
-
+    public DestinataireController(DestinataireService destinataireService) {
+        this.destinataireService = destinataireService;
+    }
 
     @PostMapping("/addAll")
     public ResponseModelStandard<Long> addAllDestinataire(@RequestBody List<DestinataireDto> destinataireDtos){
@@ -35,11 +38,26 @@ public class DestinataireController {
         return new ResponseModelStandard<>("000", destinataireDtos);
     }
 
+    @PostMapping("/signer")
+    public ResponseModelStandard<Page<DemandeDto>> getDemandesToSign(@RequestBody FilterDto destinataireFilterDto){
+        try {
+            Page<DemandeDto> demandeDtoList = destinataireService.findAllDemandesToSigne(destinataireFilterDto);
+            return new ResponseModelStandard<>("000",demandeDtoList);
+        }catch (Exception e){
+            return new ResponseModelStandard<>("099");
+        }
+    }
 
-
-
-
-
-
-
+    @GetMapping("/chart")
+    public ResponseModelStandard<List<DashboardChart>> chartDMSign(@RequestParam(name = "email") String email){
+         try {
+                 List<DashboardChart> dashboardCharts =destinataireService.loadSignDmChart(email);
+                 if(dashboardCharts == null){
+                         return new ResponseModelStandard<>("099","Missing data");
+                 }
+                 return new ResponseModelStandard<>("000", dashboardCharts);
+         }catch (Exception e){
+                 return new ResponseModelStandard<>("099");
+         }
+    }
 }
\ No newline at end of file

src/main/java/bmci/esign/backendend/controllers/NotificationController.java

+package bmci.esign.backendend.controllers;
+
+import bmci.esign.backendend.dto.NotificationDto;
+import bmci.esign.backendend.dto.request.UserEmailRequest;
+import bmci.esign.backendend.models.Notification;
+import bmci.esign.backendend.models.ResponseModelStandard;
+import bmci.esign.backendend.models.enums.ENotification;
+import bmci.esign.backendend.services.NotificationService;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/notifications")
+public class NotificationController {
+    private final NotificationService notificationService;
+    public NotificationController(NotificationService notificationService) {
+        this.notificationService = notificationService;
+    }
+
+    @PostMapping("/create")
+    public ResponseModelStandard<Notification> createNotification(@RequestBody Notification notification) {
+        try {
+             Notification response= notificationService.createNotification(notification);
+             return new ResponseModelStandard<>("000", response);
+        }catch (Exception e){
+             return new ResponseModelStandard<>("099");
+         }
+    }
+
+    @PostMapping("/user/active")
+    public ResponseModelStandard<List<NotificationDto>> loadActiveNotificationsByUserEmail(@RequestBody UserEmailRequest userEmailRequest) {
+         try {
+             List<NotificationDto> notifications= notificationService.loadActiveNotificationsByUserEmail(userEmailRequest.getEmail());
+             return new ResponseModelStandard<>("000", notifications);
+         }catch (Exception e){
+             return new ResponseModelStandard<>("099");
+         }
+    }
+
+    @PostMapping("/update/status")
+    public ResponseModelStandard<NotificationDto> updateStatus(@RequestParam Long id) {
+         try {
+             notificationService.changeStatusByDmId(id, null,ENotification.VIEW);
+             return new ResponseModelStandard<>("000");
+         }catch (Exception e){
+             return new ResponseModelStandard<>("099");
+         }
+    }
+}

src/main/java/bmci/esign/backendend/controllers/TypeDocumentController.java

 package bmci.esign.backendend.controllers;
 
 import bmci.esign.backendend.dto.TypeDocumentDto;
+import bmci.esign.backendend.dto.request.TypeDocAddDto;
 import bmci.esign.backendend.models.ResponseModelStandard;
 import bmci.esign.backendend.services.TypeDocumentService;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
 
@@ -27,4 +26,13 @@ public class TypeDocumentController {
         }
     }
 
+    @PostMapping("/add")
+    public ResponseModelStandard<TypeDocumentDto> addTypeDocument(@RequestBody TypeDocAddDto type){
+        try {
+            TypeDocumentDto typeDocumentDtos =  typeDocumentService.addTypeDocument(type);
+            return new ResponseModelStandard<>("000", typeDocumentDtos);
+        }catch (Exception e){
+            return new ResponseModelStandard<>("099");
+        }
+    }
 }

src/main/java/bmci/esign/backendend/dto/DemandeDto.java

@@ -2,7 +2,6 @@ package bmci.esign.backendend.dto;
 
 import bmci.esign.backendend.models.TypeDocument;
 import bmci.esign.backendend.models.enums.EDemande;
-import bmci.esign.backendend.models.enums.EStatut;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.AllArgsConstructor;

src/main/java/bmci/esign/backendend/dto/DestinataireDto.java

 package bmci.esign.backendend.dto;
 
-import bmci.esign.backendend.models.Demande;
-import bmci.esign.backendend.models.Position;
-import bmci.esign.backendend.models.enums.EStatut;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
@@ -28,5 +26,5 @@ public class DestinataireDto {
     private Date creationDate;
     @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss.SSSZ")
     private Date modificationDate;
-    private List<PositionDto> positions;
+    private List<PositionDto> positions= new ArrayList<>();
 }

src/main/java/bmci/esign/backendend/dto/NotificationDto.java

+package bmci.esign.backendend.dto;
+
+import bmci.esign.backendend.models.enums.ENotification;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class NotificationDto {
+    private Long id;
+    private String title;
+    private String message;
+    private ENotification status;
+}

src/main/java/bmci/esign/backendend/dto/request/FilterDto.java

+package bmci.esign.backendend.dto.request;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Date;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class FilterDto {
+    private int page;
+    private int size;
+    private String email;
+    private Date createdDate;
+    private String demandeType;
+    private String priority;
+
+    @Override
+    public String toString() {
+        return "FilterDto{" +
+                "page=" + page +
+                ", size=" + size +
+                ", email='" + email + '\'' +
+                ", createdDate=" + createdDate +
+                ", demandeType='" + demandeType + '\'' +
+                ", priority='" + priority + '\'' +
+                '}';
+    }
+}
\ No newline at end of file

src/main/java/bmci/esign/backendend/dto/request/TypeDocAddDto.java

+package bmci.esign.backendend.dto.request;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Getter
+@Setter
+public class TypeDocAddDto {
+    String type;
+
+    @Override
+    public String toString() {
+        return "TypeDocAddDto{" +
+                "type='" + type + '\'' +
+                '}';
+    }
+}

src/main/java/bmci/esign/backendend/dto/request/UserEmailRequest.java

+package bmci.esign.backendend.dto.request;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class UserEmailRequest {
+     private String email;
+}

src/main/java/bmci/esign/backendend/dto/response/DashboardChart.java

+package bmci.esign.backendend.dto.response;
+
+public interface DashboardChart {
+    int getCount();
+    String getStatut();
+}

src/main/java/bmci/esign/backendend/dto/response/NotificationsResponse.java

+package bmci.esign.backendend.dto.response;
+
+public interface NotificationsResponse {
+    Long getId();
+    String getTitle();
+    String getMessage();
+    String getStatus();
+}

src/main/java/bmci/esign/backendend/dto/response/ResponseDto.java

+package bmci.esign.backendend.dto.response;
+
+import bmci.esign.backendend.dto.DestinataireDto;
+import bmci.esign.backendend.dto.DocumentDto;
+import bmci.esign.backendend.dto.UserDto;
+import bmci.esign.backendend.models.TypeDocument;
+import bmci.esign.backendend.models.enums.EDemande;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+@Getter
+@Setter
+@AllArgsConstructor
+public class ResponseDto implements Serializable {
+    private Long id;
+    private String confidentiality;
+    private String priority;
+    private String objetMail;
+    private String message;
+    private String statut;
+    private String edemande;
+    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
+    private UserDto user;
+    private TypeDocument typeDocument;
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private Date expirationDate;
+    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss.SSSZ")
+    private Date creationDate;
+    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss.SSSZ")
+    private Date modificationDate;
+    private List<DestinataireDto> destinataires;
+    private List<DocumentDto> documents;
+
+
+    public String getEDemande() {
+        return EDemande.valueOf(edemande).getDisplayName();
+    }
+
+    public String getStringDemand(){
+        return edemande;
+    }
+}

src/main/java/bmci/esign/backendend/dto/services/IMapClassWithDto.java

 package bmci.esign.backendend.dto.services;
+import bmci.esign.backendend.dto.response.DashboardChart;
 import org.springframework.data.domain.Page;
 
 import java.util.Collection;
@@ -15,4 +16,8 @@ public interface IMapClassWithDto<E,D> {
     List<D> convertPageToListDto(Page<E> entityList, Class<D> outCLass);
 
     List<E> convertListToListEntity(Collection<D> dtoList, Class<E> outCLass);
+
+    Page<D> convertResponseToPageDto(Page<E> entityList, Class<D> outCLass);
+    List<DashboardChart> mappingData(List<DashboardChart> chartList);
+
 }

src/main/java/bmci/esign/backendend/dto/services/MapClassWithDto.java

 package bmci.esign.backendend.dto.services;
+import bmci.esign.backendend.dto.response.DashboardChart;
+import bmci.esign.backendend.models.enums.EStatut;
 import org.modelmapper.Conditions;
 import org.modelmapper.ModelMapper;
 import org.modelmapper.convention.MatchingStrategies;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 @Service
@@ -59,4 +65,35 @@ public class MapClassWithDto<E, D> implements IMapClassWithDto<E, D> {
 
         return dtoList.stream().map(dto -> convertToEntity(dto, outCLass)).collect(Collectors.toList());
     }
+
+    @Override
+    public Page<D> convertResponseToPageDto(Page<E> entityPage, Class<D> outClass) {
+        List<D> dtoList = entityPage.stream()
+            .map(entity -> convertToDto(entity, outClass))
+            .collect(Collectors.toList());
+
+        Pageable pageable = PageRequest.of(entityPage.getNumber(), entityPage.getSize(), entityPage.getSort());
+
+        return new PageImpl<>(dtoList, pageable, entityPage.getTotalElements());
+    }
+
+    public List<DashboardChart> mappingData(List<DashboardChart> chartList){
+        Map<String, Integer> map=chartList.stream().collect(Collectors.toMap(DashboardChart::getStatut, DashboardChart::getCount));
+        for(EStatut eStatut: EStatut.values()){
+            if(!map.containsKey(eStatut.name())){
+                map.put(eStatut.name(), 0);
+            }
+        }
+        return map.entrySet().stream().map(entry -> new DashboardChart() {
+            @Override
+            public int getCount() {
+                return entry.getValue();
+            }
+
+            @Override
+            public String getStatut() {
+                return entry.getKey();
+            }
+        }).collect(Collectors.toList());
+    }
 }

src/main/java/bmci/esign/backendend/models/AuditorEntity.java

+package bmci.esign.backendend.models;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.hibernate.annotations.CreationTimestamp;
+import org.hibernate.annotations.UpdateTimestamp;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+import javax.persistence.*;
+import java.time.LocalDateTime;
+import java.util.Date;
+
+@Getter
+@Setter
+@MappedSuperclass
+@EntityListeners(AuditingEntityListener.class)
+public abstract class AuditorEntity {
+
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+    protected Long id;
+
+    @CreationTimestamp
+ //   @Column(name = "creationDate", columnDefinition = "TIMESTAMP", nullable = false, updatable = false)
+    @Temporal(TemporalType.TIMESTAMP)
+    protected Date creationDate;
+
+    @UpdateTimestamp
+ //   @Column(name = "modificationDate", columnDefinition = "TIMESTAMP", nullable = false)
+    @Temporal(TemporalType.TIMESTAMP)
+    protected Date modificationDate;
+}
\ No newline at end of file

src/main/java/bmci/esign/backendend/models/Demande.java

@@ -2,15 +2,12 @@ package bmci.esign.backendend.models;
 
 import bmci.esign.backendend.models.enums.EDemande;
 import bmci.esign.backendend.models.enums.EStatut;
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import org.hibernate.annotations.CreationTimestamp;
-import org.hibernate.annotations.UpdateTimestamp;
-
 import javax.persistence.*;
+import java.io.Serializable;
 import java.util.Date;
 import java.util.List;
 
@@ -18,36 +15,35 @@ import java.util.List;
 @AllArgsConstructor
 @Data
 @Entity
-public class Demande {
-    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+public class Demande extends AuditorEntity implements Serializable {
+
     private String confidentiality;
     private String priority;
     private String objetMail;
     private String message;
+
     @Enumerated(EnumType.STRING)
     @Column(length = 50)
     private EStatut statut;
+
     @Enumerated(EnumType.STRING)
     @Column(length = 50)
     private EDemande edemande;
+
     @ManyToOne
     @JoinColumn(name = "user_id")
     @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
     private User user;
+
     @ManyToOne
     @JoinColumn(name = "typeDocument_id")
     private TypeDocument typeDocument;
+
     @Temporal(TemporalType.TIMESTAMP)
     private Date expirationDate;
-    @CreationTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date creationDate;
-    @UpdateTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date modificationDate;
 
-    @OneToMany(mappedBy = "demande")
+    @OneToMany(mappedBy = "demande", fetch = FetchType.LAZY)
+    //        @JsonManagedReference
     private List<Destinataire> destinataires;
     @OneToMany(mappedBy = "demande")
     private List<Document> documents;

src/main/java/bmci/esign/backendend/models/Destinataire.java

@@ -7,7 +7,6 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 import org.hibernate.annotations.CreationTimestamp;
 import org.hibernate.annotations.UpdateTimestamp;
-
 import javax.persistence.*;
 import java.util.Date;
 import java.util.List;
@@ -28,7 +27,9 @@ public class Destinataire {
     private String envoie;
     private int place;
     @ManyToOne
-    @JoinColumn(name = "demande_id") @JsonIgnore
+    @JoinColumn(name = "demande_id")
+    @JsonIgnore
+    //        @JsonBackReference
     private Demande demande;
     @CreationTimestamp
     @Temporal(TemporalType.TIMESTAMP)

src/main/java/bmci/esign/backendend/models/Document.java

 package bmci.esign.backendend.models;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import org.hibernate.annotations.CreationTimestamp;
-import org.hibernate.annotations.UpdateTimestamp;
-
 import javax.persistence.*;
-import java.util.Date;
+import java.io.Serializable;
 
 
 @Data @AllArgsConstructor @NoArgsConstructor
 @Entity
-public class Document {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+public class Document extends AuditorEntity implements Serializable {
     private String directory;
     @ManyToOne
     @JoinColumn(name = "demande_id")
+    @JsonIgnore
     private Demande demande;
-    @CreationTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date creationDate;
-    @UpdateTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date modificationDate;
 }

src/main/java/bmci/esign/backendend/models/MailRequest.java

@@ -2,23 +2,17 @@ package bmci.esign.backendend.models;
 
 
 import bmci.esign.backendend.models.enums.EMailStatus;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import org.hibernate.annotations.CreationTimestamp;
-import org.hibernate.annotations.UpdateTimestamp;
+import lombok.*;
 
 import javax.persistence.*;
-import java.util.Date;
+import java.io.Serializable;
 
-@Data
+@Getter
+@Setter
 @AllArgsConstructor
 @NoArgsConstructor
 @Entity
-public class MailRequest {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+public class MailRequest extends AuditorEntity implements Serializable {
     private String destination;
     private String email_type;
     private long demandeId;
@@ -31,11 +25,24 @@ public class MailRequest {
     private EMailStatus status;
     private String responseMessage;
     private String url_sign;
-    @CreationTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date creationDate;
-    @UpdateTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date modificationDate;
 
+    @Override
+    public String toString() {
+        return "MailRequest{" +
+                "destination='" + destination + '\'' +
+                ", email_type='" + email_type + '\'' +
+                ", demandeId=" + demandeId +
+                ", processCamundaId='" + processCamundaId + '\'' +
+                ", token='" + token + '\'' +
+                ", expiration_date='" + expiration_date + '\'' +
+                ", name='" + name + '\'' +
+                ", userMessage='" + userMessage + '\'' +
+                ", status=" + status +
+                ", responseMessage='" + responseMessage + '\'' +
+                ", url_sign='" + url_sign + '\'' +
+                ", id=" + id +
+                ", creationDate=" + creationDate +
+                ", modificationDate=" + modificationDate +
+                '}';
+    }
 }

src/main/java/bmci/esign/backendend/models/Notification.java

+package bmci.esign.backendend.models;
+
+import bmci.esign.backendend.models.enums.ENotification;
+import lombok.*;
+
+import javax.persistence.*;
+import java.io.Serializable;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+public class Notification extends AuditorEntity implements Serializable {
+
+    private String title;
+    private String message;
+
+    @ManyToOne
+    @JoinColumn(name = "destinataire_id")
+    private Destinataire destinataire;
+
+    @ManyToOne
+    @JoinColumn(name = "demande_id")
+    private Demande demande;
+
+    @Enumerated(EnumType.STRING)
+    @Column(length = 50)
+    private ENotification status;
+
+    @Override
+    public String toString() {
+        return "Notification{" +
+                "title='" + title + '\'' +
+                ", message='" + message + '\'' +
+                ", destinataire_name=" + destinataire.getName() +
+                ", demande_id=" + demande.getId() +
+                ", status=" + status +
+                ", id=" + id +
+                ", creationDate=" + creationDate +
+                ", modificationDate=" + modificationDate +
+                '}';
+    }
+}

src/main/java/bmci/esign/backendend/models/Position.java

@@ -6,12 +6,10 @@ import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import org.hibernate.annotations.*;
-
 import javax.persistence.*;
 import javax.persistence.Entity;
-import java.util.Date;
+import java.io.Serializable;
 import java.util.HashMap;
-import java.util.Map;
 
 @Data
 @AllArgsConstructor @NoArgsConstructor
@@ -19,20 +17,12 @@ import java.util.Map;
         @TypeDef(name = "jsonb", typeClass = JsonBinaryType.class)
 })
 @Entity
-public class Position {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+public class Position extends AuditorEntity implements Serializable {
     @ManyToOne
     @JoinColumn(name = "destinataire_id") @JsonIgnore
     private Destinataire destinataire;
     @Type(type = "jsonb")
     @Column(columnDefinition = "jsonb")
     private HashMap<String, Object> information;
-    @CreationTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date creationDate;
-    @UpdateTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date modificationDate;
+
 }

src/main/java/bmci/esign/backendend/models/Signature.java

@@ -4,30 +4,16 @@ import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import org.hibernate.annotations.CreationTimestamp;
-import org.hibernate.annotations.TypeDef;
-import org.hibernate.annotations.TypeDefs;
-import org.hibernate.annotations.UpdateTimestamp;
-
 import javax.persistence.*;
-import java.util.Date;
+import java.io.Serializable;
 
 @Data
 @NoArgsConstructor @AllArgsConstructor
 @Table
 @Entity
-public class Signature {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+public class Signature extends AuditorEntity implements Serializable {
     private String directory;
     @ManyToOne
     @JoinColumn(name = "user_id") @JsonIgnore
     private User user;
-    @CreationTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date creationDate;
-    @UpdateTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date modificationDate;
 }

src/main/java/bmci/esign/backendend/models/Statut.java

 package bmci.esign.backendend.models;
 
-import bmci.esign.backendend.models.enums.EDemande;
 import bmci.esign.backendend.models.enums.EStatut;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import org.hibernate.annotations.CreationTimestamp;
-import org.hibernate.annotations.UpdateTimestamp;
-
 import javax.persistence.*;
-import java.util.Date;
+import java.io.Serializable;
 
 
 @NoArgsConstructor
 @AllArgsConstructor
 @Data
 @Entity
-public class Statut {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+public class Statut extends AuditorEntity implements Serializable {
+//    @Id
+//    @GeneratedValue(strategy = GenerationType.IDENTITY)
+//    private Long id;
     @Enumerated(EnumType.STRING)
     @Column(length = 50)
     private EStatut name;
-    @CreationTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date creationDate;
-    @UpdateTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date modificationDate;
+
+//    @CreationTimestamp
+//    @Temporal(TemporalType.TIMESTAMP)
+//    private Date creationDate;
+//    @UpdateTimestamp
+//    @Temporal(TemporalType.TIMESTAMP)
+//    private Date modificationDate;
 }

src/main/java/bmci/esign/backendend/models/TypeDemande.java

 package bmci.esign.backendend.models;
 
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import org.hibernate.annotations.CreationTimestamp;
-import org.hibernate.annotations.UpdateTimestamp;
-
 import javax.persistence.*;
-import java.util.Date;
-import java.util.List;
+import java.io.Serializable;
 
 
 @NoArgsConstructor
 @AllArgsConstructor
 @Data
 @Entity
-public class TypeDemande {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+public class TypeDemande extends AuditorEntity implements Serializable {
     private String name;
-    @CreationTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date creationDate;
-    @UpdateTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date modificationDate;
 
 }

src/main/java/bmci/esign/backendend/models/TypeDocument.java

@@ -4,26 +4,15 @@ import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import org.hibernate.annotations.CreationTimestamp;
-import org.hibernate.annotations.UpdateTimestamp;
-
 import javax.persistence.*;
-import java.util.Date;
+import java.io.Serializable;
 import java.util.List;
 
 @NoArgsConstructor @AllArgsConstructor
 @Data
 @Entity
-public class TypeDocument {
-    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+public class TypeDocument extends AuditorEntity implements Serializable {
     private String name;
-    @CreationTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date creationDate;
-    @UpdateTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date modificationDate;
 
     @OneToMany(mappedBy = "typeDocument") @JsonIgnore
     private List<Demande> demandes;

src/main/java/bmci/esign/backendend/models/User.java

@@ -4,12 +4,9 @@ import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import org.hibernate.annotations.CreationTimestamp;
-import org.hibernate.annotations.UpdateTimestamp;
-
 import javax.persistence.*;
+import java.io.Serializable;
 import java.util.ArrayList;
-import java.util.Date;
 import java.util.List;
 import java.util.Set;
 
@@ -17,10 +14,8 @@ import java.util.Set;
 @NoArgsConstructor @AllArgsConstructor
 @Entity
 @Table(name = "userEntity")
-public class User {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+public class User extends AuditorEntity implements Serializable {
+
     @Column(length = 120)
     private String firstname;
     @Column(length = 120)
@@ -30,12 +25,6 @@ public class User {
     private String email;
     @Column(length = 60)
     private String password;
-    @CreationTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date creationDate;
-    @UpdateTimestamp
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date modificationDate;
 
     @OneToMany(mappedBy = "user") @JsonIgnore
     private List<Demande> demandes = new ArrayList<>();

src/main/java/bmci/esign/backendend/models/enums/ENotification.java

+package bmci.esign.backendend.models.enums;
+
+public enum ENotification {
+    WAITING("En attente"),
+    VIEW("Vue");
+
+    private final String displayName;
+
+    ENotification(String displayName) {
+        this.displayName = displayName;
+    }
+
+    public String getDisplayName() {
+        return displayName;
+    }
+
+    public static ENotification fromString(String text) {
+        for (ENotification statut : ENotification.values()) {
+            if (statut.displayName.equalsIgnoreCase(text)) {
+                return statut;
+            }
+        }
+        throw new IllegalArgumentException("No constant with text " + text + " found");
+    }
+}

src/main/java/bmci/esign/backendend/repositories/DemandeRepository.java

 package bmci.esign.backendend.repositories;
 
+import bmci.esign.backendend.dto.response.DashboardChart;
 import bmci.esign.backendend.models.Demande;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
 
 @Repository
-public interface DemandeRepository extends JpaRepository<Demande, Long> {
+public interface DemandeRepository extends JpaRepository<Demande, Long>, JpaSpecificationExecutor<Demande> {
     List<Demande> findAllByUserId(Long id);
 
+    @Query(value = "SELECT count(d.id) as count, d.statut as statut FROM Demande d WHERE d.user.email= :email GROUP BY d.statut")
+    List<DashboardChart> loadSignaturesChart(@Param("email") String email);
 }
+/*
+SELECT statut as statut, SUM(count) as total
+FROM (
+    SELECT count(d.id) as count, d.statut as statut
+    FROM demande d
+    INNER JOIN user_entity u ON u.id = d.user_id
+    WHERE u.email = 'anasjegoual.04@gmail.com'
+    GROUP BY d.statut
+    UNION ALL
+    SELECT count(dem.id) as count, dem.statut as statut
+    FROM demande dem
+    INNER JOIN destinataire dest ON dem.id = dest.demande_id
+    WHERE dest.email = 'anasjegoual.04@gmail.com'
+    GROUP BY dem.statut
+) GROUP BY statut;
+ */
\ No newline at end of file

src/main/java/bmci/esign/backendend/repositories/DestinataireRepository.java

 package bmci.esign.backendend.repositories;
 
+import bmci.esign.backendend.dto.response.DashboardChart;
 import bmci.esign.backendend.models.Destinataire;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
+import java.util.Optional;
 
 @Repository
-public interface DestinataireRepository extends JpaRepository<Destinataire, Long> {
+public interface DestinataireRepository extends JpaRepository<Destinataire, Long>, JpaSpecificationExecutor<Destinataire> {
     List<Destinataire> findAllByDemandeId(Long id);
+
+    @Query(value = "SELECT count(d.id) as count, d.statut as statut FROM Destinataire d WHERE d.email= :email GROUP BY d.statut")
+    List<DashboardChart> loadSignDm(@Param("email") String email);
+    Optional<Destinataire> findByEmail(String email);
 }

src/main/java/bmci/esign/backendend/repositories/NotificationRepository.java

+package bmci.esign.backendend.repositories;
+
+import bmci.esign.backendend.models.Notification;
+import bmci.esign.backendend.models.enums.ENotification;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface NotificationRepository extends JpaRepository<Notification, Long> {
+    List<Notification> findAllByDestinataire_EmailAndStatus(String email, ENotification status);
+    Notification findByDemandeId(Long id);
+}

src/main/java/bmci/esign/backendend/repositories/UserRepository.java

@@ -4,7 +4,10 @@ import bmci.esign.backendend.models.User;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.stereotype.Repository;
 
+import java.util.Optional;
+
 @Repository
 public interface UserRepository extends PagingAndSortingRepository<User, Long> {
-    User findByEmail(String email);
+    Optional<User> findByEmail(String email);
+    boolean existsByEmail(String email);
 }

src/main/java/bmci/esign/backendend/services/AuthorityService.java

 package bmci.esign.backendend.services;
 
 import bmci.esign.backendend.dto.AuthorityDto;
+import bmci.esign.backendend.models.Authority;
 
 import java.util.List;
 
 public interface AuthorityService {
-    AuthorityDto addAuthority(AuthorityDto authorityDto);
+    Authority addAuthority(Authority authority);
     AuthorityDto getAuthority(Long id);
     List<AuthorityDto> getAll();
 }

src/main/java/bmci/esign/backendend/services/DemandeService.java

 package bmci.esign.backendend.services;
 
 import bmci.esign.backendend.dto.DemandeDto;
+import bmci.esign.backendend.dto.request.FilterDto;
+import bmci.esign.backendend.dto.response.DashboardChart;
 import bmci.esign.backendend.models.Demande;
-import bmci.esign.backendend.models.enums.EStatut;
+import org.springframework.data.domain.Page;
 
 import java.util.Date;
 import java.util.List;
@@ -20,4 +22,7 @@ public interface DemandeService {
     List<DemandeDto> getAll();
     List<DemandeDto> getAllbyUser(Long userId);
     Map<String, Object> getForUserDemandeSearch(Long userId, int page, int limit, String statut, String eDemande, Date dateStart);
+    Page<DemandeDto> findDemandesByUser(FilterDto filterDto);
+    List<DashboardChart> loadReceivedChart(String email);
+    List<DashboardChart> loadGlobalData(String email);
 }

src/main/java/bmci/esign/backendend/services/DestinataireService.java

 package bmci.esign.backendend.services;
 
+import bmci.esign.backendend.dto.DemandeDto;
 import bmci.esign.backendend.dto.DestinataireDto;
+import bmci.esign.backendend.dto.request.FilterDto;
+import bmci.esign.backendend.dto.response.DashboardChart;
 import bmci.esign.backendend.models.Destinataire;
+import org.springframework.data.domain.Page;
 
 import java.util.List;
 
@@ -12,4 +16,6 @@ public interface DestinataireService {
     DestinataireDto getDestinataire(Long id);
     Destinataire findDestinataire(Long id);
     List<DestinataireDto> findAllByDemandeId(Long id);
+    Page<DemandeDto> findAllDemandesToSigne(FilterDto destinataireFilterDto);
+    List<DashboardChart> loadSignDmChart(String email);
 }

src/main/java/bmci/esign/backendend/services/NotificationService.java

+package bmci.esign.backendend.services;
+
+import bmci.esign.backendend.dto.NotificationDto;
+import bmci.esign.backendend.models.Notification;
+import bmci.esign.backendend.models.enums.ENotification;
+
+import java.util.List;
+
+public interface NotificationService {
+    List<NotificationDto> loadActiveNotificationsByUserEmail(String email);
+ //   Notification createNotification(NotificationDto dto);
+    Notification createNotification(Notification notification);
+    void changeStatusByDmId(Long id,Long demandeId, ENotification status);
+}

src/main/java/bmci/esign/backendend/services/TypeDocumentService.java

 package bmci.esign.backendend.services;
 
 import bmci.esign.backendend.dto.TypeDocumentDto;
+import bmci.esign.backendend.dto.request.TypeDocAddDto;
 
 import java.util.List;
 
 public interface TypeDocumentService {
-    TypeDocumentDto addTypeDocument(TypeDocumentDto typeDocumentDto);
+    TypeDocumentDto addTypeDocument(TypeDocAddDto type);
     List<TypeDocumentDto> getAll();
 }

src/main/java/bmci/esign/backendend/services/impl/AuthorityServiceImpl.java

@@ -21,9 +21,12 @@ public class AuthorityServiceImpl implements AuthorityService {
     private IMapClassWithDto<Authority, AuthorityDto> authorityMapping;
 
     @Override
-    public AuthorityDto addAuthority(AuthorityDto authorityDto) {
+    public Authority addAuthority(Authority authority) {
+        if(authority == null){
             return null;
         }
+        return authorityRepository.save(authority);
+    }
 
     @Override
     public AuthorityDto getAuthority(Long id) {

src/main/java/bmci/esign/backendend/services/impl/CamundaUserService.java

+package bmci.esign.backendend.services.impl;
+
+import org.camunda.bpm.engine.IdentityService;
+import org.camunda.bpm.engine.identity.User;
+import org.springframework.stereotype.Service;
+
+@Service
+public class CamundaUserService {
+    private final IdentityService identityService;
+    public CamundaUserService(IdentityService identityService) {
+        this.identityService = identityService;
+    }
+
+    public void createUser(String userId, String firstName, String lastName, String email, String password) {
+        User user = identityService.newUser(userId);
+        user.setFirstName(firstName);
+        user.setLastName(lastName);
+        user.setEmail(email);
+        user.setPassword(password);
+
+        identityService.saveUser(user);
+    }
+
+    public void updateUser(String userId, String newFirstName, String newLastName, String newEmail) {
+    User user = identityService.createUserQuery().userId(userId).singleResult();
+    if (user != null) {
+        user.setFirstName(newFirstName);
+        user.setLastName(newLastName);
+        user.setEmail(newEmail);
+
+        identityService.saveUser(user);
+    }
+}
+
+}

src/main/java/bmci/esign/backendend/services/impl/DemandeServiceImpl.java

 package bmci.esign.backendend.services.impl;
 
 import bmci.esign.backendend.dto.DemandeDto;
+import bmci.esign.backendend.dto.request.FilterDto;
 import bmci.esign.backendend.dto.DestinataireDto;
 import bmci.esign.backendend.dto.PositionDto;
+import bmci.esign.backendend.dto.response.DashboardChart;
 import bmci.esign.backendend.dto.services.IMapClassWithDto;
 import bmci.esign.backendend.models.*;
 import bmci.esign.backendend.models.enums.EDemande;
+import bmci.esign.backendend.models.enums.ENotification;
 import bmci.esign.backendend.models.enums.EStatut;
 import bmci.esign.backendend.repositories.DemandeRepository;
 import bmci.esign.backendend.repositories.DestinataireRepository;
@@ -13,9 +16,15 @@ import bmci.esign.backendend.repositories.DocumentRepository;
 import bmci.esign.backendend.repositories.PositionRepository;
 import bmci.esign.backendend.services.DemandeService;
 import bmci.esign.backendend.services.EmailService;
+import bmci.esign.backendend.services.NotificationService;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
 import org.springframework.stereotype.Service;
-
+import org.springframework.transaction.annotation.Transactional;
 import javax.persistence.EntityManager;
 import javax.persistence.TypedQuery;
 import javax.persistence.criteria.CriteriaBuilder;
@@ -26,6 +35,7 @@ import java.util.*;
 import java.util.stream.Collectors;
 
 @Service
+@Slf4j
 public class DemandeServiceImpl implements DemandeService {
 
     @Autowired
@@ -46,9 +56,12 @@ public class DemandeServiceImpl implements DemandeService {
     private IMapClassWithDto<Destinataire, DestinataireDto> destinataireMapping;
     @Autowired
     private IMapClassWithDto<Position, PositionDto> positionMapping;
+    @Autowired
+    private NotificationService notificationService;
 
     @Override
     public DemandeDto addDemande(DemandeDto demandeDto) {
+        log.info("PROCESSING<>{addDemande}... REQUEST_ID: {}", demandeDto.getId());
         List<DestinataireDto> destinataireDtos = demandeDto.getDestinataires();
 
         Demande demande = demandeMapping.convertToEntity(demandeDto, Demande.class);
@@ -110,6 +123,7 @@ public class DemandeServiceImpl implements DemandeService {
 
     @Override
     public DemandeDto getDemande(Long id) {
+        log.info("PROCESSING<>{getDemande}... REQUEST_DM_ID: {}", id);
         Optional<Demande> demande = demandeRepository.findById(id);
         return demande.map(value -> demandeMapping.convertToDto(value, DemandeDto.class)).orElse(null);
     }
@@ -122,6 +136,7 @@ public class DemandeServiceImpl implements DemandeService {
 
     @Override
     public void processEmail(Demande demande) {
+        log.info("PROCESSING<>{processEmail}...");
         List<Destinataire> destinataires = demande.getDestinataires().stream().filter(destinataire ->
                 destinataire.getStatut().name().equals(EStatut.WAITING.name())).collect(Collectors.toList());
 
@@ -135,6 +150,7 @@ public class DemandeServiceImpl implements DemandeService {
                 if(demande1.isPresent()){
                     demande.setEdemande(demande1.get().getEdemande());
                     demandeRepository.save(demande);
+                  //  notificationService.changeStatusByDmId(null, demande.getId(), ENotification.VIEW);
                 }
             }
         }else if(demande.getEdemande().equals(EDemande.PARALLELE)){
@@ -146,6 +162,7 @@ public class DemandeServiceImpl implements DemandeService {
                 if(demande1.isPresent()){
                     demande.setEdemande(demande1.get().getEdemande());
                     demandeRepository.save(demande);
+                  //   notificationService.changeStatusByDmId(null, demande.getId(), ENotification.VIEW);
                 }
 
             }else{
@@ -220,7 +237,14 @@ public class DemandeServiceImpl implements DemandeService {
         model.put("message", demande.getMessage());
         model.put("name", dest.getName());
         emailService.SendEmail(mailRequest,model);
+        String message = String.format("Cher %s, vous avez une nouvelle demande avec le sujet '%s'. Veuillez la consulter dès que possible.",
+                                   demande.getUser().getLastname(),
+                                   demande.getObjetMail());
+        for(Destinataire destinataire : demande.getDestinataires()){
+        notificationService.createNotification(new Notification(message, demande.getObjetMail(),destinataire,demande, ENotification.WAITING));
+
         }
+}
 
     @Override
     public void deleteDemande(Long id) {
@@ -240,6 +264,7 @@ public class DemandeServiceImpl implements DemandeService {
 
     @Override
     public Map<String, Object> getForUserDemandeSearch(Long userId, int page, int limit, String statut, String eDemande, Date dateStart) {
+        log.info("PROCESSING<>{getForUserDemandeSearch}... REQUEST: userId {}; page {}; limit {}; ", userId, page, limit);
         Map<String, Object> resp = new HashMap<String, Object>();
         Calendar cal = Calendar.getInstance();
         cal.setTime(dateStart);
@@ -284,4 +309,89 @@ public class DemandeServiceImpl implements DemandeService {
         return resp;
 
     }
+
+// Received
+    @Override
+    @Transactional(readOnly = true)
+    public Page<DemandeDto> findDemandesByUser(FilterDto filterDto){
+        log.info("PROCESSING<>{findDemandesByUser}... REQUEST: {}", filterDto);
+        try {
+            int page = filterDto.getPage();
+            int size = filterDto.getSize();
+            Pageable pageable = PageRequest.of(page, size);
+            Specification<Demande> specification = buildSpecification(filterDto);
+            Page<Demande> demandePage= demandeRepository.findAll(specification, pageable);
+            demandePage.stream().forEach(demande -> {
+                demande.setDestinataires(mapDestinatairesToDto(demande.getDestinataires()));
+            });
+            return demandeMapping.convertResponseToPageDto(demandePage, DemandeDto.class);
+        } catch (Exception e) {
+            log.error("EXCEPTION<>findAllDemandesToSigne: {}", e.getMessage(), e);
+            return Page.empty();
+        }
+    }
+
+    private Specification<Demande> buildSpecification(FilterDto dto) {
+        return (root, query, criteriaBuilder) -> {
+            List<Predicate> predicates = new ArrayList<>();
+            if (dto.getCreatedDate() != null) {
+                log.info("creation_date: {}",dto.getCreatedDate());
+                predicates.add(criteriaBuilder.equal(root.get("creation_date"), dto.getCreatedDate()));
+            }
+            if(dto.getPriority() != null){
+                log.info("priority: {}",dto.getPriority());
+                predicates.add(criteriaBuilder.equal(root.get("demande").get("priority"), dto.getPriority()));
+            }
+            predicates.add(criteriaBuilder.equal(root.get("user").get("email"), dto.getEmail()));
+
+            return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
+        };
+    }
+    private List<Destinataire> mapDestinatairesToDto(List<Destinataire> destinataires) {
+        return destinataires.stream()
+                .map(dest -> new Destinataire(
+                        dest.getId(),
+                        dest.getName(),
+                        dest.getEmail(),
+                        dest.getRole(),
+                        dest.getStatut(),
+                        dest.getEnvoie(),
+                        dest.getPlace(),
+                        null,
+                        dest.getCreationDate(),
+                        dest.getModificationDate(),
+                        Collections.emptyList()
+                ))
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public List<DashboardChart> loadReceivedChart(String email) {
+        log.info("PROCESSING<>{Load_received_Request}... EMAIL: {}", email);
+        try {
+            if(email.isEmpty()){
+                return null;
+            }
+            return demandeMapping.mappingData(demandeRepository.loadSignaturesChart(email));
+        }catch (Exception e){
+            log.error("EXCEPTION<>loadSignaturesChart: {}", e.getMessage(), e);
+            return Collections.emptyList();
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public List<DashboardChart> loadGlobalData(String email) {
+        log.info("PROCESSING<>{loadGlobalData}... EMAIL: {}", email);
+        try {
+            if(email.isEmpty()){
+                return null;
+            }
+            return demandeRepository.loadSignaturesChart(email);
+        }catch (Exception e){
+            log.error("EXCEPTION<>loadSignaturesChart: {}", e.getMessage(), e);
+            return Collections.emptyList();
+        }
+    }
 }
\ No newline at end of file

src/main/java/bmci/esign/backendend/services/impl/DestinataireServiceImpl.java

 package bmci.esign.backendend.services.impl;
 
+import bmci.esign.backendend.dto.DemandeDto;
 import bmci.esign.backendend.dto.DestinataireDto;
+import bmci.esign.backendend.dto.request.FilterDto;
+import bmci.esign.backendend.dto.response.DashboardChart;
 import bmci.esign.backendend.dto.services.IMapClassWithDto;
+import bmci.esign.backendend.models.Demande;
 import bmci.esign.backendend.models.Destinataire;
 import bmci.esign.backendend.models.enums.EStatut;
 import bmci.esign.backendend.repositories.DestinataireRepository;
 import bmci.esign.backendend.services.DestinataireService;
-import org.springframework.beans.factory.annotation.Autowired;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
 import org.springframework.stereotype.Service;
-
+import org.springframework.transaction.annotation.Transactional;
+import javax.persistence.criteria.Predicate;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 @Service
+@Slf4j
 public class DestinataireServiceImpl implements DestinataireService {
 
-    @Autowired
-    private DestinataireRepository destinataireRepository;
+    private final DestinataireRepository destinataireRepository;
+    private final IMapClassWithDto<Destinataire, DestinataireDto> destinataireMapping;
+    private final IMapClassWithDto<Demande, DemandeDto> demandeMapping;
 
-    @Autowired
-    private IMapClassWithDto<Destinataire, DestinataireDto> destinataireMapping;
+    public DestinataireServiceImpl(DestinataireRepository destinataireRepository, IMapClassWithDto<Destinataire, DestinataireDto> destinataireMapping, IMapClassWithDto<Demande, DemandeDto> demandeMapping) {
+        this.destinataireRepository = destinataireRepository;
+        this.destinataireMapping = destinataireMapping;
+        this.demandeMapping = demandeMapping;
+    }
 
     @Override
     public DestinataireDto addDestinataire(DestinataireDto destinataireDto) {
@@ -56,4 +72,62 @@ public class DestinataireServiceImpl implements DestinataireService {
     public List<DestinataireDto> findAllByDemandeId(Long id) {
         return destinataireMapping.convertListToListDto(destinataireRepository.findAllByDemandeId(id), DestinataireDto.class);
     }
+
+    @Override
+    @Transactional(readOnly = true)
+    public Page<DemandeDto> findAllDemandesToSigne(FilterDto destinataireFilterDto) {
+        log.info("PROCESSING<>{findAllDemandesToSigne}... REQUEST: {}", destinataireFilterDto);
+        try {
+            int page = destinataireFilterDto.getPage();
+            int size = destinataireFilterDto.getSize();
+            Pageable pageable = PageRequest.of(page, size);
+            Specification<Destinataire> specification = buildSpecification(destinataireFilterDto);
+            Page<Destinataire> destinataires= destinataireRepository.findAll(specification, pageable);
+            Page<Destinataire> destinatairePage =  destinataires.map(destinataire -> {
+                destinataire.getDemande().getDestinataires().get(0).setPositions(new ArrayList<>());
+              return destinataire;
+            });
+            return destinatairePage.map(this::mapToResponseDto);
+        } catch (Exception e) {
+            log.error("EXCEPTION<>findAllDemandesToSigne: {}", e.getMessage(), e);
+            return Page.empty();
+        }
+    }
+
+    private Specification<Destinataire> buildSpecification(FilterDto dto) {
+        return (root, query, criteriaBuilder) -> {
+            List<Predicate> predicates = new ArrayList<>();
+            if (dto.getCreatedDate() != null) {
+                log.info("creation_date: {}",dto.getCreatedDate());
+                predicates.add(criteriaBuilder.equal(root.get("creation_date"), dto.getCreatedDate()));
+            }
+            if(dto.getPriority() != null){
+                log.info("priority: {}",dto.getPriority());
+                predicates.add(criteriaBuilder.equal(root.get("demande").get("priority"), dto.getPriority()));
+            }
+            predicates.add(criteriaBuilder.equal(root.get("statut"), EStatut.WAITING));
+            predicates.add(criteriaBuilder.equal(root.get("email"), dto.getEmail()));
+
+            return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
+        };
+    }
+
+    private DemandeDto mapToResponseDto(Destinataire destinataire) {
+        return demandeMapping.convertToDto(destinataire.getDemande(), DemandeDto.class);
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public List<DashboardChart> loadSignDmChart(String email) {
+        log.info("PROCESSING<Destinataire>{loadSignDmChart}... EMAIL: {}", email);
+        try {
+            if(email.isEmpty()){
+                return null;
+            }
+            return destinataireMapping.mappingData(destinataireRepository.loadSignDm(email));
+        }catch (Exception e){
+            log.error("EXCEPTION<>loadSignaturesChart: {}", e.getMessage(), e);
+            return Collections.emptyList();
+        }
+    }
 }

src/main/java/bmci/esign/backendend/services/impl/EmailServiceImpl.java

@@ -7,6 +7,7 @@ import bmci.esign.backendend.services.EmailService;
 import freemarker.template.Configuration;
 import freemarker.template.Template;
 import freemarker.template.TemplateException;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.mail.javamail.JavaMailSender;
@@ -22,6 +23,7 @@ import java.util.Map;
 import java.util.Random;
 
 @Service
+@Slf4j
 public class EmailServiceImpl implements EmailService {
     @Autowired
     private JavaMailSender mailSender;
@@ -53,6 +55,7 @@ public class EmailServiceImpl implements EmailService {
 
     @Override
     public void SendEmail(MailRequest req, Map<String, String> model) {
+        log.info("PROCESSING<>{sendEmail} REQUEST {}", req.toString());
         MimeMessage mimeMessage =  mailSender.createMimeMessage();
         MimeMessageHelper helper = null;
         String template_name = "";
@@ -83,6 +86,7 @@ public class EmailServiceImpl implements EmailService {
             mailRequestRepository.save(req);
 
         } catch (IOException | TemplateException | MessagingException e) {
+            log.error("ERROR: {sendEmail}_ Message {} ; Cause {} ; Localized {}",e.getMessage(),e.getCause(), e.getLocalizedMessage(),e);
             e.printStackTrace();
         }
 

src/main/java/bmci/esign/backendend/services/impl/NotificationServiceImpl.java

+package bmci.esign.backendend.services.impl;
+
+import bmci.esign.backendend.dto.NotificationDto;
+import bmci.esign.backendend.dto.services.IMapClassWithDto;
+import bmci.esign.backendend.models.Notification;
+import bmci.esign.backendend.models.enums.ENotification;
+import bmci.esign.backendend.repositories.NotificationRepository;
+import bmci.esign.backendend.repositories.UserRepository;
+import bmci.esign.backendend.services.NotificationService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import java.util.Collections;
+import java.util.List;
+
+@Service
+@Slf4j
+public class NotificationServiceImpl implements NotificationService {
+    private final NotificationRepository notificationRepository;
+    private final UserRepository userRepository;
+    private final IMapClassWithDto<Notification, NotificationDto> mapClassWithDto;
+
+    public NotificationServiceImpl(NotificationRepository notificationRepository, UserRepository userRepository, IMapClassWithDto<Notification, NotificationDto> mapClassWithDto) {
+        this.notificationRepository = notificationRepository;
+        this.userRepository = userRepository;
+        this.mapClassWithDto = mapClassWithDto;
+    }
+
+
+    @Override
+    @Transactional(readOnly = true)
+    public List<NotificationDto> loadActiveNotificationsByUserEmail(String email) {
+        log.info("PROCESSING<>{loadActiveNotificationsByUserEmail}.. REQUEST {}", email);
+        try {
+            if (!userRepository.existsByEmail(email)) {
+                log.warn("loadActiveNotificationsByUserEmail: User Not Found with EMAIL {}", email);
+                return Collections.emptyList();
+            }
+            List<Notification> notifications = notificationRepository.findAllByDestinataire_EmailAndStatus(email, ENotification.WAITING);
+            return mapClassWithDto.convertListToListDto(notifications, NotificationDto.class);
+        } catch (Exception e) {
+            log.error("Exception occurred while loading active notifications for User EMAIL {}: {}", email, e.getMessage());
+            return Collections.emptyList();
+        }
+    }
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+  //  public Notification createNotification(NotificationDto dto) {
+    public Notification createNotification(Notification notification) {
+        log.info("PROCESSING<>{createNotification}.. REQUEST {}", notification);
+        try {
+         //   Notification notif = mapClassWithDto.convertToEntity(dto, Notification.class);
+        //    log.info("AFTER convert To Entity {}",notif);
+            Notification savedNotification = notificationRepository.save(notification);
+            log.info("createNotification: Notification created with ID {}", savedNotification.getId());
+            return savedNotification;
+        } catch (Exception e) {
+            log.error("Exception occurred while creating notification: {}", e.getMessage());
+            throw e;
+        }
+    }
+
+    @Override
+    @Transactional
+    public void changeStatusByDmId(Long id, Long demandeId, ENotification status) {
+        log.info("PROCESSING<>{changeStatus}.. REQUEST_ ID {} Demande_Id {}", id, demandeId);
+        try {
+            Notification notification;
+            if(id == null){
+                notification = notificationRepository.findByDemandeId(demandeId);
+            }else{
+                notification = notificationRepository.findById(id).get();
+            }
+            notification.setStatus(status);
+            notificationRepository.save(notification);
+        } catch (Exception e) {
+            log.error("Exception occurred while creating notification: {}", e.getMessage());
+            throw e;
+        }
+    }
+}

src/main/java/bmci/esign/backendend/services/impl/TypeDocumentServiceImpl.java

 package bmci.esign.backendend.services.impl;
 
 import bmci.esign.backendend.dto.TypeDocumentDto;
+import bmci.esign.backendend.dto.request.TypeDocAddDto;
 import bmci.esign.backendend.dto.services.IMapClassWithDto;
 import bmci.esign.backendend.models.TypeDocument;
 import bmci.esign.backendend.repositories.TypeDocumentRepository;
 import bmci.esign.backendend.services.TypeDocumentService;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
 
 @Service
+@Slf4j
 public class TypeDocumentServiceImpl implements TypeDocumentService {
 
     @Autowired
@@ -19,14 +22,17 @@ public class TypeDocumentServiceImpl implements TypeDocumentService {
     private IMapClassWithDto<TypeDocument, TypeDocumentDto> typeDocumentMapping;
 
     @Override
-    public TypeDocumentDto addTypeDocument(TypeDocumentDto typeDocumentDto) {
-        TypeDocument typeDocument = typeDocumentMapping.convertToEntity(typeDocumentDto, TypeDocument.class);
+    public TypeDocumentDto addTypeDocument(TypeDocAddDto type) {
+        log.info("PROCESSING<>{addTypeDocument}.. REQUEST {}",type);
+        TypeDocument typeDocument=new TypeDocument();
+        typeDocument.setName(type.getType());
         typeDocument = typeDocumentRepository.save(typeDocument);
         return typeDocumentMapping.convertToDto(typeDocument, TypeDocumentDto.class);
     }
 
     @Override
     public List<TypeDocumentDto> getAll() {
+          log.info("PROCESSING<>{TypeDocument_getAll}..");
         List<TypeDocument> typeDocuments = typeDocumentRepository.findAll();
         return typeDocumentMapping.convertListToListDto(typeDocuments, TypeDocumentDto.class);
     }

src/main/java/bmci/esign/backendend/services/impl/UploadServiceImpl.java

@@ -4,13 +4,10 @@ import bmci.esign.backendend.dto.DemandeDto;
 import bmci.esign.backendend.dto.DestinataireDto;
 import bmci.esign.backendend.dto.ObjetSignatureDto;
 import bmci.esign.backendend.dto.SignaturePageDto;
-import bmci.esign.backendend.models.Destinataire;
-import bmci.esign.backendend.models.Position;
-import bmci.esign.backendend.models.enums.EObjet;
 import bmci.esign.backendend.models.enums.EStatut;
-import bmci.esign.backendend.repositories.DestinataireRepository;
 import bmci.esign.backendend.services.DestinataireService;
 import bmci.esign.backendend.services.UploadService;
+import lombok.extern.slf4j.Slf4j;
 import org.apache.pdfbox.pdmodel.PDDocument;
 import org.apache.pdfbox.pdmodel.PDPage;
 import org.apache.pdfbox.pdmodel.PDPageContentStream;
@@ -21,9 +18,7 @@ import org.apache.pdfbox.pdmodel.graphics.image.PDImageXObject;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
-import org.springframework.util.StringUtils;
 import org.springframework.web.multipart.MultipartFile;
-
 import javax.imageio.ImageIO;
 import java.awt.image.BufferedImage;
 import java.io.ByteArrayInputStream;
@@ -34,10 +29,10 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.List;
-import java.util.Objects;
 import java.util.UUID;
 
 @Service
+@Slf4j
 public class UploadServiceImpl implements UploadService {
     @Value("${file.upload-dir.access}")
     private String UPLOAD_DIR;
@@ -47,6 +42,7 @@ public class UploadServiceImpl implements UploadService {
 
     @Override
     public String uploadFile(MultipartFile file) {
+        log.info("PROCESSING<>{uploadFile}... REQUEST: check_file {} ", file.isEmpty());
         try {
             String fileName = identifiant() + ".pdf";
             //file
@@ -62,6 +58,142 @@ public class UploadServiceImpl implements UploadService {
         }
     }
 
+    @Override
+    public String modifyPdf(List<SignaturePageDto> signaturePageDtos, DemandeDto demandeDto) {
+        String filename = demandeDto.getDocuments().get(0).getDirectory();
+        DestinataireDto destinataireDto = demandeDto.getDestinataires().get(0);
+
+        if (destinataireDto.getRole().equals("Signataire")) {
+            try (PDDocument document = PDDocument.load(new File(UPLOAD_DIR + "/" + filename))) {
+                for (SignaturePageDto signaturePageDto : signaturePageDtos) {
+                    PDPage page = document.getPage(signaturePageDto.getPage());
+                    log.info("Processing page: {}", signaturePageDto.getPage());
+                    if (!signaturePageDto.getObjetSignatureDtos().isEmpty()) {
+                        try (PDPageContentStream contentStream = new PDPageContentStream(document, page, PDPageContentStream.AppendMode.APPEND, true)) {
+                            for (ObjetSignatureDto objetSignatureDto : signaturePageDto.getObjetSignatureDtos()) {
+                                log.info("Processing object: type={}, x={}, y={}", objetSignatureDto.getTypeObjet(), objetSignatureDto.getX(), objetSignatureDto.getY());
+                                        double x = resize(objetSignatureDto.getX(), 0.75);
+                                        double y = resize(objetSignatureDto.getY(), 0.75);
+                                        double width = resize(objetSignatureDto.getWidth(), 0.75);
+                                        double height = resize(objetSignatureDto.getHeight(), 0.75);
+                                      //  y = 841 - y;
+                                        y = page.getMediaBox().getHeight() - y - height;
+                                        log.info("PAGE_SIZE {}",page.getMediaBox().getHeight());
+                                        x = Math.max(5, Math.min(x, PDRectangle.A4.getWidth() - width - 5));
+                                        y = Math.max(height + 5, Math.min(y, PDRectangle.A4.getHeight() - height - 5));
+                                        if ("NAME".equals(objetSignatureDto.getTypeObjet()) || "DATE".equals(objetSignatureDto.getTypeObjet())) {
+                                            contentStream.beginText();
+                                            contentStream.setFont(PDType1Font.TIMES_ROMAN, 12);
+                                            contentStream.newLineAtOffset((float) x, (float) (y + height));
+                                            contentStream.showText(objetSignatureDto.getText());
+                                            contentStream.endText();
+                                        } else {
+                                            insertImage(document, contentStream, objetSignatureDto, x, y, width, height);
+                                        }
+                            }
+                        }
+                    }
+                }
+                document.save(UPLOAD_DIR + "/" + filename);
+                destinataireDto.setStatut(EStatut.COMPLETE.name());
+                destinataireService.updateDestinataire(destinataireDto, destinataireDto.getId());
+                return "success";
+            } catch (IOException e) {
+                log.error("Error processing PDF: {}", e.getMessage(), e);
+                destinataireDto.setStatut(EStatut.CANCELED.name());
+                destinataireService.updateDestinataire(destinataireDto, destinataireDto.getId());
+                return "cancel";
+            }
+        } else {
+            destinataireDto.setStatut(EStatut.COMPLETE.name());
+            destinataireService.updateDestinataire(destinataireDto, destinataireDto.getId());
+            return "success";
+        }
+    }
+    private void insertImage(PDDocument document, PDPageContentStream contentStream, ObjetSignatureDto objetSignatureDto, double x, double y, double width, double height) throws IOException {
+        PDImageXObject pdImage = null;
+
+        if (objetSignatureDto.getFileBase64() != null && !objetSignatureDto.getFileBase64().isEmpty()) {
+            byte[] imageBytes = javax.xml.bind.DatatypeConverter.parseBase64Binary(objetSignatureDto.getFileBase64());
+            BufferedImage bufferedImage = ImageIO.read(new ByteArrayInputStream(imageBytes));
+            if (bufferedImage != null) {
+                pdImage = LosslessFactory.createFromImage(document, bufferedImage);
+            } else {
+                log.error("BufferedImage is null for base64: {}", objetSignatureDto.getFileBase64());
+            }
+        } else if (objetSignatureDto.getFile() != null) {
+            BufferedImage bImage = ImageIO.read(new File(String.valueOf(objetSignatureDto.getFile())));
+            if (bImage != null) {
+                pdImage = PDImageXObject.createFromByteArray(document, toByteArray(bImage), "image");
+            } else {
+                log.error("BufferedImage is null for file: {}", objetSignatureDto.getFile());
+            }
+        } else {
+            log.error("No valid image source found for objetSignatureDto: {}", objetSignatureDto);
+        }
+
+        if (pdImage != null) {
+            contentStream.drawImage(pdImage, (float) x, (float) y, (float) width, (float) height);
+        }
+    }
+
+/*
+
+
+               double y = resize(objetSignatureDto.getY(), 0.75);
+                            double x = resize(objetSignatureDto.getX(), 0.75);
+                            double width = resize(objetSignatureDto.getWidth(), 0.75);
+                            double height = resize(objetSignatureDto.getHeight(), 0.75);
+                            y = 841 - y;
+                            log.info("Y {}",y);
+                            if (x + width > PDRectangle.A4.getWidth()) {
+                                x = (PDRectangle.A4.getWidth() - width) - 5;
+                            } else if (x < 0) {
+                                x = 5;
+                            }
+                            if ((y + height) > PDRectangle.A4.getHeight()) {
+                                y = PDRectangle.A4.getHeight() - height - 5;
+                            } else if (y < height) {
+                                y = height + 5;
+                            }
+
+                            if (objetSignatureDto.getTypeObjet().equals("NAME") ||
+                                    objetSignatureDto.getTypeObjet().equals("DATE")) {
+                                // Add text
+                                contentStream.beginText();
+                                contentStream.setFont(PDType1Font.TIMES_ROMAN, 12);
+                                contentStream.newLineAtOffset((float) x, (float) (y + height));
+                                String text = objetSignatureDto.getText();
+                                contentStream.showText(text);
+                                contentStream.endText();
+                            } else {
+                                if (objetSignatureDto.getFileBase64() != null && !objetSignatureDto.getFileBase64().isEmpty()) {
+                                    byte[] imageBytes = javax.xml.bind.DatatypeConverter.parseBase64Binary(objetSignatureDto.getFileBase64());
+                                    BufferedImage bufferedImage = ImageIO.read(new ByteArrayInputStream(imageBytes));
+                                    if (bufferedImage != null) {
+                                        PDImageXObject pdImage = LosslessFactory.createFromImage(document, bufferedImage);
+                                        log.warn("BASE64: selected x {}, y {}",(float) x, (float) y);
+                                        contentStream.drawImage(pdImage, (float) x, (float) y, (float) width, (float) height);
+                                    } else {
+                                        log.error("BufferedImage is null for base64: {}", objetSignatureDto.getFileBase64());
+                                        return "cancel";
+                                    }
+                                } else if (objetSignatureDto.getFile() != null) {
+                                    BufferedImage bImage = ImageIO.read(new File(String.valueOf(objetSignatureDto.getFile())));
+                                    if (bImage != null) {
+                                        PDImageXObject pdImage = PDImageXObject.createFromByteArray(document, toByteArray(bImage), "image");
+                                        log.warn("FILE: selected x {}, y {}",(float) x, (float) y);
+                                        contentStream.drawImage(pdImage, (float) x, (float) y, (float) width, (float) height);
+                                    } else {
+                                        log.error("BufferedImage is null for file: {}", objetSignatureDto.getFile());
+                                        return "cancel";
+                                    }
+                                } else {
+                                    log.error("No valid image source found for objetSignatureDto: {}", objetSignatureDto);
+                                }
+                            }
+
+
     @Override
     public String modifyPdf(List<SignaturePageDto> signaturePageDtos, DemandeDto demandeDto) {
         String state = "";
@@ -71,10 +203,10 @@ public class UploadServiceImpl implements UploadService {
             try (
                     PDDocument document = PDDocument.load(new File(UPLOAD_DIR+"/"+ filename))) {
                 PDPage page = new PDPage(PDRectangle.A4);
-
                 for (SignaturePageDto signaturePageDto: signaturePageDtos){
                     page = document.getPage(signaturePageDto.getPage());
                     PDPageContentStream contentStream = new PDPageContentStream(document, page, PDPageContentStream.AppendMode.APPEND, true);
+                    log.info("SIZE {}",signaturePageDto.getObjetSignatureDtos().size());
                     if(signaturePageDto.getObjetSignatureDtos().size() > 0){
                         for (ObjetSignatureDto objetSignatureDto:signaturePageDto.getObjetSignatureDtos()){
                             double y = resize(objetSignatureDto.getY(), 0.75);
@@ -111,6 +243,7 @@ public class UploadServiceImpl implements UploadService {
                                 if(!objetSignatureDto.getFileBase64().equals("") || objetSignatureDto.getFileBase64() != null){
                                     byte[] imageBytes = javax.xml.bind.DatatypeConverter.parseBase64Binary(objetSignatureDto.getFileBase64());
                                     BufferedImage bufferedImage = ImageIO.read(new ByteArrayInputStream(imageBytes));
+                                    log.info("document: {} | bufferedImage: {}",document.getDocument(),bufferedImage);
                                     PDImageXObject pdImage = LosslessFactory.createFromImage(document, bufferedImage);
                                     contentStream.drawImage(pdImage, (float) x, (float) y,(float) width,(float) height);
                                 }else if(objetSignatureDto.getFile() != null){
@@ -143,6 +276,7 @@ public class UploadServiceImpl implements UploadService {
         return "cancel";
     }
 
+ */
     private static String identifiant(){
         return UUID.randomUUID().toString();
     }
@@ -158,4 +292,6 @@ public class UploadServiceImpl implements UploadService {
         heigth = heigth * pourcent;
         return heigth;
     }
+
 }
+

src/main/java/bmci/esign/backendend/services/impl/UserServiceImpl.java

@@ -5,12 +5,14 @@ import bmci.esign.backendend.dto.services.IMapClassWithDto;
 import bmci.esign.backendend.models.User;
 import bmci.esign.backendend.repositories.UserRepository;
 import bmci.esign.backendend.services.UserService;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.Optional;
 
 @Service
+@Slf4j
 public class UserServiceImpl implements UserService {
 
     @Autowired
@@ -52,7 +54,8 @@ public class UserServiceImpl implements UserService {
 
     @Override
     public UserDto findByEmail(String email) {
-        User user = userRepository.findByEmail(email);
-        return userMapping.convertToDto(user, UserDto.class);
+        log.info("PROCESSING<>{findByEmail}... REQUEST: {}", email);
+        Optional<User> user = userRepository.findByEmail(email);
+        return user.map(value -> userMapping.convertToDto(value, UserDto.class)).orElse(null);
     }
 }

src/main/resources/application.properties

 spring.application.name=backend-esign
 # App Properties
 spring.mvc.converters.preferred-json-mapper=gson
-server.address=192.168.1.40
+server.address=localhost
 server.servlet.context-path=/esignback
 #server.address=192.168.11.106
 #server.servlet-path=/*
@@ -10,11 +10,11 @@ spring.sql.init.platform= postgres
 #server.ssl.enabled= true
 #spring.datasource.url= jdbc:postgresql://192.168.1.46:5433/esigndb?createDatabaseIfNotExist=true&useSSL=false&serverTimezone=GMT+1:00
 spring.datasource.url= jdbc:postgresql://localhost:5432/esigndb?createDatabaseIfNotExist=true&useSSL=false&serverTimezone=GMT+1:00
-spring.datasource.password= 2011
+spring.datasource.password= admin
 #spring.datasource.password= @sql$23asas
-spring.datasource.username=postgres
+spring.datasource.username=admin
 spring.jpa.database = postgresql
-spring.jpa.show-sql=true
+spring.jpa.show-sql=false
 spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation= true
 spring.jpa.properties.hibernate.dialect= org.hibernate.dialect.PostgreSQLDialect
 
@@ -34,12 +34,15 @@ spring.servlet.multipart.max-request-size=10MB
 
 spring.mail.properties.mail.smtp.auth=true
 spring.mail.properties.mail.smtp.starttls.enable=true
-
+camunda.bpm.admin-user.email=anas@indatacore.com
+camunda.bpm.admin-user.password=123456
 
 
 
 #file.upload-dir.access=/opt/SIGNATURES
-file.upload-dir.access=C:\\Users\\hp\\Documents\\SIGNATURES
+#file.upload-dir.access=C:\\Users\\hp\\Documents\\SIGNATURES
+file.upload-dir.access=/Users/anace/Desktop/InDataCore/bmsi/Documents/SIGNATURES
 
 url.esign.acess=http://localhost:4200/#/online-signature/
 #url.esign.acess=https://skyanalytics.indatacore.com/esign/#/online-signature/
+