From 23a46b4be35277e06ec89f48730eeb694e686be8 Mon Sep 17 00:00:00 2001
From: Kenmegne <stephanie.kenmegne@gmail.com>
Date: Thu, 18 Jun 2026 15:40:06 +0000
Subject: [PATCH] add fdx-commons and fdx-consultation
---
fdx-consultation/fdxconsultation-core-impl/src/main/java/com/megatim/fdxconsultation/core/impl/administration/UserManagerImpl.java | 648 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 648 insertions(+), 0 deletions(-)
diff --git a/fdx-consultation/fdxconsultation-core-impl/src/main/java/com/megatim/fdxconsultation/core/impl/administration/UserManagerImpl.java b/fdx-consultation/fdxconsultation-core-impl/src/main/java/com/megatim/fdxconsultation/core/impl/administration/UserManagerImpl.java
new file mode 100644
index 0000000..c387bd5
--- /dev/null
+++ b/fdx-consultation/fdxconsultation-core-impl/src/main/java/com/megatim/fdxconsultation/core/impl/administration/UserManagerImpl.java
@@ -0,0 +1,648 @@
+package com.megatim.fdxconsultation.core.impl.administration;
+
+import com.bekosoftware.genericdaolayer.dao.ifaces.GenericDAO;
+import com.bekosoftware.genericdaolayer.dao.tools.RestrictionsContainer;
+import com.bekosoftware.genericmanagerlayer.core.impl.AbstractGenericManager;
+import com.megatim.commons.tools.exceptions.ApplicationValidationException;
+import com.megatim.fdxcommons.model.enumeration.EtatOperation;
+import com.megatim.fdxcommons.model.enumeration.TypeIdMessageSysteme;
+import com.megatim.fdxcommons.model.enumeration.TypeMessageSysteme;
+import com.megatim.fdxcommons.model.enumeration.TypeOperation;
+import com.megatim.fdxcommons.model.pojo.CriteriaEntityFromView;
+import com.megatim.fdxcommons.model.pojo.CriteriaFormRequest;
+import com.megatim.fdxcommons.tools.exceptions.CommonAlredyExistException;
+import com.megatim.fdxcommons.tools.exceptions.CommonApplicationValidationException;
+import com.megatim.fdxcommons.tools.exceptions.CommonRessourceNotFoundException;
+import com.megatim.fdxconsultation.core.ifaces.administration.HistoriqueMotDePasseManager;
+import com.megatim.fdxconsultation.core.ifaces.administration.UserManager;
+import com.megatim.fdxconsultation.core.ifaces.message.systeme.MessageSystemeManager;
+import com.megatim.fdxconsultation.core.ifaces.stats.TableauBordManager;
+import com.megatim.fdxconsultation.dao.ifaces.abstracts.PaginationWithCriteriaEntityDAO;
+import com.megatim.fdxconsultation.dao.ifaces.administration.UserDAO;
+import com.megatim.fdxconsultation.model.administration.Action;
+import com.megatim.fdxconsultation.model.administration.Role;
+import com.megatim.fdxconsultation.model.administration.User;
+import com.megatim.fdxconsultation.reporting.model.administration.UserReporting;
+import com.megatim.fdxconsultation.model.dto.EditPasswordDto;
+import com.megatim.fdxconsultation.model.dto.UserDto;
+import com.megatim.fdxconsultation.model.dto.UserSlimDto;
+import com.megatim.fdxconsultation.model.mappers.MapStructMapper;
+import com.megatim.fdxconsultation.model.searchentities.UserSearch;
+import com.megatim.fdxconsultation.tools.CommonTools;
+import com.megatim.fdxconsultation.tools.CommonsToolsEntity;
+import com.megatim.fdxconsultation.tools.context.AppCommonContext;
+import com.megatim.reporting.adhoc.dto.ReportConfiguration;
+import com.megatim.rs.tools.utils.RestrictionContainerBuildeUtil;
+import java.io.File;
+import java.math.BigDecimal;
+import java.security.NoSuchAlgorithmException;
+import java.security.spec.InvalidKeySpecException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import javax.enterprise.context.Dependent;
+import javax.inject.Inject;
+import javax.transaction.Transactional;
+
+@Transactional
+@Dependent
+public class UserManagerImpl extends AbstractGenericManager<User, Long> implements UserManager {
+
+ @Inject
+ protected UserDAO dao;
+
+ @Inject
+ protected HistoriqueMotDePasseManager historiqueMotDePasseManager;
+
+ @Inject
+ private MapStructMapper mapstructMapper;
+
+ @Inject
+ com.megatim.fdxcommons.model.mappers.MapStructMapper commonMapper;
+
+ @Inject
+ TableauBordManager tableauBordManager;
+
+ @Inject
+ private MessageSystemeManager messageSystemeManager;
+
+ /**
+ *
+ */
+ public UserManagerImpl() {
+ }
+
+ @Override
+ public GenericDAO<User, Long> getDao() {
+ return dao;
+ }
+
+ @Override
+ public String getEntityIdName() {
+ return "id";
+ }
+
+ @Override
+ public UserDto getById(Long id) {
+ return mapToDetailDto(dao.getById(id));
+ }
+
+ public User getCurrentElement() {
+ return dao.getCurrentUser();
+ }
+
+ @Override
+ @Transactional
+ public User modify(Long id, User entity, User connectedUser) {
+ User actualEntity = find(getEntityIdName(), id);
+ beforeModify(actualEntity, entity, connectedUser);
+ update(id, actualEntity);
+ tableauBordManager.deleteUserTableauBord(entity);
+ messageSystemeManager.ajouter(TypeMessageSysteme.AVERTISSEMENT, TypeIdMessageSysteme.MODIFICATION_INFORMATION_UTILISATEUR, "Oups ! il semblerait que vos paramètres personnels aient été mis à jour, en conséquence vous allez être déconnecté, pour que les modifications soient prises en compte, vous pourrez vous reconnecter par la suite.", actualEntity);
+ return actualEntity;
+ }
+
+ @Override
+ public User recuperUtilisateur(String username, String motDePasse) {
+ return dao.recuperUtilisateur(username, motDePasse);
+ }
+
+ @Override
+ public User recuperUtilisateur(String username) {
+ return dao.recuperUtilisateur(username);
+ }
+
+ public User getUserByUserName(String userName) {
+ List<User> liste = findByUniqueProperty("userName", userName, null);
+ if (liste != null && !liste.isEmpty()) {
+ return liste.get(0);
+ } else {
+ return null;
+ }
+ }
+
+ @Override
+ public void validate(String userName, User utilisateurConnecte) {
+ User entity = getUserByUserName(userName);
+ if (entity == null) {
+ throw new CommonRessourceNotFoundException(User.class);
+ }
+ entity.setEtatOperation(EtatOperation.ACTIF);
+ entity.setDateValidation(new Date());
+ entity.setUtilisateurValidation(utilisateurConnecte != null ? utilisateurConnecte.getUserName() : null);
+ update(entity.getId(), entity);
+ }
+
+ @Override
+ public void reject(String userName, User user, User utilisateurConnecte) {
+ User entity = getUserByUserName(userName);
+ if (entity == null) {
+ throw new CommonRessourceNotFoundException(User.class);
+ }
+ if (user.getMotifRejet() == null || user.getMotifRejet().isEmpty()) {
+ throw new ApplicationValidationException(Arrays.asList("Le motif de rejet est obligatoire"));
+ }
+ entity.setEtatOperation(EtatOperation.REJETE);
+ entity.setDateRejetValidation(new Date());
+ entity.setUtilisateurRejetValidation(utilisateurConnecte != null ? utilisateurConnecte.getUserName() : null);
+ entity.setMotifRejet(user.getMotifRejet());
+ update(entity.getId(), entity);
+ }
+
+ @Override
+ public UserSlimDto mapToDto(User entity) {
+ return mapstructMapper.userToUserSlimDto(entity);
+ }
+
+ @Override
+ public UserDto mapToDetailDto(User entity) {
+ return mapstructMapper.userToUserDto(entity);
+ }
+
+ @Override
+ public void beforeModify(User actualEntity, User requestEntity, User utilisateurConnecte) {
+ if (actualEntity == null) {
+ throw new CommonRessourceNotFoundException(User.class);
+ }
+ User userWithSameName = recuperUtilisateur(requestEntity.getUserName());
+ if (requestEntity.getUserName() != null && !requestEntity.getUserName().isEmpty() && userWithSameName != null
+ && !requestEntity.getId().equals(userWithSameName.getId())) {
+ throw new CommonAlredyExistException("username", "Un utilisateur avec le même login existe déjà.");
+ }
+ if (requestEntity.isUpdatePassword()) {
+ actualEntity.setPwd(CommonTools.encryptPassword(requestEntity.getPwd()));
+ }
+ actualEntity.setDateDerniereModification(new Date());
+ if (utilisateurConnecte != null) {
+ actualEntity.setUtilisateurModification(utilisateurConnecte.getUserName());
+ }
+ validerMotDePasseModifier(requestEntity.isUpdatePassword(), requestEntity.getPwd(), actualEntity);
+ checkerParticipants(requestEntity);
+ actualEntity.setAlertDelay(requestEntity.getAlertDelay());
+ actualEntity.setAttemps(requestEntity.getAttemps());
+ actualEntity.setAttempsNumber(requestEntity.getAttempsNumber());
+ actualEntity.setConnected(requestEntity.isConnected());
+ actualEntity.setExpirationDelay(requestEntity.getExpirationDelay());
+ actualEntity.setFirstName(requestEntity.getFirstName());
+ actualEntity.setLastName(requestEntity.getLastName());
+ actualEntity.setLocked(requestEntity.isLocked());
+ actualEntity.setActive(requestEntity.isActive());
+ actualEntity.setRole(requestEntity.getRole());
+ actualEntity.setTypeFichiers(requestEntity.getTypeFichiers());
+ actualEntity.setParticipants(requestEntity.getParticipants());
+ }
+
+ @Override
+ public void beforeRemove(User entity, User utilisateurConnecte) {
+ entity.setTypeOperation(TypeOperation.SUPPRIMER);
+ entity.setDateSuppression(new Date());
+ if (utilisateurConnecte != null) {
+ entity.setUtilisateurSuppression(utilisateurConnecte.getUserName());
+ }
+ }
+
+ @Override
+ public void beforeAdd(User entity, User utilisateurConnecte) {
+ if (entity.getUserName() != null && !entity.getUserName().isEmpty() && recuperUtilisateur(entity.getUserName()) != null) {
+ throw new CommonAlredyExistException("userName", "Un utilisateur avec le même nom utilisateur existe déjà.");
+ }
+ checkerSiMotDePasseComplexe(true, entity.getPwd());
+ checkerParticipants(entity);
+ entity.setPwd(CommonTools.encryptPassword(entity.getPwd()));
+ entity.setDateCreation(new Date());
+ entity.setEtatOperation(EtatOperation.ATTENTE_VALIDATION);
+ entity.setDateDerniereModificationMotDePasse(new Date());
+ if (utilisateurConnecte != null) {
+ entity.setUtilisateurCreation(utilisateurConnecte.getUserName());
+ }
+ }
+
+ @Override
+ public User remove(Long id, User connectedUser) {
+ User entity = find(getEntityIdName(), id);
+ beforeRemove(entity, connectedUser);
+ User updatedUser = update(id, entity);
+ messageSystemeManager.ajouter(TypeMessageSysteme.ERREUR, TypeIdMessageSysteme.SUPPRESSION_COMPTE_UTILISATEUR, "Oups ! il semblerait que votre compte utilisateur ait été supprimé, en conséquence vous allez être déconnecté.", entity);
+
+ return updatedUser;
+ }
+
+ /**
+ * Methode permettant d'effectuer des controles sur les participants (sur la
+ * présence ou non)
+ *
+ * @param utilisateur
+ */
+ private void checkerParticipants(User utilisateur) {
+
+ /* Si non null */
+ if (utilisateur != null && utilisateur.getRole() != null) {
+
+ /* On parcourt la liste des actions */
+ for (Action action : utilisateur.getRole().getActions()) {
+
+ /* Si actions liées à génération des mot de passe pour l'API sont présents */
+ if ((action.getModule().equalsIgnoreCase(AppCommonContext.MODULE_ADMINISTRATION)
+ && action.getPath().equalsIgnoreCase(AppCommonContext.PATH_API_TOKEN))
+ && (utilisateur.getParticipants() == null || utilisateur.getParticipants().isEmpty())) {
+
+ /* On lève l'exception */
+ //throw new ApplicationValidationException(Arrays.asList("Veuillez sélectionner au moins un participant"));
+ }
+
+ }
+
+ }
+
+ }
+
+ @Override
+ public Class<UserReporting> getClazz() {
+ return UserReporting.class;
+ }
+
+ @Override
+ public Map<String, Object> getParameters() {
+ return new HashMap<>();
+ }
+
+ @Override
+ public List<UserReporting> getDatas(CriteriaEntityFromView searchEntity) throws Exception {
+ return CommonsToolsEntity.convertToUserReporting(findAll(searchEntity, Arrays.asList(), Arrays.asList()));
+ }
+
+ @Override
+ public File printAll(ReportConfiguration<CriteriaFormRequest> reportConfiguration, User userConnected) throws Exception {
+ return generatePdf(finalReportConfiguration(reportConfiguration), userConnected, false);
+ }
+
+ @Override
+ public File printOne(ReportConfiguration<CriteriaFormRequest> reportConfiguration, User userConnected) throws Exception {
+ return generatePdf(finalReportConfiguration(reportConfiguration), userConnected, true);
+ }
+
+ @Override
+ public File exportExcelAll(ReportConfiguration<CriteriaFormRequest> reportConfiguration, User userConnected) throws Exception {
+ return exportExcel(finalReportConfiguration(reportConfiguration), userConnected, false);
+ }
+
+ @Override
+ public File exportExcelOne(ReportConfiguration<CriteriaFormRequest> reportConfiguration, User userConnected) throws Exception {
+ return exportExcel(finalReportConfiguration(reportConfiguration), userConnected, true);
+ }
+
+ /**
+ * Permet de recuperer un utilisateur via son id
+ *
+ * @param id
+ * @return
+ */
+ @Override
+ public User findById(Long id) {
+ return find(getEntityIdName(), id);
+ }
+
+ /**
+ * Permet de checker si un mot de passe saisi est complexe
+ *
+ * @param motDePasse
+ */
+ private void checkerSiMotDePasseComplexe(boolean siMotDePasseModifier, String motDePasse) {
+
+ //Variables
+ String erreurs = null;
+
+ //Si mot de passe editer
+ if (siMotDePasseModifier) {
+
+ if (motDePasse != null && !motDePasse.isEmpty() && !motDePasse.matches("^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#&()–[{}]:;',?/*~$^+=<>]).{8,20}$")) {
+ erreurs = "Le mot de passe doit contenir :"
+ + " \n\t - Au moins un chiffre"
+ + " \n\t - Au moins une minuscule"
+ + " \n\t - Au moins une majuscule"
+ + " \n\t - Au moins un caractère special (! @ # & ( ))"
+ + " \n\t - Au moins 8 caractères et 20 caractères maximum";
+ };
+
+ //Si erreurs
+ if (erreurs != null && !erreurs.isEmpty()) {
+ throw new CommonApplicationValidationException(erreurs);
+ }
+
+ }
+
+ }
+
+ /**
+ * Permet d'effectuer certains controle après la modification du mot de
+ * passe
+ *
+ * @param siMotDePasseModifier
+ * @param nouveauMotDepasse
+ * @param user
+ */
+ private void validerMotDePasseModifier(boolean siMotDePasseModifier, String nouveauMotDepasse, User user) {
+
+ //Si mot de passe modifié
+ if (siMotDePasseModifier) {
+
+ //Si mot de passe dejà utilisé
+ checkerSiMotDePasseDejaUtilise(nouveauMotDepasse, user);
+
+ //Si mot de passe complexe
+ checkerSiMotDePasseComplexe(siMotDePasseModifier, nouveauMotDepasse);
+
+ //On set la date de derniere modification
+ user.setDateDerniereModificationMotDePasse(new Date());
+
+ }
+
+ }
+
+ /**
+ * Permet de checker si un mot de passe a deja été utilsé
+ *
+ * @param motDePasse
+ * @param user
+ */
+ private void checkerSiMotDePasseDejaUtilise(String motDePasse, User user) {
+ if (historiqueMotDePasseManager.siMotDePasseExiste(motDePasse, user)) { //Si mot de passe déjà utilisé
+ throw new CommonApplicationValidationException("Ce mot de passe correspond à un mot de passe que vous avez déjà utilisé, veuillez en saisir un autre.");
+ } else { //Sinon on enregistre
+ historiqueMotDePasseManager.ajouter(CommonTools.encryptPassword(motDePasse), user);
+ }
+ }
+
+ @Override
+ public void editPassword(String username, EditPasswordDto editPasswordDto) {
+ if (!editPasswordDto.getNewPassword().equals(editPasswordDto.getNewPasswordConfirm())) {
+ throw new CommonApplicationValidationException("Le nouveau mot de passe et le mote de passe de confirmation ne sont pas identiques.");
+ }
+ User user = recuperUtilisateur(username);
+ if (user == null) {
+ throw new CommonApplicationValidationException("Imposssible d'effectuer l'action: utilisateur non reconnu");
+ }
+ try {
+ if (!CommonTools.validerMotDePasse(editPasswordDto.getActualPassword(), user.getPwd())) {
+ throw new CommonApplicationValidationException("Le mot de passe actuel est incorrect");
+ }
+ } catch (NoSuchAlgorithmException | InvalidKeySpecException ex) {
+ throw new CommonApplicationValidationException("Impossible d'effectuer l'opération une erreur interne du serveur s'est produite");
+ }
+ validerMotDePasseModifier(true, editPasswordDto.getNewPassword(), user);
+ user.setPwd(CommonTools.encryptPassword(editPasswordDto.getNewPassword()));
+ update(user.getId(), user);
+ }
+
+ @Override
+ public List<String> validerParametresConnexion(String username, String password) {
+
+ //Variables
+ List<String> errors = new ArrayList<>();
+ User user = recuperUtilisateur(username, password);
+
+ //Si null
+ if (user == null) {
+
+ //On recupère l'utilisateur via son login
+ user = recuperUtilisateur(username);
+
+ //Si non null et non administrateurs
+ if (user != null && !(user.getRole().getAdmin() || user.getRole().getMegaAdmin() || user.getRole().getSuperAdmin())) {
+
+ //Si le nombre de tentatives est depassé
+ if (user.getAttemps() >= user.getAttempsNumber()) {
+
+ //Si compte pas encore verrouillé
+ if (!user.isLocked()) {
+
+ //On verrouille le compte
+ user.setLocked(true);
+
+ }
+
+ //On met à jour
+ update(user.getId(), user);
+
+ //On lève l'exeption
+ errors.add("Suite à l'echec des " + user.getAttempsNumber() + " tentative(s) de connexions à ce compte, ce dernier a été verrouillé. "
+ + "\n Veuillez contacter l'administrateur.");
+
+ } else {
+
+ //On comptabilise le nombre de tentatives
+ user.setAttemps(user.getAttemps() + 1);
+
+ //On met à jour
+ update(user.getId(), user);
+
+ //Si nbre tentatives > 0
+ if ((user.getAttempsNumber() - user.getAttemps()) > 0) {
+
+ //On lève l'exeption
+ errors.add("Login ou mot de passe incorrect, Il vous reste (" + ((user.getAttempsNumber() - user.getAttemps())) + ") tentative(s)");
+
+ } else {
+
+ //Si compte pas encore verrouillé
+ if (!user.isLocked()) {
+
+ //On verrouille le compte
+ user.setLocked(true);
+
+ }
+
+ //On met à jour
+ update(user.getId(), user);
+
+ //On lève l'exeption
+ errors.add("Suite à l'echec des " + user.getAttempsNumber() + " tentative(s) de connexions à ce compte, ce dernier a été verrouillé. "
+ + "\n Veuillez contacter l'administrateur.");
+
+ }
+
+ }
+
+ } else {
+
+ //On lève l'exeption
+ errors.add("Login ou mot de passe incorrect.");
+
+ }
+
+ } else {
+
+ //Ces controles ne concernent pas les administrateurs par defauts
+ if (!(user.getRole().getAdmin() || user.getRole().getMegaAdmin() || user.getRole().getSuperAdmin())) {
+
+ if (user.getEtatOperation() != EtatOperation.ACTIF) { //Si compte non actif
+
+ //On lève l'exeption
+ errors.add("Compte non activé.\n Veuillez contacter l'administrateur.");
+
+ } else if (user.isLocked()) { //Si compte verrouillé
+
+ //On lève l'exeption
+ errors.add("Compte verrouillé.\n Veuillez contacter l'administrateur.");
+
+ }
+
+ //On calcule le nbre de jour restant avant expiration du mot de passe
+ calculerNbreJoursAvantExpirationMotDePasse(user);
+
+ //On verifie si le mot de passe a expiré
+ checkerExpirationMotDePasse(user);
+
+ //On reset le nombre de tentatives
+ user.setAttemps(0);
+
+ //On met à jour
+ update(user.getId(), user);
+
+ } else {
+
+ //On calcule le nbre de jour restant avant expiration du mot de passe
+ calculerNbreJoursAvantExpirationMotDePasse(user);
+
+ //On verifie si le mot de passe a expiré
+ checkerExpirationMotDePasse(user);
+
+ //On met à jour
+ update(user.getId(), user);
+
+ }
+
+ }
+
+ return errors;
+ }
+
+ /**
+ * Permet de determiner si la delai d'expiration mot de passe est arrivé
+ *
+ * @param user
+ */
+ public void checkerExpirationMotDePasse(User user) {
+
+ //Si mot de passe expiré
+ if (siDelaiExpirationArrive(user)) {
+
+ //On ajoute à la pile des messages système
+ messageSystemeManager.ajouter(TypeMessageSysteme.AVERTISSEMENT, TypeIdMessageSysteme.MOT_DE_PASSE_EXPIRE, "Votre mot de passe a expiré, veuillez le modifier.", user);
+
+ }
+
+ }
+
+ /**
+ * Permet de determiner si la delai expiration mot de passe arrivé
+ *
+ * @param user
+ */
+ public boolean siDelaiExpirationArrive(User user) {
+
+ //Variables
+ Date dateFuturExpirationMotDePasse = null;
+ Date dateCourante = new Date();
+
+ //Si egal à zero (n'expire jamais)
+ if (user.getExpirationDelay() == 0) {
+ return false;
+ } else {
+
+ //On calcule la date d'expiration
+ dateFuturExpirationMotDePasse = CommonTools.addDay(user.getDateDerniereModificationMotDePasse(), user.getExpirationDelay());
+
+ //On compare si la date courante est supérieur ou égale à la date d'expiration
+ if (dateCourante.getTime() >= dateFuturExpirationMotDePasse.getTime()) {
+ return true;
+ } else {
+ return false;
+ }
+
+ }
+
+ }
+
+ /**
+ * Cette methode permet de calculer le nombre de jours avant expiration du
+ * mot de passe
+ *
+ * @param utilisateur
+ */
+ private void calculerNbreJoursAvantExpirationMotDePasse(User utilisateur) {
+
+ //Variables
+ Date dateFuturExpirationMotDePasse = null;
+ Date dateCourante = new Date();
+ long difference = 0l;
+ Integer nbreJoursRestant = 0;
+ String message = "";
+
+ //Si egal à zero (n'expire jamais)
+ if (utilisateur.getExpirationDelay() > 0) {
+
+ //On calcule la date d'expiration
+ dateFuturExpirationMotDePasse = CommonTools.addDay(utilisateur.getDateDerniereModificationMotDePasse(), utilisateur.getExpirationDelay());
+
+ //On compare si la date courante est inferieur ou egale à la date d'expiration
+ if (dateCourante.getTime() < dateFuturExpirationMotDePasse.getTime()) {
+
+ //On calcule la difference en milli seconde
+ difference = dateFuturExpirationMotDePasse.getTime() - dateCourante.getTime();
+
+ //On recupere le nombre de jours restant avant expiration
+ nbreJoursRestant = new BigDecimal(TimeUnit.DAYS.convert(difference, TimeUnit.MILLISECONDS)).intValue();
+
+ //Si le nbre jours restant est inferieur ou egal au seuil d'alerte
+ if (nbreJoursRestant <= utilisateur.getAlertDelay()) {
+
+ //Si nbre jour == 0,
+ switch (nbreJoursRestant) {
+ case 0:
+ //On recupere le message
+ message = "Votre mot de passe expire aujourd'hui, pensez à le modifier";
+ break;
+ case 1:
+ //On recupere le message
+ message = "Votre mot de passe expire demain, pensez à le modifier";
+ break;
+ default:
+ //On recupere le message
+ message = "Votre mot de passe expire dans (" + CommonTools.formaterChiffreAvecZeroDevant(nbreJoursRestant) + ") jour(s), \n Pensez à le modifier.";
+ break;
+ }
+
+ //On ajoute à la pile des messages système
+ messageSystemeManager.ajouter(TypeMessageSysteme.AVERTISSEMENT, TypeIdMessageSysteme.ALERTE_MOT_DE_PASSE_EXPIRE, message, utilisateur);
+
+ }
+
+ }
+
+ }
+
+ }
+
+ @Override
+ public List<User> obtenirListeUtilisateursRole(Role role) {
+ return dao.obtenirListeUtilisateursRole(role);
+ }
+
+ @Override
+ public PaginationWithCriteriaEntityDAO<User, Long> paginationWithCriteriaEntityDAO() {
+ return dao;
+ }
+
+ @Override
+ public RestrictionsContainer construireRequete(UserSearch searchEntity, TypeOperation typeOperation) {
+ RestrictionsContainer requeteur = RestrictionContainerBuildeUtil.construireRequete(searchEntity, UserSearch.class);
+ requeteur.addEq("typeOperation", typeOperation);
+ return requeteur;
+ }
+
+}
--
Gitblit v1.10.0