~fstephanie/sources_fdx_api.git

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.OrderByType;
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.model.pojo.OrderByDefinition;
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.RoleManager;
import com.megatim.fdxconsultation.core.ifaces.administration.UserManager;
import com.megatim.fdxconsultation.core.ifaces.message.systeme.MessageSystemeManager;
import com.megatim.fdxconsultation.dao.ifaces.abstracts.PaginationWithCriteriaEntityDAO;
import com.megatim.fdxconsultation.dao.ifaces.abstracts.PaginationWithSearchEnityDAO;
import com.megatim.fdxconsultation.dao.ifaces.administration.RoleDAO;
import com.megatim.fdxconsultation.model.administration.Role;
import com.megatim.fdxconsultation.reporting.model.administration.RoleReporting;
import com.megatim.fdxconsultation.model.administration.User;
import com.megatim.fdxconsultation.model.dto.RoleDto;
import com.megatim.fdxconsultation.model.mappers.MapStructMapper;
import com.megatim.fdxconsultation.model.searchentities.RoleSearch;
import com.megatim.fdxconsultation.tools.CommonsToolsEntity;
import com.megatim.reporting.adhoc.dto.ReportConfiguration;
import com.megatim.rs.tools.utils.RestrictionContainerBuildeUtil;
import java.io.File;
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 javax.enterprise.context.Dependent;
import javax.inject.Inject;
import javax.transaction.Transactional;
 
@Transactional
@Dependent
public class RoleManagerImpl extends AbstractGenericManager<Role, Long>  implements RoleManager {
 
    @Inject
    private RoleDAO dao;
 
    @Inject
    private UserManager userManager;
 
    @Inject
    private MapStructMapper mapstructMapper;
    
    @Inject
    private MessageSystemeManager messageSystemeManager;
 
    public RoleManagerImpl() {
    }
 
    @Override
    public String getEntityIdName() {
        return "id";
    }
 
    public Role getCurrentElement() {
        return dao.getCurrentRole();
    }
 
    public Role saveOrUpdateCurrentElement(Role entityToSave) {
        return dao.save(entityToSave);
    }
 
    public Role getUserByUserName(String libelle){
        List<Role> liste = findByUniqueProperty("libelle", libelle, null);
        if(liste != null && !liste.isEmpty()){
            return liste.get(0);
        }else{
            return null;
        }
    }
    
