com.dominion.salud.pedicom.negocio.service.impl.UsuariosServiceImpl.java Source code

Java tutorial

Introduction

Here is the source code for com.dominion.salud.pedicom.negocio.service.impl.UsuariosServiceImpl.java

Source

/*
 * Copyright (C) 2016 Dominion Global
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package com.dominion.salud.pedicom.negocio.service.impl;

import com.dominion.farmacia.ldap.farmatools.LDAPFarmatools;
import static com.dominion.salud.pedicom.negocio.configuration.CriptoManager.encriptar;
import com.dominion.salud.pedicom.negocio.entities.CabParInt;
import com.dominion.salud.pedicom.negocio.entities.EquiEc;
import com.dominion.salud.pedicom.negocio.entities.EquiEcPK;
import com.dominion.salud.pedicom.negocio.entities.LinParInt;
import com.dominion.salud.pedicom.negocio.entities.LinParIntPK;
import com.dominion.salud.pedicom.negocio.entities.Usuarios;
import com.dominion.salud.pedicom.negocio.repositories.CabParIntRepository;
import com.dominion.salud.pedicom.negocio.repositories.EquiEcRepository;
import com.dominion.salud.pedicom.negocio.repositories.LinParIntRepository;
import com.dominion.salud.pedicom.negocio.repositories.UsuariosRepository;
import com.dominion.salud.pedicom.negocio.service.UsuariosService;
import com.dominion.salud.pedicom.negocio.service.exception.UsuarioIncorrectoException;
import com.dominion.salud.pedicom.negocio.service.exception.UsuarioNoAsociadoACentroException;
import java.util.HashMap;
import java.util.List;
import javax.persistence.NoResultException;
import javax.persistence.NonUniqueResultException;
import javax.servlet.http.HttpSession;
import javax.transaction.Transactional;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 *
 * @author jcgonzalez
 */
@Transactional
@Service("usuariosService")
public class UsuariosServiceImpl extends AbstractServiceImpl<Usuarios, Long> implements UsuariosService {

    private static final Logger logger = LoggerFactory.getLogger(UsuariosServiceImpl.class);

    @Autowired
    private UsuariosRepository usuariosRepository;

    @Autowired
    private CabParIntRepository cabParIntRepository;
    @Autowired
    private LinParIntRepository linParIntRepository;

    @Autowired
    private EquiEcRepository equiEcRepository;

    @Autowired
    private HttpSession session;

