src/Controller/UsuariosProcesosTrait.php line 1493

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use Symfony\Bridge\Twig\Mime\TemplatedEmail;
  6. use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
  7. use Symfony\Component\Mime\Address;
  9. use App\Service\FuncionesIvtcotizador;
  10. use App\Entity\Clientes;
  11. use App\Entity\Funciones;
  12. use App\Entity\Usuarios;
  13. use App\Entity\Usuariosavisos;
  14. use App\Entity\Usuarioubicaciones;
  15. use App\Entity\Logusuario;
  16. use App\Entity\Perfiles;
  17. use App\Entity\Perfilfunciones;
  18. use App\Entity\Usuariosfavoritos;
  19. use App\Repository\ClientefuncionesRepository;
  20. use App\Repository\ClientesRepository;
  21. use App\Repository\FuncionesRepository;
  22. use App\Repository\OrigenesRepository;
  23. use App\Repository\PerfilesRepository;
  24. use App\Repository\PerfilfuncionesRepository;
  25. use App\Repository\SeccionesRepository;
  26. use App\Repository\UbicacionesRepository;
  27. use App\Repository\UsuariosavisosRepository;
  28. use App\Repository\UsuariosfavoritosRepository;
  29. use App\Repository\UsuariosRepository;
  30. use App\Repository\UsuarioubicacionesRepository;
  32. trait UsuariosProcesosTrait
  33. {
  34.     /**
  35.      * Method procUsuariosUsuarios
  36.      *
  37.      * @param array $paraProceso
  38.      *
  39.      * @return array
  40.      */
  41.     private function procUsuariosUsuarios($paraProceso): array
  42.     {
  43.         $cliente = $paraProceso['cliente'];
  44.         $registry = $paraProceso['registry'];
  45.         $requestStack = $paraProceso['requestStack'];
  47.         $usuariosRepo = new UsuariosRepository($registry, $requestStack);
  48.         $perfilesRepo = new PerfilesRepository($registry);
  49.         $fi = new FuncionesIvtcotizador();
  50.         ///
  51.         $controladorA = explode('\\', get_called_class());
  52.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  53.         $rotulos = [
  54.             "titulo" => $_n['Usuarios'] ?? 'Usuarios',
  55.             'exportar' => $_n['exportar'] ?? 'Exportar',
  56.             'nuevo' => $_n['nuevo'] ?? 'Nuevo',
  57.             'claUsuario' => $_n['claUsuario'] ?? 'Usuario',
  58.             'eliminar' => $_n['eliminar'] ?? 'Eliminar',
  59.             'totalDeUsuarios' => $_n['totalDeUsuarios'] ?? 'Total de Usuarios',
  60.             'nomUsuario' => $_n['nomUsuario'] ?? 'Nombre de Usuario',
  61.             'acceso' => $_n['acceso'] ?? 'Acceso',
  62.             'normal' => $_n['normal'] ?? 'Normal',
  63.             'movil' => $_n['movil'] ?? 'Móvil',
  64.             'recolectorDeDatos' => $_n['recolectorDeDatos'] ?? 'Recolector de datos',
  65.             'cambiarContrasena' => $_n['cambiarContrasena'] ?? 'Cambiar Contraseña',
  66.             'nomPerfil' => $_n['nomPerfil'] ?? 'Perfil',
  67.             'nomTipo' => $_n['nomTipo'] ?? 'Acceso',
  68.             'activar' => $_n['activar'] ?? 'Activar',
  69.             'activarTip' => $_n['activarTip'] ?? 'Activa al usuario seleccionado',
  70.             'activarConfirmar' => $_n['activarConfirmar'] ?? '¿Está seguro de querer activar a este usuario?',
  71.             'desactivar' => $_n['desactivar'] ?? 'Desactivar',
  72.             'desactivarTip' => $_n['desactivarTip'] ?? 'Desactiva al usuario seleccionado',
  73.             'desactivarConfirmar' => $_n['desactivarConfirmar'] ?? '¿Está seguro de querer desactivar a este usuario?',
  74.             'cambiarContra' => $_n['cambiarContra'] ?? 'Cambiar contraseña',
  75.             'cambiarContraTip' => $_n['cambiarContraTip'] ?? 'Cambia la contraseña del usuario seleccionado',
  76.             'avisos' => $_n['avisos'] ?? 'Configuración de avisos',
  77.             'avisosTip' => $_n['avisosTip'] ?? 'Cambia la configuración de avisos del usuario seleccionado',
  78.             'fecha' => $_n['fecha'] ?? 'Fecha',
  79.         ];
  81.         $valoresDB = $usuariosRepo->findForGrid($cliente);
  82.         $perfiles = $perfilesRepo->findForClaCatalogoIndiceEsClave($cliente);
  83.         $tipos = $usuariosRepo->findForClaTipo($cliente);
  84.         $mostrarCuales = [Usuarios::_claTipoNormal, Usuarios::_claTipoMovil, Usuarios::_claTipoRecolectorDatos];
  86.         $valores = [];
  87.         $enLista = ['claUsuario', 'nomUsuario', 'id', 'claPerfil', 'claTipo', 'activo'];
  88.         $cuentas = [];
  89.         foreach ($valoresDB as $x => $campos) {
  90.             $mostrar = false;
  91.             $array = [];
  92.             foreach ($campos as $y => $campo) {
  93.                 if (in_array($campo['alias'], $enLista)) {
  94.                     $array[$campo['alias']] = $campo['valor'];
  95.                 }
  96.                 //perfil
  97.                 if ($campo['alias'] == 'claPerfil') {
  98.                     $array['nomPerfil'] = $perfiles[$campo['valor']] ?? '';
  99.                 }
  100.                 //tipo
  101.                 if ($campo['alias'] == 'claTipo') {
  102.                     $array['nomTipo'] = $tipos[$campo['valor']] ?? '';
  103.                     if (in_array($campo['valor'], $mostrarCuales)) {
  104.                         $mostrar = true;
  105.                     }
  106.                 }
  108.                 $array['eliminar'] = true;
  109.                 if ($campo['alias'] == 'claUsuario') {
  110.                     $cuentas[$campo['valor']] = 0;
  111.                 }
  112.             }
  113.             if ($mostrar) {
  114.                 $valores[] = $array;
  115.             }
  116.         }
  118.         foreach ($valores as $v => $valor) {
  119.             $claUsuario = $valor["claUsuario"];
  120.             $cuenta = 0;
  121.             if (isset($cuentas[$claUsuario])) {
  122.                 $cuenta = $cuentas[$claUsuario];
  123.             }
  124.             if ($cuenta > 0) {
  125.                 $valores[$v]['eliminar'] = false;
  126.             }
  127.         }
  128.         ///
  129.         $html = [
  130.             "titulo" => $rotulos["titulo"],
  131.         ];
  132.         ///
  133.         $generales = [];
  134.         $generales['fecha'] = date($fi->getFormatoFecha(1) , $fi->ivtCotizadorTiempo());
  135.         ///
  136.         $catalogos = [];
  137.         //la data
  138.         $data = [];
  139.         $data['generales'] = $generales;
  140.         $data['rotulos'] = $rotulos;
  141.         $data['html'] = $html;
  142.         $data['valores'] = $valores;
  143.         $data['catalogos'] = $catalogos;
  144.         return $data;
  145.     }
  146.     /**
  147.      * Method procUsuariosEditar
  148.      *
  149.      * @param array $paraProceso
  150.      *
  151.      * @return array
  152.      */
  153.     private function procUsuariosEditar($paraProceso): array
  154.     {
  155.         $registry = $paraProceso['registry'];
  156.         $requestStack = $paraProceso['requestStack'];
  157.         $sesion = $paraProceso['sesion'];
  158.         $usuariosRepo = new UsuariosRepository($registry, $requestStack);
  159.         $perfilesRepo = new perfilesRepository($registry);
  160.         $ubicacionesRepo = new UbicacionesRepository($registry);
  161.         $cliente = $paraProceso['cliente'];
  162.         $claUsuario = $paraProceso['claUsuario'];
  163.         $fi = new FuncionesIvtcotizador();
  164.         ///
  165.         $generales = [];
  166.         $generales['claUsuario'] = $claUsuario;
  167.         $generales['nuevo'] = strlen($claUsuario) > 0 ? self::_editar : self::_nuevo;
  168.         $generales['multiUbicacion'] = isset($sesion->get('parametros')['MultiUbicacion']) ? $sesion->get('parametros')['MultiUbicacion'] : '0';
  169.         ///
  170.         $controladorA = explode('\\', get_called_class());
  171.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  172.         $rotulos = [
  173.             'nuevoUsuario' => $_n['nuevoUsuario'] ?? 'Nuevo Usuario',
  174.             'editarUsuario' => $_n['editarUsuario'] ?? 'Modificar Usuario',
  175.             'cancelar' => $_n['cancelar'] ?? 'Cancelar',
  176.             'nomUsuario' => $_n['nomUsuario'] ?? 'Usuario',
  177.             'claUsuario' => $_n['claUsuario'] ?? 'Clave',
  178.             'correo' => $_n['correo'] ?? 'Correo',
  179.             'contra' => $_n['contra'] ?? 'Contraseña',
  180.             'confirmacion' => $_n['confirmacion'] ?? 'Confirmación',
  181.             'guardar' => $_n['guardar'] ?? 'Guardar',
  182.             'nomUsuarioAviso' => $_n['nomUsuarioAviso'] ?? 'Indique el usuario',
  183.             'claUsuarioAviso' => $_n['claUsuarioAviso'] ?? 'Indique la clave de usuario',
  184.             'correoAviso' => $_n['correoAviso'] ?? 'Indique un correo válido',
  185.             'contraAviso' => $_n['contraAviso'] ?? 'Indique la contraseña',
  186.             'confirmacionAviso' => $_n['confirmacionAviso'] ?? 'Indique la confirmación',
  187.             'noCoinciden' => $_n['noCoinciden'] ?? 'La contraseña y la confirmación no coinciden',
  188.             'error' => $_n['error'] ?? 'Revise los campos',
  189.             'ubicacion' => $_n['ubicacion'] ?? 'Ubicación',
  190.             'region' => $_n['region'] ?? 'Región',
  191.             'centro' => $_n['centro'] ?? 'Centro',
  192.             'nomTipoNormal' => $_n['nomTipoNormal'] ?? 'Normal',
  193.             'nomTipoRecolector' => $_n['nomTipoRecolector'] ?? 'Recolector de datos',
  194.             'tipoAcceso' => $_n['tipoAcceso'] ?? 'Tipo de acceso',
  195.             'perfil' => $_n['perfil'] ?? 'Perfil',
  196.             'noCumple' => $_n['noCumple'] ?? 'La contraseña no cumple con las reglas. Mínimo 8 carácteres, mínimo un número',
  197.         ];
  198.         ///
  199.         $html = [];
  200.         $html["nuevo"] = $generales['nuevo'];
  201.         $html["multiUbicacion"] = $generales['multiUbicacion'];
  202.         //////
  203.         if ($generales['nuevo'] == self::_editar) { // es string
  204.             $rotulos['titulo'] = $rotulos['editarUsuario'];
  205.             $valoresFor = $usuariosRepo->findForEditar($cliente, $claUsuario);
  206.         } else {
  207.             $rotulos['titulo'] = $rotulos['nuevoUsuario'];
  208.             $valoresFor = $usuariosRepo->findForNuevo();
  209.         }
  211.         $valores = [];
  212.         foreach ($valoresFor as $v => $valor) {
  213.             $valores[$valor['alias']] = $valor['valor'];
  214.         }
  215.         $valores['nivelClave'] = $ubicacionesRepo->getUbicacionNivel($cliente, $valores['claUbicacion']) . '|' . $valores['claUbicacion'];
  217.         $catalogos = [];
  218.         $claMatriz = $ubicacionesRepo->findForMatriz($cliente);
  219.         $catalogos['ubicaciones'] = $ubicacionesRepo->getUbicacionesArray($cliente, $claMatriz, $rotulos['region'], $rotulos['centro']);
  220.         $catalogos['perfiles'] = $perfilesRepo->findForCatalogo($cliente);
  221.         $usuariosTipos = [];
  222.         $usuariosTipos[] = ['claTipo' => Usuarios::_claTipoNormal, 'nomTipo' => $rotulos['nomTipoNormal']];
  223.         //$usuariosTipos[] = ['claTipo' => Usuarios::_claTipoRecolectorDatos, 'nomTipo' => $rotulos['nomTipoRecolector']];
  224.         $catalogos['tipos'] = $usuariosTipos;
  225.         //la data
  226.         $data = [];
  227.         $data['generales'] = $generales;
  228.         $data['rotulos'] = $rotulos;
  229.         $data['html'] = $html;
  230.         $data['valores'] = $valores;
  231.         $data['catalogos'] = $catalogos;
  232.         return $data;
  233.     }
  234.     /**
  235.      * Method procUsuariosEnviar
  236.      *
  237.      * @param array $paraProceso
  238.      *
  239.      * @return array
  240.      */
  241.     private function procUsuariosEnviar($paraProceso): array
  242.     {
  243.         $entityManager = $this->getDoctrine()->getManager();
  244.         $fi = new FuncionesIvtcotizador();
  245.         $registry = $paraProceso['registry'];
  246.         $requestStack = $paraProceso['requestStack'];
  247.         $hasher = $paraProceso['hasher'];
  248.         $cliente = $paraProceso['cliente'];
  249.         $claUsuario = $paraProceso['claUsuario'];
  250.         $datosRequest = $paraProceso['datosRequest'];
  251.         $contra = $paraProceso['contra'];
  252.         $nuevo = $paraProceso['nuevo'];
  253.         $sesion = $paraProceso['sesion'];
  254.         ///
  255.         $usuariosRepo = new UsuariosRepository($registry, $requestStack);
  256.         $perfilesRepo = new PerfilesRepository($registry);
  257.         ///
  258.         $controladorA = explode('\\', get_called_class());
  259.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  260.         $rotulos = [
  261.             'usuarioAgregado' => $_n['usuarioAgregado'] ?? 'Nuevo usuario agregado con éxito',
  262.             'usuarioActualizado' => $_n['usuarioActualizado'] ?? 'Usuario actualizado con éxito',
  263.             'usuarioNoExiste' => $_n['usuarioNoExiste'] ?? 'El usuario no existe',
  264.             'usuarioYaExiste' => $_n['usuarioYaExiste'] ?? 'El usuario ya existe',
  265.             'nomTipoNormal' => $_n['nomTipoNormal'] ?? 'Normal',
  266.             'nomTipoRecolector' => $_n['nomTipoRecolector'] ?? 'Recolector de datos',
  267.         ];
  268.         $resultado = 1;
  269.         $mensaje = $rotulos['usuarioAgregado'];
  270.         $dataGrid = [];
  272.         $usuariosCuenta = $usuariosRepo->createQueryBuilder('s')
  273.             ->select('count(s.clausuario)')
  274.             ->where('s.clausuario = :claUsuario')
  275.             ->setParameters(['claUsuario' => $claUsuario])
  276.             ->getQuery()
  277.             ->getSingleScalarResult();
  279.         if ($usuariosCuenta > 0 && $nuevo == self::_nuevo) {
  280.             $mensaje = $rotulos['usuarioYaExiste'];
  281.             $resultado = -2;
  282.         }
  284.         if ($resultado == 1) {
  285.             $usuario = new Usuarios();
  286.             if ($nuevo == self::_editar) {
  287.                 $mensaje = $rotulos['usuarioActualizado'];
  288.                 $usuario = $usuariosRepo->findForClausuario($cliente, $claUsuario);
  289.                 if ($usuario == null) {
  290.                     $resultado = -1;
  291.                     $mensaje = $rotulos['usuarioNoExiste'];
  292.                 }
  293.             }
  294.         }
  296.         if ($resultado == 1) {
  297.             $camposContinuar = ['id', 'nuevo'];
  298.             $camposSoloNuevo = ['clacliente', 'contra2', 'contra3', 'clausuario', 'fecha'];
  299.             $camposParaGrid = ['clausuario', 'nomusuario', 'activo'];
  300.             $camposInfo = $usuariosRepo->getDataArray();
  302.             foreach ($datosRequest as $d => $valor) {
  303.                 $campo = strtolower($d);
  304.                 if ($campo == 'nivelclave') { //viene como nivel|claUbicacion
  305.                     $valor = explode('|', $valor)[1];
  306.                     $campo = 'claubicacion';
  307.                 }
  308.                 if (in_array($campo, $camposContinuar)) {
  309.                     continue;
  310.                 }
  311.                 if (in_array($campo, $camposParaGrid)) {
  312.                     $dataGrid[$d] = $valor;
  313.                 }
  314.                 if ($nuevo == self::_nuevo) {
  315.                     if ($campo == 'clacliente') {
  316.                         $valor = $cliente;
  317.                     }
  318.                     if ($campo == 'activo') {
  319.                         $valor = '1';
  320.                     }
  321.                     if ($campo == 'fecha') {
  322.                         $valor = $fi->ivtCotizadorTiempoDT();
  323.                     }
  324.                 } else {
  325.                     if (in_array($campo, $camposSoloNuevo)) {
  326.                         continue;
  327.                     }
  328.                 }
  330.                 //valida el tipo de dato
  331.                 $metaData = $fi->getCampoMetadata($camposInfo, $campo);
  332.                 $columnaTipoDato = $metaData['columnaTipoDato'];
  333.                 $valorDefault = $metaData['valorDefault'];
  335.                 $tipoDato = gettype($valor);
  336.                 if ($tipoDato != $columnaTipoDato) {
  337.                     if ($columnaTipoDato == 'integer') {
  338.                         if ($tipoDato == 'string') {
  339.                             $valor = str_replace(',', '', $valor);
  340.                             $valor = str_replace(' ', '', $valor);
  341.                             $valor = (int) $valor;
  342.                         }
  343.                     }
  344.                     if ($columnaTipoDato == 'float') {
  345.                         if ($tipoDato == 'string') {
  346.                             $valor = str_replace(',', '', $valor);
  347.                             $valor = str_replace(' ', '', $valor);
  348.                             $valor = (float) $valor;
  349.                         }
  350.                     }
  351.                 }
  353.                 $campoSet = "set" . ucfirst($campo);
  354.                 $usuario->$campoSet($valor);
  355.             }
  356.             $entityManager->persist($usuario);
  357.             $entityManager->flush();
  359.             if ($nuevo == self::_nuevo && strlen($contra) > 0) {
  360.                 $contra = $hasher->hashPassword($usuario, $contra);
  361.                 $usuario->setPassword($contra);
  362.                 $usuario->setContra($contra);
  363.                 $usuario->setContra1($contra);
  364.                 $usuario->setContra2('');
  365.                 $usuario->setContra3('');
  366.                 $usuario->setRoles([]);
  367.                 $entityManager->persist($usuario);
  368.                 $entityManager->flush();
  369.                 //MultiUbicacion
  370.                 $multiUbicacion = $sesion->get('parametros')['MultiUbicacion'] ?? '0';
  371.                 if ($multiUbicacion == '1') {
  372.                     $multi = new Usuarioubicaciones();
  373.                     $multi->setClacliente($cliente)
  374.                         ->setClausuario($usuario->getClausuario())
  375.                         ->setClaubicacion($usuario->getClaubicacion());
  376.                     $entityManager->persist($multi);
  377.                     $entityManager->flush();
  378.                 }
  379.             }
  380.             $dataGrid['nomTipo'] = '';
  381.             switch ($usuario->getClatipo()) {
  382.                 case Usuarios::_claTipoNormal:
  383.                     $dataGrid['nomTipo'] = $rotulos['nomTipoNormal'];
  384.                     break;
  385.                 case Usuarios::_claTipoRecolectorDatos:
  386.                     $dataGrid['nomTipo'] = $rotulos['nomTipoRecolector'];
  387.                     break;
  388.             }
  390.             $dataGrid['claUsuario'] = $usuario->getClausuario();
  391.             $dataGrid['activo'] = $usuario->getActivo();
  392.             $dataGrid['nomPerfil'] = $perfilesRepo->findForNombre($cliente, $usuario->getClaperfil());
  393.         }
  394.         //la data
  395.         $data = [];
  396.         $data['resultado'] = $resultado;
  397.         $data['mensaje'] = $mensaje;
  398.         $data['dataGrid'] = $dataGrid;
  399.         return $data;
  400.     }
  401.     /**
  402.      * Method procUsuariosMultiUbicaciones
  403.      *
  404.      * @param array $paraProceso
  405.      *
  406.      * @return void
  407.      */
  408.     private function procUsuariosMultiUbicaciones($paraProceso)
  409.     {
  410.         $entityManager = $this->getDoctrine()->getManager();
  411.         $fi = new FuncionesIvtcotizador();
  412.         $registry = $paraProceso['registry'];
  413.         $usuarioUbiRepo = new UsuarioubicacionesRepository($registry);
  414.         $ubicacionesRepo = new UbicacionesRepository($registry);
  415.         $cliente = $paraProceso['cliente'];
  416.         $claUsuario = $paraProceso['claUsuario'];
  417.         ///
  418.         $controladorA = explode('\\', get_called_class());
  419.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  420.         $rotulos = [
  421.             'nomUbicacion' => $_n['nomUbicacion'] ?? 'Ubicación',
  422.             'ubicacion' => $_n['ubicacion'] ?? 'Ubicación',
  423.             'region' => $_n['region'] ?? 'Región',
  424.             'centro' => $_n['centro'] ?? 'Centro',
  425.             'agregar' => $_n['agregar'] ?? 'Agregar',
  426.             'eliminar' => $_n['eliminar'] ?? 'Eliminar',
  427.             'eliminarTip' => $_n['eliminarTip'] ?? 'Elimina la ubicación seleccionada',
  428.             'eliminarConfirmar' => $_n['eliminarConfirmar'] ?? '¿Está seguro de querer eliminar esta ubicación?',
  429.         ];
  431.         $ubicaciones = $ubicacionesRepo->findForIndiceEsClaveConNivel($cliente);
  432.         $valoresDB = $usuarioUbiRepo->findForGrid($cliente, $claUsuario);
  433.         $valores = [];
  434.         $enLista = ['claUsuario', 'claUbicacion', 'claUsuarioUbicacion'];
  435.         $cuentas = [];
  436.         foreach ($valoresDB as $x => $campos) {
  437.             $array = [];
  438.             foreach ($campos as $y => $campo) {
  439.                 if (in_array($campo['alias'], $enLista)) {
  440.                     $array[$campo['alias']] = $campo['valor'];
  441.                 }
  442.                 //nomUbicacion
  443.                 if ($campo['alias'] == 'claUbicacion') {
  444.                     $array['nomUbicacion'] = $ubicaciones[$campo['valor']] ?? '';
  445.                 }
  446.                 $array['eliminar'] = true;
  447.                 if ($campo['alias'] == 'claUsuarioUbicacion') {
  448.                     $cuentas[$campo['valor']] = 0;
  449.                 }
  450.             }
  451.             $valores[] = $array;
  452.         }
  454.         $catalogos = [];
  455.         $claMatriz = $ubicacionesRepo->findForMatriz($cliente);
  456.         $catalogos['ubicaciones'] = $ubicacionesRepo->getUbicacionesArray($cliente, $claMatriz, $rotulos['region'], $rotulos['centro']);
  458.         $generales = [];
  459.         $generales['claUsuario'] = $claUsuario;
  460.         //la data
  461.         $data = [];
  462.         $data['rotulos'] = $rotulos;
  463.         $data['valores'] = $valores;
  464.         $data['catalogos'] = $catalogos;
  465.         $data['generales'] = $generales;
  466.         return $data;
  467.     }
  468.     /**
  469.      * Method procMultiUbicacionesEnviar
  470.      *
  471.      * @param array $paraProceso
  472.      *
  473.      * @return array
  474.      */
  475.     private function procMultiUbicacionesEnviar($paraProceso): array
  476.     {
  477.         $entityManager = $this->getDoctrine()->getManager();
  478.         $fi = new FuncionesIvtcotizador();
  479.         $registry = $paraProceso['registry'];
  480.         $usuarioUbiRepo = new UsuarioubicacionesRepository($registry);
  481.         $ubicacionesRepo = new UbicacionesRepository($registry);
  482.         $cliente = $paraProceso['cliente'];
  483.         $datosRequest = $paraProceso['datosRequest'];
  484.         $nuevo = $paraProceso['nuevo'];
  485.         $claUsuario = $paraProceso['claUsuario'];
  486.         $claUbicacion = $paraProceso['claUbicacion'];
  488.         ///
  489.         $controladorA = explode('\\', get_called_class());
  490.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  491.         $rotulos = [
  492.             'agregada' => $_n['agregada'] ?? 'Ubicación agregada con éxito',
  493.             'ubicacionYaAgregada' => $_n['ubicacionYaAgregada'] ?? 'Ubicación previamente agregada',
  494.         ];
  495.         $resultado = 1;
  496.         $mensaje = $rotulos['agregada'];
  497.         $dataGrid = [];
  499.         $ubiCuenta = $usuarioUbiRepo->createQueryBuilder('s')
  500.             ->select('count(s.clausuario)')
  501.             ->where('s.clausuario = :claUsuario')
  502.             ->andWhere('s.claubicacion = :claUbicacion')
  503.             ->setParameters(['claUsuario' => $claUsuario, 'claUbicacion' => $claUbicacion])
  504.             ->getQuery()
  505.             ->getSingleScalarResult();
  507.         if ($ubiCuenta > 0) {
  508.             $mensaje = $rotulos['ubicacionYaAgregada'];
  509.             $resultado = -2;
  510.         }
  512.         if ($resultado == 1) {
  513.             $usuUbi = new Usuarioubicaciones();
  514.             $camposContinuar = [];
  515.             $camposSoloNuevo = ['clacliente'];
  516.             $camposParaGrid = ['claubicacion'];
  517.             $camposInfo = $usuarioUbiRepo->getDataArray();
  519.             foreach ($datosRequest as $d => $valor) {
  520.                 $campo = strtolower($d);
  521.                 if ($campo == 'claubicacion') { //viene como nivel|claUbicacion
  522.                     $valor = explode('|', $valor)[1];
  523.                     $campo = 'claubicacion';
  524.                 }
  525.                 if (in_array($campo, $camposContinuar)) {
  526.                     continue;
  527.                 }
  528.                 if (in_array($campo, $camposParaGrid)) {
  529.                     $dataGrid[$d] = $valor;
  530.                 }
  531.                 if ($nuevo == self::_nuevo) {
  532.                     if ($campo == 'clacliente') {
  533.                         $valor = $cliente;
  534.                     }
  535.                 } else {
  536.                     if (in_array($campo, $camposSoloNuevo)) {
  537.                         continue;
  538.                     }
  539.                 }
  541.                 //valida el tipo de dato
  542.                 $metaData = $fi->getCampoMetadata($camposInfo, $campo);
  543.                 $columnaTipoDato = $metaData['columnaTipoDato'];
  544.                 $valorDefault = $metaData['valorDefault'];
  546.                 $tipoDato = gettype($valor);
  547.                 if ($tipoDato != $columnaTipoDato) {
  548.                     if ($columnaTipoDato == 'integer') {
  549.                         if ($tipoDato == 'string') {
  550.                             $valor = str_replace(',', '', $valor);
  551.                             $valor = str_replace(' ', '', $valor);
  552.                             $valor = (int) $valor;
  553.                         }
  554.                     }
  555.                     if ($columnaTipoDato == 'float') {
  556.                         if ($tipoDato == 'string') {
  557.                             $valor = str_replace(',', '', $valor);
  558.                             $valor = str_replace(' ', '', $valor);
  559.                             $valor = (float) $valor;
  560.                         }
  561.                     }
  562.                 }
  564.                 $campoSet = "set" . ucfirst($campo);
  565.                 $usuUbi->$campoSet($valor);
  566.             }
  567.             $usuUbi->setClacliente($cliente);
  568.             $entityManager->persist($usuUbi);
  569.             $entityManager->flush();
  571.             $dataGrid['nomUbicacion'] = $ubicacionesRepo->findForNombreConNivel($usuUbi->getClacliente(), $usuUbi->getClaubicacion());
  572.         }
  573.         //la data
  574.         $data = [];
  575.         $data['resultado'] = $resultado;
  576.         $data['mensaje'] = $mensaje;
  577.         $data['dataGrid'] = $dataGrid;
  578.         return $data;
  579.     }
  580.     /**
  581.      * Method procMultiUbicacionesEliminar
  582.      *
  583.      * @param array $paraProceso
  584.      *
  585.      * @return void
  586.      */
  587.     private function procMultiUbicacionesEliminar($paraProceso)
  588.     {
  589.         $entityManager = $this->getDoctrine()->getManager();
  590.         $fi = new FuncionesIvtcotizador();
  591.         $registry = $paraProceso['registry'];
  592.         $usuarioUbiRepo = new UsuarioubicacionesRepository($registry);
  593.         $claUsuarioUbicacion = $paraProceso['claUsuarioUbicacion'];
  594.         ///
  595.         $controladorA = explode('\\', get_called_class());
  596.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  597.         $rotulos = [
  598.             'exito' => $_n['exito'] ?? 'Ubicación eliminada',
  599.             'noExiste' => $_n['noExiste'] ?? 'No existe la ubicación',
  600.         ];
  602.         $resultado = 1;
  603.         $mensaje = $rotulos['exito'];
  604.         $usuUbi = $usuarioUbiRepo->find($claUsuarioUbicacion);
  605.         if ($usuUbi == null) {
  606.             $resultado = -1;
  607.             $mensaje = $rotulos['noExiste'];
  608.         }
  610.         if ($resultado == 1) {
  611.             $entityManager->remove($usuUbi);
  612.             $entityManager->flush();
  613.         }
  614.         //la data
  615.         $data = [];
  616.         $data['resultado'] = $resultado;
  617.         $data['mensaje'] = $mensaje;
  618.         return $data;
  619.     }
  620.     /**
  621.      * Method procUsuariosDesactivar
  622.      *
  623.      * @param array $paraProceso
  624.      *
  625.      * @return array
  626.      */
  627.     private function procUsuariosDesactivar($paraProceso): array
  628.     {
  629.         $entityManager = $this->getDoctrine()->getManager();
  630.         $fi = new FuncionesIvtcotizador();
  631.         $registry = $paraProceso['registry'];
  632.         $requestStack = $paraProceso['requestStack'];
  633.         $usuariosRepo = new UsuariosRepository($registry, $requestStack);
  634.         $cliente = $paraProceso['cliente'];
  635.         $datosRequest = $paraProceso['datosRequest'];
  636.         $claUsuario = $paraProceso['claUsuario'];
  637.         ///
  638.         $controladorA = explode('\\', get_called_class());
  639.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  640.         $rotulos = [
  641.             'exito' => $_n['exito'] ?? 'Usuario desactivado',
  642.             'usuarioNoExiste' => $_n['usuarioNoExiste'] ?? 'El usuario no existe',
  643.         ];
  644.         $resultado = 1;
  645.         $mensaje = $rotulos['exito'];
  646.         $dataGrid = [];
  648.         $usuario = $usuariosRepo->findForClausuario($cliente, $claUsuario);
  649.         if ($usuario == null) {
  650.             $resultado = -1;
  651.             $mensaje = $rotulos['usuarioNoExiste'];
  652.         }
  654.         if ($resultado == 1) {
  655.             $usuario->setActivo('0');
  656.             $entityManager->persist($usuario);
  657.             $entityManager->flush();
  659.             $dataGrid['claUsuario'] = $usuario->getClausuario();
  660.             $dataGrid['activo'] = $usuario->getActivo();
  661.         }
  662.         //la data
  663.         $data = [];
  664.         $data['resultado'] = $resultado;
  665.         $data['mensaje'] = $mensaje;
  666.         $data['dataGrid'] = $dataGrid;
  667.         return $data;
  668.     }
  669.     /**
  670.      * Method procUsuariosActivar
  671.      *
  672.      * @param array $paraProceso
  673.      *
  674.      * @return array
  675.      */
  676.     private function procUsuariosActivar($paraProceso): array
  677.     {
  678.         $entityManager = $this->getDoctrine()->getManager();
  679.         $fi = new FuncionesIvtcotizador();
  680.         $registry = $paraProceso['registry'];
  681.         $requestStack = $paraProceso['requestStack'];
  682.         $usuariosRepo = new UsuariosRepository($registry, $requestStack);
  683.         $cliente = $paraProceso['cliente'];
  684.         $datosRequest = $paraProceso['datosRequest'];
  685.         $claUsuario = $paraProceso['claUsuario'];
  686.         ///
  687.         $controladorA = explode('\\', get_called_class());
  688.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  689.         $rotulos = [
  690.             'exito' => $_n['exito'] ?? 'Usuario activado',
  691.             'usuarioNoExiste' => $_n['usuarioNoExiste'] ?? 'El usuario no existe',
  692.         ];
  693.         $resultado = 1;
  694.         $mensaje = $rotulos['exito'];
  695.         $dataGrid = [];
  697.         $usuario = $usuariosRepo->findForClausuario($cliente, $claUsuario);
  698.         if ($usuario == null) {
  699.             $resultado = -1;
  700.             $mensaje = $rotulos['usuarioNoExiste'];
  701.         }
  703.         if ($resultado == 1) {
  704.             $usuario->setActivo('1');
  705.             $entityManager->persist($usuario);
  706.             $entityManager->flush();
  708.             $dataGrid['claUsuario'] = $usuario->getClausuario();
  709.             $dataGrid['activo'] = $usuario->getActivo();
  710.         }
  711.         //la data
  712.         $data = [];
  713.         $data['resultado'] = $resultado;
  714.         $data['mensaje'] = $mensaje;
  715.         $data['dataGrid'] = $dataGrid;
  716.         return $data;
  717.     }
  718.     /**
  719.      * Method procUsuariosCambiarContra
  720.      *
  721.      * @param array $paraProceso
  722.      *
  723.      * @return array
  724.      */
  725.     private function procUsuariosCambiarContra($paraProceso): array
  726.     {
  727.         $fi = new FuncionesIvtcotizador();
  728.         $claUsuario = $paraProceso['claUsuario'];
  729.         $registry = $paraProceso['registry'];
  730.         $cliente = $paraProceso['cliente'];
  731.         ///
  732.         $controladorA = explode('\\', get_called_class());
  733.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  734.         $rotulos = [
  735.             'titulo' => $_n['Cambiar contraseña'] ?? 'Cambiar contraseña',
  736.             'clave' => $_n['clave'] ?? 'Clave',
  737.             'contra' => $_n['contra'] ?? 'Contraseña',
  738.             'confirmacion' => $_n['confirmacion'] ?? 'Confirmación',
  739.             'guardar' => $_n['guardar'] ?? 'Guardar',
  740.             'contraAviso' => $_n['contraAviso'] ?? 'Indique la contraseña',
  741.             'confirmacionAviso' => $_n['confirmacionAviso'] ?? 'Indique la confirmación',
  742.             'noCoinciden' => $_n['noCoinciden'] ?? 'La contraseña y la confirmación no coinciden',
  743.             'error' => $_n['error'] ?? 'Revise los campos',
  744.             'noCumple' => $_n['noCumple'] ?? 'La contraseña no cumple con las reglas. Mínimo 8 carácteres, mínimo un número',
  745.             'caracteres' => $_n['caracteres'] ?? 'Mínimo 8 caracteres',
  746.             'minuscula' => $_n['minuscula'] ?? 'Una minúscula',
  747.             'mayuscula' => $_n['mayuscula'] ?? 'Una mayúscula',
  748.             'numero' => $_n['numero'] ?? 'Un número',
  749.             'reglas' => $_n['reglas'] ?? 'Reglas de contraseñas',
  750.         ];
  751.         $valores = [];
  752.         $valores['claUsuario'] = $claUsuario;
  753.         ///
  754.         $html = [
  755.             "titulo" => $rotulos["titulo"],
  756.         ];
  757.         ///
  758.         $generales = [];
  759.         //la data
  760.         $data = [];
  761.         $data['generales'] = $generales;
  762.         $data['rotulos'] = $rotulos;
  763.         $data['html'] = $html;
  764.         $data['valores'] = $valores;
  765.         return $data;
  766.     }
  767.     /**
  768.      * Method procUsuariosCambiarContraEnviar
  769.      *
  770.      * @param array $paraProceso
  771.      *
  772.      * @return array
  773.      */
  774.     private function procUsuariosCambiarContraEnviar($paraProceso): array
  775.     {
  776.         $entityManager = $this->getDoctrine()->getManager();
  777.         $fi = new FuncionesIvtcotizador();
  778.         $registry = $paraProceso['registry'];
  779.         $requestStack = $paraProceso['requestStack'];
  780.         $usuariosRepo = new UsuariosRepository($registry, $requestStack);
  781.         $hasher = $paraProceso['hasher'];
  782.         $cliente = $paraProceso['cliente'];
  783.         $claUsuario = $paraProceso['claUsuario'];
  784.         $contra = $paraProceso['contra'];
  785.         $contraActual = $paraProceso['contraActual'];
  786.         $id = $paraProceso['id'];
  788.         ///
  789.         $controladorA = explode('\\', get_called_class());
  790.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  791.         $rotulos = [
  792.             'exito' => $_n['exito'] ?? 'Contraseña cambiada con éxito',
  793.             'usuarioNoExiste' => $_n['usuarioNoExiste'] ?? 'El usuario no existe',
  794.             'noCoincide' => $_n['noCoincide'] ?? 'La contraseña actual no coincide',
  795.         ];
  796.         $resultado = 1;
  797.         $mensaje = $rotulos['exito'];
  799.         if (strlen($contraActual) > 0) {
  800.             $usuario = $usuariosRepo->find($id);
  801.         } else {
  802.             $usuario = $usuariosRepo->findForClausuario($cliente, $claUsuario);
  803.         }
  804.         if ($usuario == null) {
  805.             $resultado = -1;
  806.             $mensaje = $rotulos['usuarioNoExiste'];
  807.         }
  809.         if ($resultado == 1) {
  810.             if (strlen($contraActual) > 0) {
  811.                 $compara = $hasher->isPasswordValid($usuario, $contraActual);
  812.                 if (!$compara) {
  813.                     $resultado = -2;
  814.                     $mensaje = $rotulos['noCoincide'];
  815.                 }
  816.             }
  817.         }
  818.         if ($resultado == 1) {
  819.             $contra1 = $usuario->getContra1();
  820.             $contra2 = $usuario->getContra2();
  821.             $contra3 = $usuario->getContra3();
  822.             $contra = $hasher->hashPassword($usuario, $contra);
  823.             $usuario->setPassword($contra);
  824.             $usuario->setContra($contra);
  825.             $usuario->setContra1($contra);
  826.             $usuario->setContra2($contra1);
  827.             $usuario->setContra3($contra2);
  828.             $usuario->setFecha($fi->ivtCotizadorTiempoDT());
  829.             $entityManager->persist($usuario);
  830.             $entityManager->flush();
  831.         }
  832.         //la data
  833.         $data = [];
  834.         $data['resultado'] = $resultado;
  835.         $data['mensaje'] = $mensaje;
  836.         return $data;
  837.     }
  838.     /**
  839.      * Method procAvisosAgregar
  840.      *
  841.      * @param array $paraProceso
  842.      *
  843.      * @return array
  844.      */
  845.     private function procAvisosAgregar($paraProceso): array
  846.     {
  847.         $entityManager = $this->getDoctrine()->getManager();
  848.         $fi = new FuncionesIvtcotizador();
  849.         $registry = $paraProceso['registry'];
  850.         $usuariosAvisosRepo = new UsuariosavisosRepository($registry);
  851.         $cliente = $paraProceso['cliente'];
  852.         $claUsuario = $paraProceso['claUsuario'];
  853.         $claSeccion = $paraProceso['claSeccion'];
  855.         ///
  856.         $controladorA = explode('\\', get_called_class());
  857.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  858.         $rotulos = [
  859.             'exito' => $_n['exito'] ?? 'Sección agregada con éxito',
  860.             'seccionYaAgregada' => $_n['seccionYaAgregada'] ?? 'Sección previamente agregada',
  861.         ];
  862.         $resultado = 1;
  863.         $mensaje = $rotulos['exito'];
  864.         $dataGrid = [];
  866.         $seccionCuenta = $usuariosAvisosRepo->createQueryBuilder('s')
  867.             ->select('count(s.claaviso)')
  868.             ->where('s.clausuario = :claUsuario')
  869.             ->andWhere('s.clatipoorigen = :claTipoOrigen')
  870.             ->setParameters(['claUsuario' => $claUsuario, 'claTipoOrigen' => $claSeccion])
  871.             ->getQuery()
  872.             ->getSingleScalarResult();
  874.         if ($seccionCuenta > 0) {
  875.             $mensaje = $rotulos['seccionYaAgregada'];
  876.             $resultado = -2;
  877.         }
  879.         if ($resultado == 1) {
  880.             $entityManager = $this->getDoctrine()->getManager();
  881.             $qb = $entityManager->createQueryBuilder();
  882.             $qb->select('p')
  883.                 ->from('App\Entity\Secciones', 'p')
  884.                 ->where('p.claseccion = :claSeccion')
  885.                 ->setParameters(['claSeccion' => $claSeccion]);
  886.             $query = $qb->getQuery();
  887.             $res = $query->getResult();
  889.             $claOrigen = 0;
  890.             foreach ($res as $re) {
  891.                 $claOrigen = $re->getClaorigen();
  892.             }
  894.             $usuAviso = new Usuariosavisos();
  895.             $usuAviso->setClacliente($cliente);
  896.             $usuAviso->setClaorigen($claOrigen);
  897.             $usuAviso->setClatipoorigen($claSeccion);
  898.             $usuAviso->setClausuario($claUsuario);
  899.             $entityManager->persist($usuAviso);
  900.             $entityManager->flush();
  901.         }
  902.         //la data
  903.         $data = [];
  904.         $data['resultado'] = $resultado;
  905.         $data['mensaje'] = $mensaje;
  906.         $data['dataGrid'] = $dataGrid;
  907.         return $data;
  908.     }
  909.     /**
  910.      * Method procAvisosQuitar
  911.      *
  912.      * @param array $paraProceso
  913.      *
  914.      * @return array
  915.      */
  916.     private function procAvisosQuitar($paraProceso): array
  917.     {
  918.         $entityManager = $this->getDoctrine()->getManager();
  919.         $fi = new FuncionesIvtcotizador();
  920.         $registry = $paraProceso['registry'];
  921.         $usuariosAvisosRepo = new UsuariosavisosRepository($registry);
  922.         $cliente = $paraProceso['cliente'];
  923.         $claUsuario = $paraProceso['claUsuario'];
  924.         $claSeccion = $paraProceso['claSeccion'];
  926.         ///
  927.         $controladorA = explode('\\', get_called_class());
  928.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  929.         $rotulos = [
  930.             'exito' => $_n['exito'] ?? 'Sección quitada',
  931.         ];
  932.         $resultado = 1;
  933.         $mensaje = $rotulos['exito'];
  934.         $dataGrid = [];
  936.         $res = $usuariosAvisosRepo->createQueryBuilder('s')
  937.             ->where('s.clausuario = :claUsuario')
  938.             ->andWhere('s.clatipoorigen = :claTipoOrigen')
  939.             ->setParameters(['claUsuario' => $claUsuario, 'claTipoOrigen' => $claSeccion])
  940.             ->getQuery()
  941.             ->getResult();
  943.         $claAviso = 0;
  944.         foreach ($res as $re) {
  945.             $claAviso = $re->getClaaviso();
  946.         }
  948.         if ($claAviso > 0) {
  949.             $usuAviso = $usuariosAvisosRepo->find($claAviso);
  950.             $entityManager->remove($usuAviso);
  951.             $entityManager->flush();
  952.         }
  953.         //la data
  954.         $data = [];
  955.         $data['resultado'] = $resultado;
  956.         $data['mensaje'] = $mensaje;
  957.         $data['dataGrid'] = $dataGrid;
  958.         return $data;
  959.     }
  960.     /**
  961.      * Method procUsuariosAvisos
  962.      *
  963.      * @param array $paraProceso
  964.      *
  965.      * @return void
  966.      */
  967.     private function procUsuariosAvisos($paraProceso)
  968.     {
  969.         $entityManager = $this->getDoctrine()->getManager();
  970.         $fi = new FuncionesIvtcotizador();
  971.         $registry = $paraProceso['registry'];
  972.         $usuariosAvisosRepo = new UsuariosavisosRepository($registry);
  973.         $origenesRepo = new OrigenesRepository($registry);
  974.         $seccionesRepo = new SeccionesRepository($registry);
  975.         $cliente = $paraProceso['cliente'];
  976.         $claUsuario = $paraProceso['claUsuario'];
  977.         ///
  978.         $controladorA = explode('\\', get_called_class());
  979.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  980.         $rotulos = [
  981.             'origen' => $_n['origen'] ?? 'Origen',
  982.             'seccion' => $_n['seccion'] ?? 'Sección',
  983.             'titulo' => $_n['titulo'] ?? 'Configuración de avisos',
  984.         ];
  986.         $origenes = $origenesRepo->findForCatalogoIndiceEsClave();
  987.         $secciones = $seccionesRepo->findForCatalogoIndiceEsClave();
  988.         $valoresDB = $usuariosAvisosRepo->findForGrid($cliente, $claUsuario);
  989.         $valores = [];
  990.         $enLista = ['claOrigen', 'claTipoOrigen'];
  991.         foreach ($valoresDB as $x => $campos) {
  992.             $array = [];
  993.             foreach ($campos as $y => $campo) {
  994.                 if (in_array($campo['alias'], $enLista)) {
  995.                     $array[$campo['alias']] = $campo['valor'];
  996.                 }
  997.                 //nomOrigen
  998.                 if ($campo['alias'] == 'claOrigen') {
  999.                     $array['nomOrigen'] = $origenes[$campo['valor']] ?? '';
  1000.                 }
  1001.                 //claTipoOrigen
  1002.                 if ($campo['alias'] == 'claTipoOrigen') {
  1003.                     $array['nomTipoOrigen'] = $secciones[$campo['valor']] ?? '';
  1004.                 }
  1005.                 $array['eliminar'] = true;
  1006.             }
  1007.             $valores[] = $array;
  1008.         }
  1010.         $valoresFalta = [];
  1011.         $seccionesRS = $seccionesRepo->findForRS();
  1012.         foreach ($origenes as $claOrigen => $nomOrigen) {
  1013.             foreach ($seccionesRS as $seccion) {
  1014.                 if ($seccion->getClaorigen() == $claOrigen) {
  1015.                     $ya = false;
  1016.                     foreach ($valores as $x => $valor) {
  1017.                         if ($valor['claOrigen'] == $claOrigen && $valor['claTipoOrigen'] == $seccion->getClaseccion()) {
  1018.                             $ya = true;
  1019.                         }
  1020.                     }
  1022.                     if (!$ya) {
  1023.                         $array = [];
  1024.                         $array['claOrigen'] = $claOrigen;
  1025.                         $array['claTipoOrigen'] = $seccion->getClaseccion();
  1026.                         $array['nomOrigen'] = $origenes[$claOrigen] ?? '';
  1027.                         $array['nomTipoOrigen'] = $secciones[$seccion->getClaseccion()] ?? '';
  1028.                         $valoresFalta[] = $array;
  1029.                     }
  1030.                 }
  1031.             }
  1032.         }
  1034.         $catalogos = [];
  1036.         $generales = [];
  1037.         $generales['claUsuario'] = $claUsuario;
  1038.         //la data
  1039.         $data = [];
  1040.         $data['rotulos'] = $rotulos;
  1041.         $data['valores'] = $valores;
  1042.         $data['valoresFalta'] = $valoresFalta;
  1043.         $data['catalogos'] = $catalogos;
  1044.         $data['generales'] = $generales;
  1045.         return $data;
  1046.     }
  1047.     /**
  1048.      * Method procUsuariosmenuPrincipal
  1049.      *
  1050.      * @param array $paraProceso
  1051.      *
  1052.      * @return void
  1053.      */
  1054.     private function procUsuariosmenuPrincipal($paraProceso)
  1055.     {
  1056.         $entityManager = $this->getDoctrine()->getManager();
  1057.         $fi = new FuncionesIvtcotizador();
  1059.         $cliente = $paraProceso['cliente'];
  1060.         $usuarioFunciones = $paraProceso['usuarioFunciones'];
  1061.         $tipoUsuario = $paraProceso['tipoUsuario'];
  1062.         ///
  1063.         // $controladorA = explode('\\', get_called_class());
  1064.         // $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  1065.         //para nomenclatura utilizar queries directamente
  1066.         $rotulos = [
  1067.             'menu' => $_n['menu'] ?? 'Menú',
  1068.         ];
  1069.         ///
  1070.         $qb = $entityManager->createQueryBuilder();
  1071.         $qb->select('p')
  1072.             ->from('App\Entity\Funciones', 'p');
  1073.         $query = $qb->getQuery();
  1074.         $funcionesRS = $query->getResult();
  1076.         $funciones = [];
  1077.         foreach ($funcionesRS as $funcion) {
  1078.             $funciones[$funcion->getClafuncion()] = [
  1079.                 'descripcion' => $funcion->getDescripcion(),
  1080.                 'padre' => $funcion->getPadre(),
  1081.                 'comando' => $funcion->getComando(),
  1082.                 'imagen' => $funcion->getImagen(),
  1083.                 'idTipo' => $funcion->getIdtipo(),
  1084.             ];
  1085.         }
  1086.         $modulos = [];
  1087.         $subModulos = [];
  1088.         foreach ($usuarioFunciones as $claFuncion => $descripcion) {
  1089.             if (strlen($claFuncion) == 2) {
  1090.                 if (isset($funciones[$claFuncion])) {
  1091.                     $modulos[] = [
  1092.                         'claModulo' => $claFuncion,
  1093.                         'nomModulo' => $funciones[$claFuncion]['descripcion']
  1094.                     ];
  1095.                 }
  1096.             } else {
  1097.                 if (isset($funciones[$claFuncion])) {
  1098.                     if ( strlen($funciones[$claFuncion]['padre']) == 2 && strlen($funciones[$claFuncion]['comando']) > 2 ) {
  1099.                         $array = [];
  1100.                         $array['claSubModulo'] = $claFuncion;
  1101.                         $array['nomSubModulo'] = $funciones[$claFuncion]['descripcion'];
  1102.                         $array['claModulo'] = $funciones[$claFuncion]['padre'];
  1103.                         $array['comando'] = $funciones[$claFuncion]['comando'];
  1104.                         $array['imagen'] = $funciones[$claFuncion]['imagen'];
  1106.                         $agregar = false;
  1107.                         if($tipoUsuario == Usuarios::_claTipoRecolectorDatos){
  1108.                             if( $funciones[$claFuncion]['idTipo'] == Funciones::_idTipoColectorDatos){
  1109.                                 $agregar = true;
  1110.                             }
  1111.                         }else{
  1112.                             if( $funciones[$claFuncion]['idTipo'] == Funciones::_idTipoNormal){
  1113.                                 $agregar = true;
  1114.                             }
  1115.                         }
  1116.                         if($agregar){
  1117.                             $subModulos[] = $array;
  1118.                         }
  1119.                     }
  1120.                 }
  1121.             }
  1122.         }
  1123.         //la data
  1124.         $data = [];
  1125.         $data['modulos'] = $modulos;
  1126.         $data['subModulos'] = $subModulos;
  1127.         $data['rotulos'] = $rotulos;
  1128.         return $data;
  1129.     }
  1130.     /**
  1131.      * Method procUsuariosmenuFavoritos
  1132.      *
  1133.      * @param array $paraProceso
  1134.      *
  1135.      * @return void
  1136.      */
  1137.     private function procUsuariosmenuFavoritos($paraProceso){
  1138.         $entityManager = $this->getDoctrine()->getManager();
  1139.         $cliente = $paraProceso['cliente'];
  1140.         $claUsuario = $paraProceso['claUsuario'];
  1141.         ///
  1142.         $qb = $entityManager->createQueryBuilder();
  1143.         $qb->select('p')
  1144.                 ->from('App\Entity\Usuariosfavoritos', 'p')
  1145.                 ->where('p.clausuario = :claUsuario')
  1146.                 ->andWhere('p.clacliente = :cliente')
  1147.                 ->setParameters(['claUsuario' => $claUsuario, 'cliente' => $cliente]);
  1148.         $query = $qb->getQuery();
  1149.         $favoritosRS = $query->getResult();
  1151.         $in = [];
  1152.         foreach ($favoritosRS as $favo) {
  1153.             $in[] = $favo->getClafuncion();
  1154.         }
  1156.         $qb = $entityManager->createQueryBuilder();
  1157.         $qb->select('p')
  1158.             ->from('App\Entity\Funciones', 'p')
  1159.             ->where('p.clafuncion in (:in)')
  1160.             ->setParameters(['in' => $in]);
  1161.         $query = $qb->getQuery();
  1162.         $funcionesRS = $query->getResult();
  1164.         $funciones = [];
  1165.         foreach ($funcionesRS as $funcion) {
  1166.             $funciones[$funcion->getClafuncion()] = [
  1167.                 'descripcion' => $funcion->getDescripcion(),
  1168.                 'padre' => $funcion->getPadre(),
  1169.                 'comando' => $funcion->getComando(),
  1170.                 'imagen' => $funcion->getImagen(),
  1171.                 'idTipo' => $funcion->getIdtipo(),
  1172.                 'toolTip' => $funcion->getTooltip(),
  1173.             ];
  1174.         }
  1176.         $favoritos = [];
  1177.         foreach ($favoritosRS as $favo) {
  1178.             $claFuncion = $favo->getClafuncion();
  1179.             if (isset($funciones[$claFuncion])) {
  1180.                 if ( strlen($funciones[$claFuncion]['padre']) == 2 && strlen($funciones[$claFuncion]['comando']) > 2 ) {
  1181.                     $array = [];
  1182.                     $array['claFuncion'] = $claFuncion;
  1183.                     $array['descripcion'] = $funciones[$claFuncion]['descripcion'];
  1184.                     $array['claModulo'] = $funciones[$claFuncion]['padre'];
  1185.                     $array['comando'] = $funciones[$claFuncion]['comando'];
  1186.                     $array['imagen'] = $funciones[$claFuncion]['imagen'];
  1187.                     $array['toolTip'] = $funciones[$claFuncion]['toolTip'];
  1189.                     $favoritos[] = $array;
  1190.                 }
  1191.             }
  1192.         }
  1193.         //la data
  1194.         $data = [];
  1195.         $data['favoritos'] = $favoritos;
  1196.         return $data;
  1197.     }
  1198.     /**
  1199.      * Method procUsuariosmenuFavoritosAgregar
  1200.      *
  1201.      * @param array $paraProceso
  1202.      *
  1203.      * @return void
  1204.      */
  1205.     private function procUsuariosmenuFavoritosAgregar($paraProceso){
  1206.         $entityManager = $this->getDoctrine()->getManager();
  1207.         $fi = new FuncionesIvtcotizador();
  1208.         $registry = $paraProceso['registry'];
  1209.         $cliente = $paraProceso['cliente'];
  1210.         $claUsuario = $paraProceso['claUsuario'];
  1211.         $claFuncion = $paraProceso['claFuncion'];
  1212.         $usuariosfavoritosRepo = new UsuariosfavoritosRepository($registry);
  1213.         $funcionesRepo = new FuncionesRepository($registry);
  1214.         ///
  1215.         $controladorA = explode('\\', get_called_class());
  1216.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  1217.         $rotulos = [
  1218.             'exito' => $_n['exito'] ?? 'Favorito agregado con éxito',
  1219.             'maximoAlcanzado' => $_n['maximoAlcanzado'] ?? 'Máximo de favoritos alcanzado',
  1220.             'repetido' => $_n['repetido'] ?? 'La función ya fue agregada previamente',
  1221.         ];
  1222.         $resultado = 1;
  1223.         $mensaje = $rotulos['exito'];
  1225.         //no repetir
  1226.         $favoritosCuenta = $usuariosfavoritosRepo->createQueryBuilder('s')
  1227.             ->select('count(s.clafavorito)')
  1228.             ->where('s.clausuario = :claUsuario')
  1229.             ->andWhere('s.clacliente = :cliente')
  1230.             ->andWhere('s.clafuncion = :claFuncion')
  1231.             ->setParameters(['claUsuario' => $claUsuario, 'cliente' => $cliente, 'claFuncion' => $claFuncion])
  1232.             ->getQuery()
  1233.             ->getSingleScalarResult();
  1234.         if($favoritosCuenta > 0){
  1235.             $resultado = -1;
  1236.             $mensaje = $rotulos['repetido'];
  1237.         }
  1238.         if($resultado == 1){
  1239.             //maximo 10
  1240.             $favoritosCuenta = $usuariosfavoritosRepo->createQueryBuilder('s')
  1241.                 ->select('count(s.clafavorito)')
  1242.                 ->where('s.clausuario = :claUsuario')
  1243.                 ->andWhere('s.clacliente = :cliente')
  1244.                 ->setParameters(['claUsuario' => $claUsuario, 'cliente' => $cliente])
  1245.                 ->getQuery()
  1246.                 ->getSingleScalarResult();
  1247.             if($favoritosCuenta > 9){
  1248.                 $resultado = -2;
  1249.                 $mensaje = $rotulos['maximoAlcanzado'];
  1250.             }
  1251.         }
  1252.         $dataGrid = [];
  1253.         if($resultado == 1){
  1254.             $favorito = new Usuariosfavoritos();
  1255.             $favorito->setClacliente($cliente);
  1256.             $favorito->setClausuario($claUsuario);
  1257.             $favorito->setClafuncion($claFuncion);
  1258.             $entityManager->persist($favorito);
  1259.             $entityManager->flush();
  1261.             $dataGrid['descripcion'] = '';
  1262.             $dataGrid['imagen'] = '';
  1263.             $dataGrid['toolTip'] = '';
  1264.             $dataGrid['comando'] = '';
  1265.             $dataGrid['padre'] = '';
  1267.             $funcionesRS = $funcionesRepo->findForRS($claFuncion);
  1268.             foreach ($funcionesRS as $fun) {
  1269.                 $dataGrid['descripcion'] = $fun->getDescripcion();
  1270.                 $dataGrid['imagen'] = $fun->getImagen();
  1271.                 $dataGrid['toolTip'] = $fun->getTooltip();
  1272.                 $dataGrid['comando'] = $fun->getComando();
  1273.                 $dataGrid['padre'] = $fun->getPadre();
  1274.             }
  1275.         }
  1276.         //la data
  1277.         $data = [];
  1278.         $data['resultado'] = $resultado;
  1279.         $data['mensaje'] = $mensaje;
  1280.         $data['dataGrid'] = $dataGrid;
  1281.         return $data;
  1282.     }
  1283.     /**
  1284.      * Method procUsuariosmenuFavoritosQuitar
  1285.      *
  1286.      * @param array $paraProceso
  1287.      *
  1288.      * @return void
  1289.      */
  1290.     private function procUsuariosmenuFavoritosQuitar($paraProceso){
  1291.         $entityManager = $this->getDoctrine()->getManager();
  1292.         $fi = new FuncionesIvtcotizador();
  1293.         $registry = $paraProceso['registry'];
  1294.         $cliente = $paraProceso['cliente'];
  1295.         $claUsuario = $paraProceso['claUsuario'];
  1296.         $claFuncion = $paraProceso['claFuncion'];
  1297.         $usuariosfavoritosRepo = new UsuariosfavoritosRepository($registry);
  1298.         ///
  1299.         $controladorA = explode('\\', get_called_class());
  1300.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  1301.         $rotulos = [
  1302.             'exito' => $_n['exito'] ?? 'Favorito removido',
  1303.             'noExiste' => $_n['noExiste'] ?? 'Favorito no existe',
  1304.         ];
  1305.         $resultado = 1;
  1306.         $mensaje = $rotulos['exito'];
  1308.         //claFavorito
  1309.         $qb = $entityManager->createQueryBuilder();
  1310.         $qb->select('s')
  1311.             ->from('App\Entity\Usuariosfavoritos', 's')
  1312.             ->where('s.clausuario = :claUsuario')
  1313.             ->andWhere('s.clacliente = :cliente')
  1314.             ->andWhere('s.clafuncion = :claFuncion')
  1315.             ->setParameters(['claUsuario' => $claUsuario, 'cliente' => $cliente, 'claFuncion' => $claFuncion]);
  1316.         $query = $qb->getQuery();
  1317.         $favoritosRS = $query->getResult();
  1320.         $claFavorito = 0;
  1321.         foreach ($favoritosRS as $favo) {
  1322.             $claFavorito = $favo->getClafavorito();
  1323.         }
  1325.         if($claFavorito == 0){
  1326.             $resultado = -1;
  1327.             $mensaje = $rotulos['noExiste'];
  1328.         }
  1329.         if($resultado == 1){
  1330.             $favorito = $usuariosfavoritosRepo->find($claFavorito);
  1331.             $entityManager->remove($favorito);
  1332.             $entityManager->flush();
  1333.         }
  1334.         //la data
  1335.         $data = [];
  1336.         $data['resultado'] = $resultado;
  1337.         $data['mensaje'] = $mensaje;
  1338.         return $data;
  1339.     }
  1340.     /**
  1341.      * Method procUsuariosSubMenu
  1342.      *
  1343.      * @param array $paraProceso
  1344.      *
  1345.      * @return void
  1346.      */
  1347.     private function procUsuariosSubMenu($paraProceso){
  1348.         $entityManager = $this->getDoctrine()->getManager();
  1349.         $cliente = $paraProceso['cliente'];
  1350.         $claUsuario = $paraProceso['claUsuario'];
  1351.         $subMenuRama = $paraProceso['subMenuRama'];
  1352.         $usuarioFunciones = $paraProceso['usuarioFunciones'];
  1353.         ///
  1354.         $subMenuRama = strlen($subMenuRama) > 0 ? $subMenuRama : 'XXX';
  1355.         $qb = $entityManager->createQueryBuilder();
  1356.         $qb->select('p')
  1357.             ->from('App\Entity\Funciones', 'p')
  1358.             ->where('p.clafuncion like :like')
  1359.             ->setParameters(['like' => $subMenuRama . "%"]);
  1360.         $query = $qb->getQuery();
  1361.         $funcionesRS = $query->getResult();
  1363.         $funciones = [];
  1364.         foreach ($funcionesRS as $funcion) {
  1365.             $funciones[$funcion->getClafuncion()] = [
  1366.                 'descripcion' => $funcion->getDescripcion(),
  1367.                 'padre' => $funcion->getPadre(),
  1368.                 'comando' => $funcion->getComando(),
  1369.                 'imagen' => $funcion->getImagen(),
  1370.                 'idTipo' => $funcion->getIdtipo(),
  1371.                 'toolTip' => $funcion->getTooltip(),
  1372.             ];
  1373.         }
  1375.         $subMenu = [];
  1376.         foreach ($usuarioFunciones as $claFuncion => $funcion) {
  1377.             if (isset($funciones[$claFuncion])) {
  1378.                 if ( strlen($funciones[$claFuncion]['padre']) == 2 && strlen($funciones[$claFuncion]['comando']) > 2 ) {
  1379.                     $array = [];
  1380.                     $array['claFuncion'] = $claFuncion;
  1381.                     $array['descripcion'] = $funciones[$claFuncion]['descripcion'];
  1382.                     $array['claModulo'] = $funciones[$claFuncion]['padre'];
  1383.                     $array['comando'] = $funciones[$claFuncion]['comando'];
  1384.                     $array['imagen'] = $funciones[$claFuncion]['imagen'];
  1385.                     $array['toolTip'] = $funciones[$claFuncion]['toolTip'];
  1387.                     $subMenu[] = $array;
  1388.                 }
  1389.             }
  1390.         }
  1391.         //la data
  1392.         $data = [];
  1393.         $data['subMenu'] = $subMenu;
  1394.         return $data;
  1395.     }
  1396.     /**
  1397.      * Method procUsuariosMenuUsuario
  1398.      *
  1399.      * @param array $paraProceso
  1400.      *
  1401.      * @return void
  1402.      */
  1403.     private function procUsuariosMenuUsuario($paraProceso){
  1404.         $fi = new FuncionesIvtcotizador();
  1405.         $registry = $paraProceso['registry'];
  1406.         $claUsuario = $paraProceso['claUsuario'];
  1407.         $cliente = $paraProceso['cliente'];
  1408.         $nomUsuario = $paraProceso['nomUsuario'];
  1409.         $ubicacionesRepo = new UbicacionesRepository($registry);
  1410.         $claUbicacion = $paraProceso['claUbicacion'];
  1411.         $clienteIdTipo = $paraProceso['clienteIdTipo'];
  1412.         $sesion = $paraProceso['sesion'];
  1413.         ///
  1414.         $controladorA = explode('\\', get_called_class());
  1415.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  1416.         $rotulos = [
  1417.             'salir' => $_n['salir'] ?? 'Salir de IVTCotizador',
  1418.             'ubicacion' => $_n['ubicacion'] ?? 'Ubicación',
  1419.             'contra' => $_n['contra'] ?? 'Contraseña',
  1420.             'contraCambio' => $_n['contraCambio'] ?? 'Cambio de contraseña',
  1421.             'ubicacionCambio' => $_n['ubicacionCambio'] ?? 'Cambio de ubicación',
  1422.             'perfilCliente' => $_n['perfilCliente'] ?? 'Perfil empresa',
  1423.             'perfilClienteTip' => $_n['perfilClienteTip'] ?? 'Datos generales de la empresa',
  1424.             'avisoPrivacidad' => $_n['avisoPrivacidad'] ?? 'Aviso de privacidad',
  1425.             'terminos' => $_n['terminos'] ?? 'Términos y condiciones',
  1426.         ];
  1427.         $valores = [
  1428.             'nomUsuario' => $nomUsuario,
  1429.             'nomUbicacion' => $ubicacionesRepo->findForNombre($cliente, $claUbicacion),
  1430.             'clienteIdTipo' => $clienteIdTipo,
  1431.         ];
  1432.         $generales = [];
  1433.         $generales['multiUbicacion'] = isset($sesion->get('parametros')['MultiUbicacion']) ? $sesion->get('parametros')['MultiUbicacion'] : '0';
  1435.         //la data
  1436.         $data = [];
  1437.         $data['rotulos'] = $rotulos;
  1438.         $data['valores'] = $valores;
  1439.         $data['generales'] = $generales;
  1440.         return $data;
  1441.     }
  1442.     /**
  1443.      * Method procUsuariosContraCambiar
  1444.      *
  1445.      * @param array $paraProceso
  1446.      *
  1447.      * @return void
  1448.      */
  1449.     private function procUsuariosContraCambiar($paraProceso){
  1450.         $fi = new FuncionesIvtcotizador();
  1451.         $registry = $paraProceso['registry'];
  1452.         $cliente = $paraProceso['cliente'];
  1453.         ///
  1454.         $controladorA = explode('\\', get_called_class());
  1455.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  1456.         $rotulos = [
  1457.             'guardar' => $_n['guardar'] ?? 'Guardar',
  1458.             'titulo' => $_n['titulo'] ?? 'Cambio de contraseña',
  1459.             'contraActual' => $_n['contraActual'] ?? 'Contraseña actual',
  1460.             'contra' => $_n['contra'] ?? 'Nueva contraseña',
  1461.             'confirmacion' => $_n['confirmacion'] ?? 'Confirmación',
  1462.             'contraActualAviso' => $_n['contraActualAviso'] ?? 'Indique la contraseña actual',
  1463.             'contraAviso' => $_n['contraAviso'] ?? 'Indique la nueva contraseña',
  1464.             'confirmacionAviso' => $_n['confirmacionAviso'] ?? 'Indique la confirmación',
  1465.             'noCoinciden' => $_n['noCoinciden'] ?? 'La contraseña y la confirmación no coinciden',
  1466.             'reglas' => $_n['reglas'] ?? 'Reglas de contraseñas',
  1467.             'caracteres' => $_n['caracteres'] ?? 'Mínimo ocho caracteres',
  1468.             'minuscula' => $_n['minuscula'] ?? 'Por lo menos una minúscula',
  1469.             'mayuscula' => $_n['mayuscula'] ?? 'Por lo menos una mayúscula',
  1470.             'numero' => $_n['numero'] ?? 'Por lo menos un número',
  1471.             'noCumple' => $_n['noCumple'] ?? 'La contraseña no cumple con las reglas. Mínimo 8 carácteres, mínimo un número',
  1472.             'cerrar' => $_n['cerrar'] ?? 'Cerrar',
  1473.         ];
  1474.         $valores = [
  1475.             'contraActual' => '',
  1476.             'contra' => '',
  1477.         ];
  1479.         //la data
  1480.         $data = [];
  1481.         $data['rotulos'] = $rotulos;
  1482.         $data['valores'] = $valores;
  1483.         return $data;
  1484.     }     
  1485.     /**
  1486.      * Method procLogin
  1487.      *
  1488.      * @param $paraProceso $paraProceso [explicite description]
  1489.      *
  1490.      * @return void
  1491.      */
  1492.     private function procLogin($paraProceso){
  1493.         $entityManager = $this->getDoctrine()->getManager();
  1494.         $fi = new FuncionesIvtcotizador();
  1495.         $registry = $paraProceso['registry'];
  1496.         //$HTTP_HOST = $paraProceso['HTTP_HOST'];
  1497.         $lastUsername = $paraProceso['lastUsername'];
  1498.         ///
  1499.         //$clientesRepo = new ClientesRepository($registry);
  1500.         //$usuariosRepo = new UsuariosRepository($registry, $requestStack);
  1501.         ///
  1502.         //$claStatus = 0;
  1503.         //$servidorDatos = $fi->servidorDatos($HTTP_HOST);
  1504.         //$claCliente = 0;
  1505.         //$usuario = $usuariosRepo->findForCorreoSinCliente($correo);
  1506.         
  1510.         // switch ($servidorDatos['tipo']) {
  1511.         //     case 'subDominio':
  1512.         //         $clientes = $clientesRepo->findBySubdominio($servidorDatos['subDominio']);
  1514.         //         foreach ($clientes as $cliente) {
  1515.         //             $claCliente = $cliente->getClacliente();
  1516.         //             $claStatus = $cliente->getClastatus();
  1517.         //             break;
  1518.         //         }
  1519.         //         break;
  1520.         // }
  1521.         ///
  1522.         $controladorA = explode('\\', get_called_class());
  1523.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, 0);
  1524.         $rotulos = [
  1525.             'entrar' => $_n['entrar'] ?? 'Entrar',
  1526.             'nomUsuario' => $_n['nomUsuario'] ?? 'Usuario',
  1527.             'contra' => $_n['contra'] ?? 'Contraseña',
  1528.             'nomUsuarioAviso' => $_n['nomUsuarioAviso'] ?? 'Indique el usuario',
  1529.             'contraAviso' => $_n['contraAviso'] ?? 'Indique la contraseña',
  1530.             'olvido' => $_n['olvido'] ?? '¿Olvidaste la contraseña?',
  1531.             'titulo' => $_n['titulo'] ?? 'Bienvenido',
  1532.             'olvidoTitulo' => $_n['olvidoTitulo'] ?? 'Recuperación de contraseña',
  1533.             'recuperar' => $_n['recuperar'] ?? 'Recuperar',
  1534.             'cancelar' => $_n['cancelar'] ?? 'Cancelar',
  1535.             'correo' => $_n['correo'] ?? 'Correo',
  1536.             'correoAviso' => $_n['correoAviso'] ?? 'Indique el correo',
  1537.             'errorInstancia' => $_n['errorInstancia'] ?? 'Error en la instancia',
  1538.             'cerrar' => $_n['cerrar'] ?? 'Cerrar',
  1539.             'errorUsuario' => $_n['errorUsuario'] ?? 'Error en usuario o contraseña',
  1540.             //'cuentaSuspendida' => $_n['cuentaSuspendida'] ?? 'Cuenta suspendida',
  1541.         ];
  1543.         $valores = [
  1544.             'nomUsuario' => $lastUsername,
  1545.         ];
  1546.         $generales = [];
  1548.         $cerrar = $rotulos['cerrar'];
  1549.         $errorCredenciales = $rotulos['errorUsuario'];
  1550.         $error = false;
  1551.         // $plantilla = 'usuarios/login.twig';
  1552.         // if ($claCliente == 0) {
  1553.         //     $errorCredenciales = $rotulos['errorInstancia'];
  1554.         //     $error = true;
  1555.         //     $plantilla = 'usuarios/loginCuentaSuspendida.twig';
  1556.         // } else {
  1557.         //     $error = false;
  1558.         //     if ($claStatus != Clientes::_claStatusActivo) {
  1559.         //         $errorCredenciales = $rotulos['cuentaSuspendida'];
  1560.         //         $error = true;
  1561.         //         $plantilla = 'usuarios/loginCuentaSuspendida.twig';
  1562.         //     }
  1563.         // }
  1564.         ///
  1565.         $data = [];
  1566.         $data['rotulos'] = $rotulos;
  1567.         $data['valores'] = $valores;
  1568.         $data['generales'] = $generales;
  1569.         //$data['claCliente'] = $claCliente;
  1570.         $data['cerrar'] = $cerrar;
  1571.         $data['errorCredenciales'] = $errorCredenciales;
  1572.         //$data['plantilla'] = $plantilla;
  1573.         $data['error'] = $error;
  1574.         return $data;
  1575.     }
  1576.     /**
  1577.      * Method procUbicacionCambiar
  1578.      *
  1579.      * @param array $paraProceso
  1580.      *
  1581.      * @return void
  1582.      */
  1583.     private function procUbicacionCambiar($paraProceso)
  1584.     {
  1585.         $entityManager = $this->getDoctrine()->getManager();
  1586.         $fi = new FuncionesIvtcotizador();
  1587.         $registry = $paraProceso['registry'];
  1588.         $usuarioUbiRepo = new UsuarioubicacionesRepository($registry);
  1589.         $ubicacionesRepo = new UbicacionesRepository($registry);
  1590.         $cliente = $paraProceso['cliente'];
  1591.         $claUsuario = $paraProceso['claUsuario'];
  1592.         $claUbicacion = $paraProceso['claUbicacion'];
  1593.         ///
  1594.         $controladorA = explode('\\', get_called_class());
  1595.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  1596.         $rotulos = [
  1597.             'titulo' => $_n['titulo'] ?? 'Cambio de ubicación',
  1598.             'nomUbicacion' => $_n['nomUbicacion'] ?? 'Ubicación',
  1599.             'ubicacion' => $_n['ubicacion'] ?? 'Ubicación',
  1600.             'region' => $_n['region'] ?? 'Región',
  1601.             'centro' => $_n['centro'] ?? 'Centro',
  1602.             'agregar' => $_n['agregar'] ?? 'Agregar',
  1603.             'cambiar' => $_n['cambiar'] ?? 'Cambiar',
  1604.             'cambiarTip' => $_n['cambiarTip'] ?? 'Cambia a la ubicación seleccionada',
  1605.         ];
  1607.         $ubicaciones = $ubicacionesRepo->findForIndiceEsClaveConNivel($cliente);
  1608.         $valoresDB = $usuarioUbiRepo->findForGrid($cliente, $claUsuario);
  1609.         $valores = [];
  1610.         $enLista = ['claUsuario', 'claUbicacion', 'claUsuarioUbicacion'];
  1611.         $cuentas = [];
  1612.         foreach ($valoresDB as $x => $campos) {
  1613.             $array = [];
  1614.             $agregar = true;
  1615.             foreach ($campos as $y => $campo) {
  1616.                 if (in_array($campo['alias'], $enLista)) {
  1617.                     $array[$campo['alias']] = $campo['valor'];
  1618.                 }
  1619.                 //nomUbicacion
  1620.                 if ($campo['alias'] == 'claUbicacion') {
  1621.                     $array['nomUbicacion'] = $ubicaciones[$campo['valor']] ?? '';
  1622.                     if($campo['valor'] == $claUbicacion){
  1623.                         $agregar = false;
  1624.                     }
  1625.                 }
  1626.                 $array['eliminar'] = true;
  1627.                 if ($campo['alias'] == 'claUsuarioUbicacion') {
  1628.                     $cuentas[$campo['valor']] = 0;
  1629.                 }
  1630.             }
  1631.             if($agregar){
  1632.                 $valores[] = $array;
  1633.             }
  1634.         }
  1636.         $generales = [];
  1637.         $generales['claUsuario'] = $claUsuario;
  1638.         //la data
  1639.         $data = [];
  1640.         $data['rotulos'] = $rotulos;
  1641.         $data['valores'] = $valores;
  1642.         $data['generales'] = $generales;
  1643.         return $data;
  1644.     }
  1645.     /**
  1646.      * Method procUbicacionCambiarEnviar
  1647.      *
  1648.      * @param array $paraProceso
  1649.      *
  1650.      * @return array
  1651.      */
  1652.     private function procUbicacionCambiarEnviar($paraProceso): array
  1653.     {
  1654.         $fi = new FuncionesIvtcotizador();
  1655.         $registry = $paraProceso['registry'];
  1656.         $usuarioUbiRepo = new UsuarioubicacionesRepository($registry);
  1657.         $ubicacionesRepo = new UbicacionesRepository($registry);
  1658.         $cliente = $paraProceso['cliente'];
  1659.         $sesion = $paraProceso['sesion'];
  1660.         $claUsuarioUbicacion = $paraProceso['claUsuarioUbicacion'];
  1661.         ///
  1662.         $controladorA = explode('\\', get_called_class());
  1663.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  1664.         $rotulos = [
  1665.             'exito' => $_n['exito'] ?? 'Ubicación cambiada con éxito',
  1666.             'noExiste' => $_n['noExiste'] ?? 'La ubicación no existe',
  1667.         ];
  1668.         $resultado = 1;
  1669.         $mensaje = $rotulos['exito'];
  1671.         $usuarioUbicacion = $usuarioUbiRepo->find($claUsuarioUbicacion);
  1672.         if ($usuarioUbicacion == null) {
  1673.             $resultado = -1;
  1674.             $mensaje = $rotulos['noExiste'];
  1675.         }
  1677.         if ($resultado == 1) {
  1678.             //$sesion->set('claUbicacion', $usuarioUbicacion->getClaubicacion());
  1679.             $claUbicacion = $usuarioUbicacion->getClaubicacion();
  1680.             $nomUbicacion = $ubicacionesRepo->findForNombre($cliente, $claUbicacion);
  1681.         }
  1682.         //la data
  1683.         $data = [];
  1684.         $data['resultado'] = $resultado;
  1685.         $data['mensaje'] = $mensaje;
  1686.         $data['claUbicacion'] = $claUbicacion;
  1687.         $data['nomUbicacion'] = $nomUbicacion;
  1688.         return $data;
  1689.     }
  1690.     /**
  1691.      * Method procUsuariosPerfiles
  1692.      *
  1693.      * @param $paraProceso $paraProceso [explicite description]
  1694.      *
  1695.      * @return array
  1696.      */
  1697.     private function procUsuariosPerfiles($paraProceso): array
  1698.     {
  1699.         $fi = new FuncionesIvtcotizador();
  1700.         $registry = $paraProceso['registry'];
  1701.         $requestStack = $paraProceso['requestStack'];
  1702.         $usuarioFunciones = $paraProceso['usuarioFunciones'];
  1703.         $cliente = $paraProceso['cliente'];
  1704.         ///
  1705.         $perfilesRepo = new PerfilesRepository($registry);
  1706.         $usuariosRepo = new UsuariosRepository($registry, $requestStack);
  1707.         $funcionesRepo = new FuncionesRepository($registry);
  1708.         ///
  1709.         $controladorA = explode('\\', get_called_class());
  1710.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  1711.         $rotulos = [
  1712.             'titulo' => $_n['titulo'] ?? 'Perfiles',
  1713.             'exportar' => $_n['exportar'] ?? 'Exportar',
  1714.             'nuevo' => $_n['nuevo'] ?? 'Nuevo',
  1715.             'perfil' => $_n['perfil'] ?? 'Perfil',
  1716.             'perfiles' => $_n['perfiles'] ?? 'Perfiles',
  1717.             'eliminarConfirmar' => $_n['eliminarConfirmar'] ?? '¿Está seguro de querer eliminar este perfil?',
  1718.             'opciones' => $_n['opciones'] ?? 'Opciones',
  1719.             'opcionesTip' => $_n['opcionesTip'] ?? 'Opciones del perfil',
  1720.             'eliminar' => $_n['eliminar'] ?? 'Eliminar',
  1721.             'eliminarTip' => $_n['eliminarTip'] ?? 'Elimina al perfil seleccionado',
  1722.         ];
  1723.         $valoresDB = $perfilesRepo->findForGrid($cliente);
  1724.         $valores = [];
  1725.         $enLista = ['claPerfil', 'nomPerfil'];
  1726.         $cuentas = [];
  1727.         foreach ($valoresDB as $x => $campos) {
  1728.             $array = [];
  1729.             foreach ($campos as $y => $campo) {
  1730.                 if (in_array($campo['alias'], $enLista)) {
  1731.                     $array[$campo['alias']] = $campo['valor'];
  1732.                 }
  1733.                 $array['eliminar'] = true;
  1734.                 if ($campo['alias'] == 'claPerfil') {
  1735.                     $cuentas[$campo['valor']] = 0;
  1736.                 }
  1737.             }
  1738.             $valores[] = $array;
  1739.         }
  1740.         $usuarios = $usuariosRepo->findForCatalogoRS($cliente);
  1741.         foreach ($usuarios as $usuario) {
  1742.             $cuentas[$usuario->getClaperfil()]++;
  1743.         }
  1744.         foreach ($valores as $v => $valor) {
  1745.             $claPerfil = $valor["claPerfil"];
  1746.             $cuenta = 0;
  1747.             if (isset($cuentas[$claPerfil])) {
  1748.                 $cuenta = $cuentas[$claPerfil];
  1749.             }
  1750.             if ($cuenta > 0) {
  1751.                 $valores[$v]['eliminar'] = false;
  1752.             }
  1753.         }
  1754.         ///
  1755.         $html = [
  1756.             "titulo" => $rotulos['titulo'],
  1757.         ];
  1758.         $funcionesRegistro = $funcionesRepo->findForHijas('20T01', 2);
  1759.         foreach ($funcionesRegistro as $claFuncion => $fun) {
  1760.             $funcionesRegistro[$claFuncion]['conDerecho'] = false;
  1761.             foreach ($usuarioFunciones as $claFun => $nomFuncion){
  1762.                 if($claFuncion == $claFun){
  1763.                     $funcionesRegistro[$claFuncion]['conDerecho'] = true;
  1764.                     break;
  1765.                 }
  1766.             }
  1767.         }
  1768.         //la data
  1769.         $data = [];
  1770.         $data['rotulos'] = $rotulos;
  1771.         $data['valores'] = $valores;
  1772.         $data['funcionesRegistro'] = $funcionesRegistro;
  1773.         $data['html'] = $html;
  1774.         return $data;
  1775.     }
  1776.     /**
  1777.      * Method procUsuariosPerfilesEditar
  1778.      *
  1779.      * @param $paraProceso $paraProceso [explicite description]
  1780.      *
  1781.      * @return array
  1782.      */
  1783.     private function procUsuariosPerfilesEditar($paraProceso): array
  1784.     {
  1785.         $fi = new FuncionesIvtcotizador();
  1786.         $registry = $paraProceso['registry'];
  1787.         $cliente = $paraProceso['cliente'];
  1788.         $claPerfil = $paraProceso['claPerfil'];
  1789.         ///
  1790.         $perfilesRepo = new PerfilesRepository($registry);
  1791.         ///
  1792.         $generales = [];
  1793.         $generales['claPerfil'] = $claPerfil;
  1794.         $generales['nuevo'] = $claPerfil > 0 ? 0 : 1;
  1795.         ///
  1796.         $controladorA = explode('\\', get_called_class());
  1797.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  1798.         $rotulos = [
  1799.             'nuevoPerfil' => $_n['nuevoPerfil'] ?? 'Nuevo perfil',
  1800.             'editarPerfil' => $_n['editarPerfil'] ?? 'Modificar perfil',
  1801.             'cancelar' => $_n['cancelar'] ?? 'Cancelar',
  1802.             'nomPerfil' => $_n['nomPerfil'] ?? 'Perfil',
  1803.             'guardar' => $_n['guardar'] ?? 'Guardar',
  1804.             'nomPerfilAviso' => $_n['nomPerfilAviso'] ?? 'Indique el perfil',
  1805.             'error' => $_n['error'] ?? 'Revise los campos',
  1806.         ];
  1807.         ///
  1808.         $html = [];
  1809.         $html["nuevo"] = $claPerfil > 0 ? self::_editar : self::_nuevo;
  1810.         ///
  1811.         if ($claPerfil > 0) {
  1812.             $rotulos['titulo'] = $rotulos['editarPerfil'];
  1813.             $valoresFor = $perfilesRepo->findForEditar($cliente, $claPerfil);
  1814.         } else {
  1815.             $rotulos['titulo'] = $rotulos['nuevoPerfil'];
  1816.             $valoresFor = $perfilesRepo->findForNuevo();
  1817.         }
  1819.         $valores = [];
  1820.         foreach ($valoresFor as $v => $valor) {
  1821.             $valores[$valor['alias']] = $valor['valor'];
  1822.         }
  1823.         //la data
  1824.         $data = [];
  1825.         $data['rotulos'] = $rotulos;
  1826.         $data['valores'] = $valores;
  1827.         $data['generales'] = $generales;
  1828.         $data['html'] = $html;
  1829.         return $data;
  1830.     }
  1831.     /**
  1832.      * Method procUsuariosPerfilesEnviar
  1833.      *
  1834.      * @param $paraProceso $paraProceso [explicite description]
  1835.      *
  1836.      * @return array
  1837.      */
  1838.     private function procUsuariosPerfilesEnviar($paraProceso): array
  1839.     {
  1840.         $entityManager = $this->getDoctrine()->getManager();
  1841.         $registry = $paraProceso['registry'];
  1842.         $cliente = $paraProceso['cliente'];
  1843.         $perfilesRepo = new PerfilesRepository($registry);
  1844.         $claPerfil = $paraProceso['claPerfil'];
  1845.         $nuevo = $paraProceso['nuevo'];
  1846.         $data = $paraProceso['data'];
  1847.         $fi = new FuncionesIvtcotizador();
  1848.         ///
  1849.         $controladorA = explode('\\', get_called_class());
  1850.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  1851.         $rotulos = [
  1852.             'exito' => $_n['exito'] ?? 'Perfil actualizado con éxito',
  1853.             'noExiste' => $_n['noExiste'] ?? 'El perfil no existe',
  1854.         ];
  1855.         
  1856.         $resultado = 1;
  1857.         $mensaje = $rotulos['exito'];
  1858.         $perfil = new Perfiles();
  1859.         if ($nuevo == self::_editar) {
  1860.             $perfil = $perfilesRepo->find($claPerfil);
  1861.             if ($perfil == null) {
  1862.                 $resultado = -1;
  1863.                 $mensaje = $rotulos['noExiste'];
  1864.             }
  1865.         }
  1867.         $dataGrid = [];
  1869.         if ($resultado == 1) {
  1870.             $camposContinuar = ['claperfil', 'nuevo'];
  1871.             $camposSoloNuevo = ['clacliente'];
  1872.             $camposParaGrid = ['nomperfil'];
  1873.             foreach ($data as $d => $valor) {
  1874.                 $campo = strtolower($d);
  1875.                 if (in_array($campo, $camposContinuar)) {
  1876.                     continue;
  1877.                 }
  1878.                 if (in_array($campo, $camposParaGrid)) {
  1879.                     $dataGrid[$d] = $valor;
  1880.                 }
  1881.                 if ($nuevo == 1) {
  1882.                     if ($campo == 'clacliente') {
  1883.                         $valor = $cliente;
  1884.                     }
  1885.                 } else {
  1886.                     if (in_array($campo, $camposSoloNuevo)) {
  1887.                         continue;
  1888.                     }
  1889.                 }
  1890.                 $campoSet = "set" . ucfirst($campo);
  1891.                 $perfil->$campoSet($valor);
  1892.             }
  1894.             $entityManager->persist($perfil);
  1895.             $entityManager->flush();
  1896.             $dataGrid['claPerfil'] = $perfil->getClaperfil();
  1897.         }
  1898.         //la data
  1899.         $data = [];
  1900.         $data['resultado'] = $resultado;
  1901.         $data['mensaje'] = $mensaje;
  1902.         $data['dataGrid'] = $dataGrid;
  1903.         return $data;
  1904.     }
  1905.     /**
  1906.      * Method procUsuariosPerfilesOpciones
  1907.      *
  1908.      * @param $paraProceso $paraProceso [explicite description]
  1909.      *
  1910.      * @return array
  1911.      */
  1912.     private function procUsuariosPerfilesOpciones($paraProceso): array
  1913.     {
  1914.         $fi = new FuncionesIvtcotizador();
  1915.         $registry = $paraProceso['registry'];
  1916.         $cliente = $paraProceso['cliente'];
  1917.         $perfilesRepo = new PerfilesRepository($registry);
  1918.         $perfilFuncionesRepo = new PerfilfuncionesRepository($registry);
  1919.         $clienteFuncionesRepo = new ClientefuncionesRepository($registry);
  1920.         $funcionesRepo = new FuncionesRepository($registry);
  1921.         $claPerfil = $paraProceso['claPerfil'];
  1922.         ///
  1923.         $generales = [];
  1924.         $generales['claPerfil'] = $claPerfil;
  1925.         ///
  1926.         $controladorA = explode('\\', get_called_class());
  1927.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  1928.         $rotulos = [
  1929.             'aplicarSubNiveles' => $_n['aplicarSubNiveles'] ?? 'Aplicar a subNiveles',
  1930.             'opciones' => $_n['opciones'] ?? 'Opciones del perfil',
  1931.         ];
  1932.         $rotulos["nomPerfil"] = $perfilesRepo->findForNombre($cliente, $claPerfil);
  1933.         ///
  1934.         $html = [];
  1936.         $funcionesPerfil = $perfilFuncionesRepo->findForClaCliente($cliente, $claPerfil);
  1937.         $funcionesCliente = $clienteFuncionesRepo->findForCatalogo($cliente);
  1938.         $funciones = [];
  1940.         $funNivel1 = $funcionesRepo->findForNivel(1);
  1941.         $funNivel2 = $funcionesRepo->findForNivel(2);
  1942.         $funNivel3 = $funcionesRepo->findForNivel(3);
  1943.         $funNivel4 = $funcionesRepo->findForNivel(4);
  1944.         $funNivel5 = $funcionesRepo->findForNivel(5);
  1945.         $funNivel6 = $funcionesRepo->findForNivel(6);
  1946.         $funNivel7 = $funcionesRepo->findForNivel(7);
  1948.         foreach ($funNivel1 as $claFuncion => $fun) {
  1949.             $fun['seleccionada'] = false;
  1950.             $fun['title'] = $fun['descripcion'];
  1951.             $fun['claFuncion'] = $claFuncion;
  1952.             $fun['folder'] = true;
  1953.             $fun['expanded'] = false;
  1954.             $fun['extraClasses'] = 'no-seleccionada';
  1955.             $fun['children'] = [];
  1956.             foreach ($funNivel2 as $claFuncion2 => $fun2) {
  1957.                 if ($claFuncion == $fun2['padre']) {
  1958.                     $fun2['seleccionada'] = false;
  1959.                     $fun2['title'] = $fun2['descripcion'];
  1960.                     $fun2['claFuncion'] = $claFuncion2;
  1961.                     $fun2['expanded'] = false;
  1962.                     $fun2['extraClasses'] = 'no-seleccionada';
  1963.                     $fun2['children'] = [];
  1965.                     foreach ($funNivel3 as $claFuncion3 => $fun3) {
  1966.                         if ($claFuncion2 == $fun3['padre']) {
  1967.                             $fun3['seleccionada'] = false;
  1968.                             $fun3['title'] = $fun3['descripcion'];
  1969.                             $fun3['claFuncion'] = $claFuncion3;
  1970.                             $fun3['expanded'] = false;
  1971.                             $fun3['extraClasses'] = 'no-seleccionada';
  1972.                             $fun3['children'] = [];
  1974.                             foreach ($funNivel4 as $claFuncion4 => $fun4) {
  1975.                                 if ($claFuncion3 == $fun4['padre']) {
  1976.                                     $fun4['seleccionada'] = false;
  1977.                                     $fun4['title'] = $fun4['descripcion'];
  1978.                                     $fun4['claFuncion'] = $claFuncion4;
  1979.                                     $fun4['expanded'] = false;
  1980.                                     $fun4['extraClasses'] = 'no-seleccionada';
  1981.                                     $fun4['children'] = [];
  1983.                                     foreach ($funNivel5 as $claFuncion5 => $fun5) {
  1984.                                         if ($claFuncion4 == $fun5['padre']) {
  1985.                                             $fun5['seleccionada'] = false;
  1986.                                             $fun5['title'] = $fun5['descripcion'];
  1987.                                             $fun5['claFuncion'] = $claFuncion5;
  1988.                                             $fun5['expanded'] = false;
  1989.                                             $fun5['extraClasses'] = 'no-seleccionada';
  1990.                                             $fun5['children'] = [];
  1992.                                             foreach ($funNivel6 as $claFuncion6 => $fun6) {
  1993.                                                 if ($claFuncion5 == $fun6['padre']) {
  1994.                                                     $fun6['seleccionada'] = false;
  1995.                                                     $fun6['title'] = $fun6['descripcion'];
  1996.                                                     $fun6['claFuncion'] = $claFuncion6;
  1997.                                                     $fun6['expanded'] = false;
  1998.                                                     $fun6['extraClasses'] = 'no-seleccionada';
  1999.                                                     $fun6['children'] = [];
  2001.                                                     foreach ($funNivel7 as $claFuncion7 => $fun7) {
  2002.                                                         if ($claFuncion6 == $fun7['padre']) {
  2003.                                                             $fun7['seleccionada'] = false;
  2004.                                                             $fun7['title'] = $fun7['descripcion'];
  2005.                                                             $fun7['claFuncion'] = $claFuncion7;
  2006.                                                             $fun7['expanded'] = false;
  2007.                                                             $fun7['extraClasses'] = 'no-seleccionada';
  2008.                                                             $fun7['children'] = [];
  2009.                                                             if (in_array($claFuncion7, $funcionesCliente)) {
  2010.                                                                 $fun6['children'][] = $fun7;
  2011.                                                             }
  2012.                                                         }
  2013.                                                     }//nivel 7
  2014.                                                     if (in_array($claFuncion6, $funcionesCliente)) {
  2015.                                                         $fun5['children'][] = $fun6;
  2016.                                                     }
  2017.                                                 }
  2018.                                             }//nivel 6
  2019.                                             if (in_array($claFuncion5, $funcionesCliente)) {
  2020.                                                 $fun4['children'][] = $fun5;
  2021.                                             }
  2022.                                         }
  2023.                                     }//nivel 5
  2024.                                     if (in_array($claFuncion4, $funcionesCliente)) {
  2025.                                         $fun3['children'][] = $fun4;
  2026.                                     }
  2027.                                 }
  2028.                             }//nivel 4
  2029.                             if (in_array($claFuncion3, $funcionesCliente)) {
  2030.                                 $fun2['children'][] = $fun3;
  2031.                             }
  2032.                         }
  2033.                     }//nivel 3
  2034.                     if (in_array($claFuncion2, $funcionesCliente)) {
  2035.                         $fun['children'][] = $fun2;
  2036.                     }
  2037.                 }
  2038.             }//nivel 2
  2039.             if (in_array($claFuncion, $funcionesCliente)) {
  2040.                 $funciones[] = $fun;
  2041.             }
  2042.         }
  2044.         foreach ($funcionesPerfil as $cliFun) {
  2045.             $claFuncion = $cliFun->getClaFuncion();
  2046.             foreach ($funciones as $clave => $fun) {
  2047.                 if ($claFuncion == $fun['claFuncion']) {
  2048.                     $funciones[$clave]['seleccionada'] = true;
  2049.                     $funciones[$clave]['extraClasses'] = 'seleccionada';
  2050.                     break;
  2051.                 } else {
  2052.                     foreach ($fun['children'] as $clave2 => $fun2) {
  2053.                         if ($claFuncion == $fun2['claFuncion']) {
  2054.                             $funciones[$clave]['children'][$clave2]['seleccionada'] = true;
  2055.                             $funciones[$clave]['children'][$clave2]['extraClasses'] = 'seleccionada';
  2056.                             break;
  2057.                         } else {
  2058.                             foreach ($fun2['children'] as $clave3 => $fun3) {
  2059.                                 if ($claFuncion == $fun3['claFuncion']) {
  2060.                                     $funciones[$clave]['children'][$clave2]['children'][$clave3]['seleccionada'] = true;
  2061.                                     $funciones[$clave]['children'][$clave2]['children'][$clave3]['extraClasses'] = 'seleccionada';
  2062.                                     break;
  2063.                                 } else {
  2064.                                     foreach ($fun3['children'] as $clave4 => $fun4) {
  2065.                                         if ($claFuncion == $fun4['claFuncion']) {
  2066.                                             $funciones[$clave]['children'][$clave2]['children'][$clave3]['children'][$clave4]['seleccionada'] = true;
  2067.                                             $funciones[$clave]['children'][$clave2]['children'][$clave3]['children'][$clave4]['extraClasses'] = 'seleccionada';
  2068.                                             break;
  2069.                                         } else {
  2070.                                             foreach ($fun4['children'] as $clave5 => $fun5) {
  2071.                                                 if ($claFuncion == $fun5['claFuncion']) {
  2072.                                                     $funciones[$clave]['children'][$clave2]['children'][$clave3]['children'][$clave4]['children'][$clave5]['seleccionada'] = true;
  2073.                                                     $funciones[$clave]['children'][$clave2]['children'][$clave3]['children'][$clave4]['children'][$clave5]['extraClasses'] = 'seleccionada';
  2074.                                                     break;
  2075.                                                 } else {
  2076.                                                     foreach ($fun5['children'] as $clave6 => $fun6) {
  2077.                                                         if ($claFuncion == $fun6['claFuncion']) {
  2078.                                                             $funciones[$clave]['children'][$clave2]['children'][$clave3]['children'][$clave4]['children'][$clave5]['children'][$clave6]['seleccionada'] = true;
  2079.                                                             $funciones[$clave]['children'][$clave2]['children'][$clave3]['children'][$clave4]['children'][$clave5]['children'][$clave6]['extraClasses'] = 'seleccionada';
  2080.                                                             break;
  2081.                                                         }
  2082.                                                         foreach ($fun6['children'] as $clave7 => $fun7) {
  2083.                                                             if ($claFuncion == $fun7['claFuncion']) {
  2084.                                                                 $funciones[$clave]['children'][$clave2]['children'][$clave3]['children'][$clave4]['children'][$clave5]['children'][$clave6]['children'][$clave7]['seleccionada'] = true;
  2085.                                                                 $funciones[$clave]['children'][$clave2]['children'][$clave3]['children'][$clave4]['children'][$clave5]['children'][$clave6]['children'][$clave7]['extraClasses'] = 'seleccionada';
  2086.                                                                 break;
  2087.                                                             }
  2088.                                                         }
  2089.                                                     }
  2090.                                                 }
  2091.                                             }
  2092.                                         }
  2093.                                     }
  2094.                                 }
  2095.                             }
  2096.                         }
  2097.                     }
  2098.                 }
  2099.             }
  2100.         }
  2101.         //la data
  2102.         $data = [];
  2103.         $data['rotulos'] = $rotulos;
  2104.         $data['generales'] = $generales;
  2105.         $data['funciones'] = $funciones;
  2106.         $data['html'] = $html;
  2107.         return $data;
  2108.     }
  2109.     /**
  2110.      * Method procUsuariosPerfilesOpcionesEnviar
  2111.      *
  2112.      * @param $paraProceso $paraProceso [explicite description]
  2113.      *
  2114.      * @return array
  2115.      */
  2116.     private function procUsuariosPerfilesOpcionesEnviar($paraProceso): array
  2117.     {
  2118.         $entityManager = $this->getDoctrine()->getManager();
  2119.         $fi = new FuncionesIvtcotizador();
  2120.         $registry = $paraProceso['registry'];
  2121.         $cliente = $paraProceso['cliente'];
  2122.         $claPerfil = $paraProceso['claPerfil'];
  2123.         $funciones = $paraProceso['funciones'];
  2124.         $seleccionada = $paraProceso['seleccionada'];
  2125.         ///
  2126.         $seleccionada = $seleccionada == 'true' ? true : false;
  2127.         ///
  2128.         $controladorA = explode('\\', get_called_class());
  2129.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  2130.         $rotulos = [
  2131.             'exito' => $_n['exito'] ?? 'Funciones guardadas con éxito',
  2132.         ];
  2133.         $resultado = 1;
  2134.         $mensaje = $rotulos['exito'];
  2136.         $funA = explode('|', $funciones);
  2138.         foreach ($funA as $x => $fun) {
  2139.             if (strlen($fun) > 0) {
  2140.                 if ($seleccionada) {
  2141.                     $funcion = new Perfilfunciones();
  2142.                     $funcion->setClacliente($cliente);
  2143.                     $funcion->setClaperfil($claPerfil);
  2144.                     $funcion->setClafuncion($fun);
  2145.                     $entityManager->persist($funcion);
  2146.                     $entityManager->flush();
  2147.                 } else {
  2148.                     //elimina
  2149.                     $qb = $entityManager->createQueryBuilder();
  2150.                     $qb->delete()
  2151.                             ->from('App\Entity\Perfilfunciones', 'p')
  2152.                             ->where('p.clafuncion = :claFuncion')
  2153.                             ->andWhere('p.clacliente = :claCliente')
  2154.                             ->andWhere('p.claperfil = :claPerfil')
  2155.                             ->setParameters(['claFuncion' => $fun, 'claPerfil' => $claPerfil, 'claCliente' => $cliente])
  2156.                             ->getQuery()
  2157.                             ->getResult();
  2158.                     //elimina de favoritos
  2159.                     $qb = $entityManager->createQueryBuilder();
  2160.                     $qb->delete()
  2161.                             ->from('App\Entity\Usuariosfavoritos', 'p')
  2162.                             ->where('p.clafuncion = :claFuncion')
  2163.                             ->andWhere('p.clacliente = :claCliente')
  2164.                             ->setParameters(['claFuncion' => $fun, 'claCliente' => $claPerfil])
  2165.                             ->getQuery()
  2166.                             ->getResult();
  2167.                 }
  2168.             }
  2169.         }
  2170.         //la data
  2171.         $data = [];
  2172.         $data['resultado'] = $resultado;
  2173.         $data['mensaje'] = $mensaje;
  2174.         return $data;
  2175.     }
  2176.     /**
  2177.      * Method procUsuariosPerfilesEliminar
  2178.      *
  2179.      * @param $paraProceso $paraProceso [explicite description]
  2180.      *
  2181.      * @return array
  2182.      */
  2183.     private function procUsuariosPerfilesEliminar($paraProceso): array
  2184.     {
  2185.         $entityManager = $this->getDoctrine()->getManager();
  2186.         $fi = new FuncionesIvtcotizador();
  2187.         $registry = $paraProceso['registry'];
  2188.         $claPerfil = $paraProceso['claPerfil'];
  2189.         $cliente = $paraProceso['cliente'];
  2190.         $perfilesRepo = new PerfilesRepository($registry);
  2191.         ///
  2192.         $resultado = 1;
  2193.         ///
  2194.         $controladorA = explode('\\', get_called_class());
  2195.         $_n = $fi->get_n($registry, end($controladorA), __FUNCTION__, $cliente);
  2196.         $rotulos = [
  2197.             'exito' => $_n['exito'] ?? 'Perfil eliminado',
  2198.             'noExiste' => $_n['noExiste'] ?? 'Perfil no existe',
  2199.         ];
  2200.         
  2201.         $mensaje = $rotulos['exito'];
  2202.         $perfil = $perfilesRepo->find($claPerfil);
  2203.         if ($perfil == null) {
  2204.             $resultado = -1;
  2205.             $mensaje = $rotulos['noExiste'];
  2206.         } else {
  2207.             //elimina opciones
  2208.             $qb = $entityManager->createQueryBuilder();
  2209.             $qb->delete()
  2210.                 ->from('App\Entity\Perfilfunciones', 'k')
  2211.                 ->where('k.claperfil = :claPerfil')
  2212.                 ->setParameters(['claPerfil' => $claPerfil,]);
  2213.             $query = $qb->getQuery();
  2214.             $query->execute();
  2215.             //elimina al perfil
  2216.             $entityManager->remove($perfil);
  2217.             $entityManager->flush();
  2218.         }
  2219.         //la data
  2220.         $data = [];
  2221.         $data['resultado'] = $resultado;
  2222.         $data['mensaje'] = $mensaje;
  2223.         return $data;
  2224.     }
  2225.     /**
  2226.      * Method procContraRecuperarEnviar
  2227.      *
  2228.      * @param $paraProceso $paraProceso [explicite description]
  2229.      *
  2230.      * @return array
  2231.      */
  2232.     private function procContraRecuperarEnviar($paraProceso): array
  2233.     {
  2234.         $entityManager = $this->getDoctrine()->getManager();
  2235.         $fi = new FuncionesIvtcotizador();
  2236.         $registry = $paraProceso['registry'];
  2237.         $requestStack = $paraProceso['requestStack'];
  2238.         $correo = $paraProceso['correo'];
  2239.         $hasher = $paraProceso['hasher'];
  2240.         $mailer = $paraProceso['mailer'];
  2241.         ///
  2242.         $usuariosRepo = new UsuariosRepository($registry, $requestStack);
  2243.         ///
  2244.         $resultado = 1;
  2245.         ///
  2246.         //aplicar solo _idioma
  2247.         $controladorA = explode('\\', get_called_class());
  2248.         $_n = $fi->get_nSoloIdioma($registry, end($controladorA), __FUNCTION__);
  2249.         $rotulos = [
  2250.             'contraEnviada' => $_n['contraEnviada'] ?? 'Contraseña enviada',
  2251.             'noExiste' => $_n['noExiste'] ?? 'El usuario no existe',
  2252.         ];
  2253.         $mensaje = $rotulos['contraEnviada'];
  2254.         $sesion = $this->get('session');
  2255.         $cliente = $sesion->get('claCliente');
  2257.         $usuario = $usuariosRepo->findForCorreoSinCliente($correo);
  2258.         $contra = '';
  2259.         $error = '';
  2260.         if ($usuario == null) {
  2261.             $resultado = -1;
  2262.             $mensaje = $rotulos['noExiste'];
  2263.         } else {
  2264.             $contra = $fi->olvidoContra();
  2265.             $contraH = $hasher->hashPassword($usuario, $contra);
  2266.             $usuario->setContra($contraH);
  2267.             $usuario->setPassword($contraH);
  2268.             $entityManager->persist($usuario);
  2269.             $entityManager->flush();
  2270.             ///enviar correo
  2271.             ///
  2272.             // solo _idioma
  2273.             $controladorA = explode('\\', get_called_class());
  2274.             $_n = $fi->get_nSoloIdioma($registry, end($controladorA), __FUNCTION__);
  2275.             $rotulos = [
  2276.                 'titulo' => $_n['titulo'] ?? 'Recuperacion de contraseña',
  2277.                 'nuevaContra' => $_n['nuevaContra'] ?? 'Nueva contraseña',
  2278.                 'contra' => $_n['contra'] ?? 'Contraseña',
  2279.             ];
  2280.             $email = (new TemplatedEmail())
  2281.                     ->from(new Address($fi::_mailMotorUsuario, $fi::_mailMotorNombre))
  2282.                     ->to($correo)
  2283.                     ->subject($rotulos['titulo'])
  2284.                     ->htmlTemplate('usuarios/correoOlvidoContra.twig')
  2285.                     ->context([
  2286.                         'contra' => $contra,
  2287.                         'rotulos' => $rotulos,
  2288.                     ]);
  2289.             try {
  2290.                 $envio = $mailer->send($email);
  2291.             } catch (TransportExceptionInterface $e) {
  2292.                 $error = $e->getMessage();
  2293.             }
  2294.         }
  2295.         //la data
  2296.         $data = [];
  2297.         $data['resultado'] = $resultado;
  2298.         $data['mensaje'] = $mensaje;
  2299.         $data['error'] = $error;
  2300.         return $data;
  2301.     }
  2304. }//fin trait