add fdx-commons and fdx-consultation

Kenmegne

7 days ago 23a46b4be35277e06ec89f48730eeb694e686be8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
package com.megatim.fdxconsultation.core.ifaces.abtracts;
 
import com.megatim.fdxcommons.dao.ifaces.abstracts.AbstractCrudDAO;
import com.megatim.fdxcommons.model.enumeration.TypeOperation;
import com.megatim.fdxconsultation.model.administration.User;
import com.megatim.fdxconsultation.model.base.BaseEntity;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
 
/**
 *
 * @author ASUS
 * @param <T> : Entite reelle
 * @param <K> : Dto
 * @param <ID> : Classe de l'identifiant
 * @param <S> : entité de recherche
 */
public interface AbstractCrudManager<T extends Object, K, ID, S> {
 
    <R extends AbstractCrudDAO<T, ID, S>> R getDao();
 
    K mapToDto(T entity);
 
    default T add(T entity, User connectedUser) {
        beforeAdd(entity, connectedUser);
        if (entity instanceof BaseEntity) {
            BaseEntity baseEntity = (BaseEntity) entity;
            baseEntity.setDateCreation(new Date());
            baseEntity.setTypeOperation(TypeOperation.AJOUTER);
            baseEntity.setUtilisateurCreation(connectedUser != null ? connectedUser.getUserName() : null);
        }
        return getDao().save(entity);
    }
 
    default T update(ID id, T entity, User connectedUser) {
        T refreshEntity = getDao().getById(id);
        beforeUpdate(refreshEntity, entity, connectedUser);
        if (entity instanceof BaseEntity) {
            BaseEntity baseEntity = (BaseEntity) refreshEntity;
            baseEntity.setDateDerniereModification(new Date());
            baseEntity.setUtilisateurModification(connectedUser != null ? connectedUser.getUserName() : null);
        }
        return getDao().save(refreshEntity);
    }
 
    default void delete(ID id, User connectedUser) {
        T entity = getDao().getById(id);
        beforeDelete(entity, connectedUser);
        if (entity instanceof BaseEntity) {
            BaseEntity baseEntity = (BaseEntity) entity;
            baseEntity.setDateSuppression(new Date());
            baseEntity.setUtilisateurSuppression(connectedUser != null ? connectedUser.getUserName() : null);
            baseEntity.setTypeOperation(TypeOperation.SUPPRIMER);
            getDao().save(entity);
        } else {
            getDao().delete(entity);
        }
    }
 
    default void beforeAdd(T entity, User conncectedUser) {
    }
 
    default void beforeDelete(T entity, User conncectedUser) {
    }
 
    void beforeUpdate(T refreshEntity, T entity, User conncectedUser);
 
    public default T getById(ID id) {
        return getDao().getById(id);
    }
 
    public default List<K> findWithPagination(int pageNumber, int pagesize, S searchEntity, User connectedUser) {
        return getDao().findWithPagination(pageNumber, pagesize, searchEntity)
                .stream()
                .map(t -> mapToDto(t))
                .collect(Collectors.toList());
    }
 
    public default List<K> getAll(S searchEntity, User connectedUser) {
        return getDao().getAll(searchEntity)
                .stream()
                .map(t -> mapToDto(t))
                .collect(Collectors.toList());
    }
 
    public default Long count(S searchEntity) {
        return getDao().count(searchEntity);
    }
}