    @Override
    public void validate(String libelle, User utilisateurConnecte) {
        Role entity = getUserByUserName(libelle);
        if (entity == null) {
            throw new CommonRessourceNotFoundException(Role.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 libelle, Role role, User utilisateurConnecte) {
        Role entity = getUserByUserName(libelle);
        if (entity == null) {
            throw new CommonRessourceNotFoundException(Role.class);
        }
        if (role.getMotifRejet() == null || role.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(role.getMotifRejet());
        beforeModify(entity, role, utilisateurConnecte);
        update(entity.getId(), entity);
        
    }
 
    @Override
    public void beforeModify(Role actualEntity, Role requestEntity, User utilisateurConnecte) {
        if (actualEntity == null) {
            throw new CommonRessourceNotFoundException(Role.class);
        }
 
        //Si ce libelle  existe dejà
        if (requestEntity.getLibelle() != null && !requestEntity.getLibelle().isEmpty() && !findByUniqueProperty("libelle", requestEntity.getLibelle(), null).isEmpty()) {
            //On retourne le message d'erreur
            if (!findByUniqueProperty("libelle", requestEntity.getLibelle(), null).get(0).getLibelle().equals(actualEntity.getLibelle())) {
                throw new CommonAlredyExistException("libelle", "Ce Libelle Existe déjà.");
            }
        }
 
        //On copie les nouvelles valeurs        
        actualEntity.setLibelle(requestEntity.getLibelle());
        actualEntity.setDescription(requestEntity.getDescription());
        actualEntity.setActions(requestEntity.getActions());
 
        actualEntity.setDateDerniereModification(new Date());
        if (utilisateurConnecte != null) {
            actualEntity.setUtilisateurModification(utilisateurConnecte.getUserName());
        }
    }
 
    @Override
    public Role modify(Long id, Role entity, User connectedUser) {
        Role actualEntity = find(getEntityIdName(), id);
        beforeModify(actualEntity, entity, connectedUser);
        update(id, actualEntity);
        notifierMajTousLesUtilisateursGroupeViaWebSocket(actualEntity, "Oups ! il semblerait que vos habilitations aient été mis à jour par l’administrateur, en conséquence vous allez être déconnecté, pour que les modifications soient prises en compte, vous pourrez vous reconnecter par la suite.",
                TypeMessageSysteme.AVERTISSEMENT, TypeIdMessageSysteme.MODIFICATION_GROUPE_UTILISATEUR);
        return actualEntity;
    }
    
    @Override
    public void beforeRemove(Role entity, User utilisateurConnecte) {
        //On marque comme supprimé
        entity.setTypeOperation(TypeOperation.SUPPRIMER);
 
        //On set les informations supplementaires
        entity.setDateSuppression(new Date());
 
        //Si non null
        if (utilisateurConnecte != null) {
 
            //On set les informations supplementaires
            entity.setUtilisateurSuppression(utilisateurConnecte.getUserName());
 
        }
        
        //Si le groupe possède des utilisateurs
        if (entity != null && siPossedeUtilisateurs(entity)) {
            throw new CommonApplicationValidationException("Veuillez au préalable retirer tous les utilisateurs liés à ce groupe, avant de supprimer le groupe.");
        }
       
    }
 
    @Override
    public  Role remove(Long id, User connectedUser) {
        Role entity = find(getEntityIdName(), id);
        beforeRemove(entity, connectedUser);
        Role updatedRole = update(id, entity);
        notifierMajTousLesUtilisateursGroupeViaWebSocket(entity, "Oups ! il semblerait que le groupe utilisateur auquel vous appartennez ait été supprimé par l’administrateur, en conséquence vous allez être déconnecté.",
                TypeMessageSysteme.AVERTISSEMENT, TypeIdMessageSysteme.SUPPRESSION_GROUPE_UTILISATEUR);        
        
        return updatedRole;
    }
    
    @Override
    public void beforeAdd(Role entity, User utilisateurConnecte) {
        //Si ce libelle  existe dejà
        if (entity.getLibelle() != null && !entity.getLibelle().isEmpty() && !findByUniqueProperty("libelle", entity.getLibelle(), null).isEmpty()) {
            //On retourne le message d'erreur
            throw new CommonAlredyExistException("libelle", "Ce libellé existe déjà.");
        }
        entity.setDateCreation(new Date());
        entity.setEtatOperation(EtatOperation.ATTENTE_VALIDATION);
 
        if (utilisateurConnecte != null) {
            //On set les informations supplementaires
            entity.setUtilisateurCreation(utilisateurConnecte.getUserName());
        }
    }
 
    @Override
    public boolean siPossedeUtilisateurs(Role role){
        List<User> utilisateurs = userManager.obtenirListeUtilisateursRole(role);
        boolean bool = false;
        if(utilisateurs.isEmpty()){
            bool = false;
        }else{
            bool = true;
        }        
        return bool;
    }
    
    @Override
    public Class<RoleReporting> getClazz() {
        return RoleReporting.class;
    }
 
    @Override
    public Map<String, Object> getParameters() {
        return new HashMap<>();
    }
 
    @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);
    }
 
    /**
     * Methode permettant de determiner le nombre d'utilisateur d'un groupe
     * @param entity
     * @return 
     */
    @Override
    public Integer obtenirNbreUtilisateurRole(Role entity) {
        List<User> users = null;
        Integer nbreUtilisateurs = 0;
        users = userManager.findByUniqueProperty("role", entity, null);
        if(users != null && !users.isEmpty()){
            nbreUtilisateurs = users.size();
        }
        return nbreUtilisateurs;
    }
    
    /**
     * Permet de notifier les maj via webSocket
     * @param groupe
     * @param message
     * @param typeMessageSysteme 
     * @param typeIdMessageSysteme 
     */
    public void notifierMajTousLesUtilisateursGroupeViaWebSocket(Role groupe, String message, TypeMessageSysteme typeMessageSysteme, TypeIdMessageSysteme typeIdMessageSysteme) {
        
        //Variables
        List<User> utilisateurs = userManager.obtenirListeUtilisateursRole(groupe);
        
        //Si non null
        if(utilisateurs != null && !utilisateurs.isEmpty()){
            
            //On parcourt la liste
            for(User utilisateur : utilisateurs){
                
                //On notifie l'utlisateur
                messageSystemeManager.ajouter(typeMessageSysteme, typeIdMessageSysteme, message, utilisateur);
                
            }
            
        }
        
    }
 
    @Override
    public List<RoleReporting> getDatas(CriteriaEntityFromView searchEntity) throws Exception {
        List<OrderByDefinition> orders = new ArrayList<>();
        orders.add(new OrderByDefinition("id", OrderByType.DESC));
        List<Role> liste = formaterDonnees(findAll(searchEntity, Arrays.asList(), orders));
        return CommonsToolsEntity.convertToRoleReporting(liste);
    }
 
    @Override
    public GenericDAO<Role, Long> getDao() {
        return dao;
    }
 
    @Override
    public RoleDto mapToDto(Role entity) {
        return mapstructMapper.roleToRoleDto(entity);
    }
 
    @Override
    public RoleDto mapToDetailDto(Role entity) {
        return mapstructMapper.roleToRoleDto(entity);
    }
 
    @Override
    public PaginationWithCriteriaEntityDAO<Role, Long> paginationWithCriteriaEntityDAO() {
        return dao;
    }
    
    @Override
    public PaginationWithSearchEnityDAO<Role, Long, RoleSearch> getPaginationDao() {
        return dao;
    }
    
    @Override
    public RestrictionsContainer construireRequete(RoleSearch searchEntity, TypeOperation typeOperation) {
        RestrictionsContainer requeteur = RestrictionContainerBuildeUtil.construireRequete(searchEntity, RoleSearch.class);
        requeteur.addEq("typeOperation", typeOperation);
        return requeteur;
    }
 
    @Override
    public List<Role> formaterDonnees(List<Role> liste) {
        if(liste != null){
            for(Role role : liste){
                role.setNbreUtilisateur(obtenirNbreUtilisateurRole(role));
            }
        }else{
            liste = new ArrayList<Role>();
        }
        return liste;
    }
    
    @Override
    public List<Role> findWithPagination(CriteriaEntityFromView criterion, List<String> fetchEagerFields, List<OrderByDefinition> orderByFields, Integer pageNumber, Integer pageSize) throws Exception {
        List<Role> datas = paginationWithCriteriaEntityDAO().findAll(criterion, fetchEagerFields, orderByFields);
        datas = formaterDonnees(datas);
        return datas;
    }
    
    @Override
    public  List<Role> findAll(CriteriaEntityFromView criterion, List<String> fetchEagerFields, List<OrderByDefinition> orderByFields) throws Exception {
        List<Role> datas = paginationWithCriteriaEntityDAO().findAll(criterion, fetchEagerFields, orderByFields);
        datas = formaterDonnees(datas);
        return datas;
    }
    
    @Override
    public RoleDto getById(Long id) {
        Role entity = find(getEntityIdName(), id);
        return mapToDetailDto(entity);
    }
 
}