    @Override
    public Usuarios validarUsuarios(Usuarios usuarios)
            throws UsuarioIncorrectoException, UsuarioNoAsociadoACentroException, Exception {

        CabParInt cabParInt = cabParIntRepository.getCabParIntByCodigo(new CabParInt("LDAP"));
        if (StringUtils.equals(cabParInt.getActivado(), "S")) {
            logger.debug("Iniciando validacion LDAP");

            LDAPFarmatools ldapFarmatools = new LDAPFarmatools();

            try {
                logger.debug("     Obteniendo parametros de la validacion LDAP");
                boolean LDAP_AD = BooleanUtils.toBoolean(linParIntRepository
                        .getLinParIntByCodInterfaceTipo(new LinParInt(new LinParIntPK("LDAP", "LDAP_AD")))
                        .getParametro());
                String[] LDAP_HOSTS = {
                        linParIntRepository.getLinParIntByCodInterfaceTipo(
                                new LinParInt(new LinParIntPK("LDAP", "LDAP_HOST_1"))).getParametro(),
                        linParIntRepository.getLinParIntByCodInterfaceTipo(
                                new LinParInt(new LinParIntPK("LDAP", "LDAP_HOST_2"))).getParametro(),
                        linParIntRepository.getLinParIntByCodInterfaceTipo(
                                new LinParInt(new LinParIntPK("LDAP", "LDAP_HOST_3"))).getParametro(),
                        linParIntRepository.getLinParIntByCodInterfaceTipo(
                                new LinParInt(new LinParIntPK("LDAP", "LDAP_HOST_4"))).getParametro(),
                        linParIntRepository.getLinParIntByCodInterfaceTipo(
                                new LinParInt(new LinParIntPK("LDAP", "LDAP_HOST_5"))).getParametro(),
                        linParIntRepository.getLinParIntByCodInterfaceTipo(
                                new LinParInt(new LinParIntPK("LDAP", "LDAP_HOST_6"))).getParametro() };
                String LDAP_DOMINIO = linParIntRepository
                        .getLinParIntByCodInterfaceTipo(new LinParInt(new LinParIntPK("LDAP", "LDAP_DOMINIO")))
                        .getParametro();
                String LDAP_USUARIO = linParIntRepository
                        .getLinParIntByCodInterfaceTipo(new LinParInt(new LinParIntPK("LDAP", "LDAP_USUARIO")))
                        .getParametro();
                String LDAP_PASSWORD = linParIntRepository
                        .getLinParIntByCodInterfaceTipo(new LinParInt(new LinParIntPK("LDAP", "LDAP_PASSWORD")))
                        .getParametro();
                String LDAP_RUTA_USUARIOS = linParIntRepository.getLinParIntByCodInterfaceTipo(
                        new LinParInt(new LinParIntPK("LDAP", "LDAP_RUTA_USUARIOS"))).getParametro();

                logger.debug("          LDAP_AD: " + LDAP_AD);
                logger.debug("          LDAP_HOSTS: " + StringUtils.join(LDAP_HOSTS, ","));
                logger.debug("          LDAP_DOMINIO: " + LDAP_DOMINIO);
                logger.debug("          LDAP_USUARIO: " + LDAP_USUARIO);
                logger.debug("          LDAP_PASSWORD: " + LDAP_PASSWORD);
                logger.debug("          LDAP_RUTA_USUARIOS: " + LDAP_RUTA_USUARIOS);
                logger.debug("     Parametros de la validacion LDAP obtenidos correctamente");

                logger.debug("     Validando Usuario LDAP");
                if (ldapFarmatools.validarUsuario(LDAP_AD, LDAP_HOSTS, LDAP_DOMINIO, usuarios.getLoginUsu(),
                        usuarios.getPasswUsu())) {
                    logger.debug("     Usuario LDAP validado correctamente");
                    boolean LDAP_CREAR_USUARIOS = BooleanUtils
                            .toBoolean(linParIntRepository
                                    .getLinParIntByCodInterfaceTipo(
                                            new LinParInt(new LinParIntPK("LDAP", "LDAP_CREAR_USUARIOS")))
                                    .getParametro());
                    if (LDAP_CREAR_USUARIOS && !existeUsuario(usuarios)) {
                        List<EquiEc> equiGrupo = equiEcRepository
                                .findEquiEcByTipo(new EquiEc(new EquiEcPK("GR", "LDP"), "S"));
                        List<EquiEc> equiTipo = equiEcRepository
                                .findEquiEcByTipo(new EquiEc(new EquiEcPK("TG", "LDP"), "S"));

                        boolean ENCRIPTADO = BooleanUtils
                                .toBoolean(linParIntRepository
                                        .getLinParIntByCodInterfaceTipo(
                                                new LinParInt(new LinParIntPK("PEDICOM", "ENCRIPTADO")))
                                        .getParametro());
                        String LDAP_P_MEMBER_OF = linParIntRepository.getLinParIntByCodInterfaceTipo(
                                new LinParInt(new LinParIntPK("LDAP", "LDAP_P_IsMemberOf"))).getParametro();
                        String LDAP_P_UID = linParIntRepository.getLinParIntByCodInterfaceTipo(
                                new LinParInt(new LinParIntPK("LDAP", "LDAP_P_UID"))).getParametro();
                        String LDAP_P_NOMBRE = linParIntRepository.getLinParIntByCodInterfaceTipo(
                                new LinParInt(new LinParIntPK("LDAP", "LDAP_P_NOMBRE"))).getParametro();
                        String LDAP_P_MAIL = linParIntRepository.getLinParIntByCodInterfaceTipo(
                                new LinParInt(new LinParIntPK("LDAP", "LDAP_P_MAIL"))).getParametro();
                        String LDAP_CENTRO = linParIntRepository.getLinParIntByCodInterfaceTipo(
                                new LinParInt(new LinParIntPK("LDAP", "LDAP_CENTRO"))).getParametro();
                        String[] attrs = { LDAP_P_MEMBER_OF, LDAP_P_UID, LDAP_P_NOMBRE, LDAP_P_MAIL };

                        logger.debug("          Creando el usuario: " + usuarios.getLoginUsu() + " en FARMATOOLS");
                        HashMap<String, String> params;

                        logger.debug("               Buscando ATRIBUTOS del usuario: " + LDAP_P_UID + "="
                                + usuarios.getLoginUsu());
                        if (StringUtils.isNotBlank(LDAP_USUARIO) && StringUtils.isNotBlank(LDAP_PASSWORD)) {
                            params = ldapFarmatools.findByQueryAttr(LDAP_AD, LDAP_HOSTS, LDAP_DOMINIO, LDAP_USUARIO,
                                    LDAP_PASSWORD, LDAP_RUTA_USUARIOS, LDAP_P_UID + "=" + usuarios.getLoginUsu(),
                                    attrs);
                        } else {
                            params = ldapFarmatools.findByQueryAttr(LDAP_AD, LDAP_HOSTS, LDAP_DOMINIO,
                                    usuarios.getLoginUsu(), usuarios.getPasswUsu(), LDAP_RUTA_USUARIOS,
                                    LDAP_P_UID + "=" + usuarios.getLoginUsu(), attrs);
                        }
                        logger.debug("               Atributos del usuario");
                        logger.debug(
                                "                    " + LDAP_P_MEMBER_OF + ": " + params.get(LDAP_P_MEMBER_OF));
                        logger.debug("                    " + LDAP_P_UID + ": " + params.get(LDAP_P_UID));
                        logger.debug("                    " + LDAP_P_NOMBRE + ": " + params.get(LDAP_P_NOMBRE));
                        logger.debug("                    " + LDAP_P_MAIL + ": " + params.get(LDAP_P_MAIL));

                        //Creamos el usuario nuevo
                        Usuarios usu = new Usuarios();
                        usu.setLoginUsu(usuarios.getLoginUsu());

                        if (ENCRIPTADO) {
                            usu.setPasswUsu(encriptar(usuarios.getPasswUsu()));
                        } else {
                            usu.setPasswUsu(usuarios.getPasswUsu());
                        }

                        //Nombre del Usuario
                        if (StringUtils.isNotBlank(params.get(LDAP_P_NOMBRE))) {
                            usu.setNombreUsu(params.get(LDAP_P_NOMBRE));
                        } else {
                            usu.setNombreUsu(usuarios.getLoginUsu());
                        }

                        //Valida el centro
                        if (StringUtils.isNotBlank(LDAP_CENTRO)) {
                            logger.debug("               Validando el CENTRO: " + LDAP_CENTRO);
                            if (!StringUtils.contains(params.get(LDAP_P_MEMBER_OF), LDAP_CENTRO)) {
                                logger.error("El atributo: " + LDAP_P_MEMBER_OF + "[" + params.get(LDAP_P_MEMBER_OF)
                                        + "], no contiene el CENTRO: " + LDAP_CENTRO);
                                throw new UsuarioIncorrectoException(
                                        "El usuario no pertenece al centro: " + LDAP_CENTRO + ". Validacion LDAP");
                            }
                        }

                        //Valida el grupo
                        String grupo = "";
                        logger.debug("               Obteniendo el GRUPO del usuario");
                        if (equiGrupo != null && !equiGrupo.isEmpty()) {
                            for (EquiEc equiEc : equiGrupo) {
                                logger.debug("                    Evaluando si el ATRIBUTO: "
                                        + params.get(LDAP_P_MEMBER_OF) + " contiene la EQUIVALENCIA: "
                                        + equiEc.getEquiEcPK().getCodEc() + " del GRUPO: "
                                        + equiEc.getEquiEcPK().getCodFar());
                                if (StringUtils.contains(params.get(LDAP_P_MEMBER_OF),
                                        equiEc.getEquiEcPK().getCodEc())) {
                                    grupo = equiEc.getEquiEcPK().getCodFar();
                                    break;
                                }
                            }
                        }
                        if (StringUtils.isBlank(grupo)) {
                            logger.error("El ATRIBUTO: " + params.get(LDAP_P_MEMBER_OF)
                                    + " no contiene ningun GRUPO de FARMATOOLS");
                            throw new UsuarioIncorrectoException(
                                    "El usuario pertenece a un GRUPO sin acceso a Farmatools. Validacion LDAP");
                        }

                        //Valida el tipo
                        String tipo = "";
                        logger.debug("               Obteniendo el TIPO del usuario");
                        if (equiTipo != null && !equiTipo.isEmpty()) {
                            for (EquiEc equiEc : equiTipo) {
                                logger.debug("                    Evaluando si el ATRIBUTO: "
                                        + params.get(LDAP_P_MEMBER_OF) + " contiene la EQUIVALENCIA: "
                                        + equiEc.getEquiEcPK().getCodEc() + " del TIPO: "
                                        + equiEc.getEquiEcPK().getCodFar());
                                if (StringUtils.contains(params.get(LDAP_P_MEMBER_OF),
                                        equiEc.getEquiEcPK().getCodEc())) {
                                    tipo = equiEc.getEquiEcPK().getCodFar();
                                    break;
                                }
                            }
                        }
                        if (StringUtils.isBlank(tipo)) {
                            logger.error("El ATRIBUTO: " + params.get(LDAP_P_MEMBER_OF)
                                    + " no contiene ningun TIPO de FARMATOOLS");
                            throw new UsuarioIncorrectoException(
                                    "El usuario pertenece a un TIPO sin acceso a Farmatools. Validacion LDAP");
                        }

                        usu.setGrpUsu(grupo);
                        usu.setTipoUsu(tipo);

                        //Graba el usuario
                        try {
                            logger.debug(
                                    "               Creando el usuario: " + usu.getLoginUsu() + " en FARMATOOLS");
                            usuariosRepository.save(usu);
                            logger.debug("               Usuario: " + usu.getLoginUsu()
                                    + " creado correctamente en FARMATOOLS");
                        } catch (Exception e) {
                            logger.warn("No se ha podido almacenar el nuevo usuario: " + e.toString());
                        }
                    }
                } else {
                    logger.error("El usuario no se ha validado correctamente contra LDAP");
                    throw new UsuarioIncorrectoException("El usuario no se ha validado correctamente contra LDAP");
                }
            } catch (Exception e) {
                throw new UsuarioIncorrectoException(
                        "Se han producido errores al realizar la validacion LDAP: " + e.toString());
            }

            try {
                logger.debug("Usuario validado LDAP, comprobando asociacion usuario con centro");
                Usuarios usuariosVal = usuariosRepository.validarCentroUsuarios(usuarios);
                logger.debug("Usuario asociado");
                session.setAttribute("pedicom.usuario", usuariosVal);
                return usuariosVal;
            } catch (NoResultException nre) {
                throw new UsuarioNoAsociadoACentroException(
                        "El usuario no esta asociado al centro: " + nre.toString());
            }
        } else {
            try {
                logger.debug("Comprobando que el usuario existe");
                usuariosRepository.validarUsuarios(usuarios);
                logger.debug("Usuario correcto");
            } catch (NoResultException nre) {
                throw new UsuarioIncorrectoException("Las credenciales no son correctas");
            } catch (NonUniqueResultException nure) {
                throw new UsuarioIncorrectoException("Mas de un usuario con ese login");
            }
            try {
                logger.debug("Comprobando que el usuario esta asociado al centro");
                Usuarios usuariosVal = usuariosRepository.validarCentroUsuarios(usuarios);
                session.setAttribute("pedicom.usuario", usuariosVal);
                logger.debug("Usuario asociado");
                return usuariosVal;
            } catch (NoResultException nre) {
                throw new UsuarioNoAsociadoACentroException("El usuario no esta asociado al centro");
            }
        }
    }

    @Override
    public boolean existeUsuario(Usuarios usuarios) {
        try {
            return usuariosRepository.findUsuariosByLogin(usuarios) != null;
        } catch (Exception e) {
            return false;
        }
    }
}