src/Security/Controller/SecurityController.php line 112

Open in your IDE?
  1. <?php
  3. namespace App\Security\Controller;
  5. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  6. use Symfony\Component\Security\Core\Exception\BadCredentialsException;
  7. use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
  8. use Symfony\Component\HttpFoundation\Response;
  9. //use App\Entity\SeguridadHistorialPassword;
  10. use App\Entity\SeguridadCodigoActivacion;
  11. //use Security\Interfaces\WillyUser;
  12. use Symfony\Component\HttpFoundation\Request;
  13. use Symfony\Component\Security\Core\Security;
  14. use Symfony\Contracts\Translation\TranslatorInterface;
  15. use Symfony\Component\Mailer\MailerInterface;
  16. use Psr\Log\LoggerInterface;
  17. use Symfony\Component\Mime\Email;
  18. use App\Entity\SeguridadUsuario;
  19. use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
  20. use Symfony\Component\Security\Core\Encoder\MessageDigestPasswordEncoder;
  21. use Symfony\Component\Security\Core\Encoder\NativePasswordEncoder;
  22. use Symfony\Component\Routing\Annotation\Route;
  23. use Symfony\Component\Security\Http\Authentication\AuthenticationUtils;
  24. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  25. use App\Entity\TipoSuscripcion;
  26. use App\Entity\Suscripcion;
  27. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  28. use Symfony\Component\HttpFoundation\RequestStack;
  29. use Doctrine\ORM\EntityManagerInterface;
  31. use App\Entity\SeguridadConfiguracion;
  33. /**
  34. *
  35. * Security controller.
  36. *
  37. */
  38. class SecurityController extends AbstractController
  39. {
  40.     private $session;
  41.     private $translator;
  42.     private $logger;
  43.     private $mailer;
  44.     private $encoder;
  45.     private $em;
  46.     private $request;
  48.     public function __construct(UserPasswordHasherInterface $encoder, TranslatorInterface $translator, MailerInterface $mailer, RequestStack $requestStack, EntityManagerInterface $entityManager, LoggerInterface $logger)
  49.     {
  50.         $this->encoder = $encoder;
  51.         $this->translator = $translator;
  52.         $this->mailer = $mailer;
  53.         $this->session = $requestStack->getSession();
  54.         $this->em = $entityManager;
  55.         $this->logger = $logger;
  56.         $this->request = $requestStack->getCurrentRequest();
  57.     }
  59.     public function login(AuthenticationUtils $authenticationUtils): Response
  60.     {
  61.         $session = $this->session;
  62.         $username = $authenticationUtils->getLastUsername();
  63.         $error_msj = '';
  64.         $msj =  $session->get('auth_msj');
  65.         if ($msj)
  66.         {
  67.             $session->remove('auth_msj');
  68.         }
  69.         else
  70.         {
  71.             $msj='';
  72.         }
  74.         $error = $authenticationUtils->getLastAuthenticationError();
  76. /*        if (!$error)
  77.         {
  78.             $error = $session->get(Security::AUTHENTICATION_ERROR);
  79.             $session->remove(Security::AUTHENTICATION_ERROR);
  80.         }*/
  81.         if ($error)
  82.         {
  83.             if ($error instanceof BadCredentialsException ||
  84.                 $error instanceof UsernameNotFoundException)
  85.             {
  86.                 $error_msj = $this->translator->trans('seguridad.autenticacion.error.credenciales');
  87.             }
  88.             else
  89.             if ($error->getMessage()=='Captcha error')
  90.             {
  91.                 $error_msj = $this->translator->trans('seguridad.autenticacion.error.captcha');
  92.             }
  93.             else
  94.             {
  95.                 $error_msj = 'PP '.$error->getMessage();
  96.             }
  97.         }
  99.         return $this->render('Security\ingresar.html.twig',
  100.                             array('last_username' => $username, 'error_msj' => $error_msj, 'msj' => $msj));
  102.     }
  104.     /**
  105.      * @Route("/logout", name="app_logout")
  106.      */
  107.     public function logout()
  108.     {
  109.         throw new \LogicException('This method can be blank - it will be intercepted by the logout key on your firewall.');
  110.     }
  111.     
  112.     public function preLogoutAction() 
  113.     {
  114.         $user = $this->getUser();
  115.         if (is_object($user))
  116.         {
  117.             $user->setConectado(false);
  118.             $user->setFechaAcceso(null);
  119.             $em = $this->em;
  120.             $em->persist($user);
  121.             $em->flush();
  122.         }
  123.         return $this->redirect($this->generateUrl('app_logout')); 
  124.     }    
  126.     public function pageVisitedAction()
  127.     {
  128.         $usuario = $this->get('security.context')->getToken()->getUser();
  129.         if (is_object($usuario))
  130.         {
  131.             $usuario->setFechaAcceso(new \DateTime());
  132.             $em = $this->em;
  133.             $em->persist($usuario);
  134.             $em->flush();
  135.         }
  136.         return new Response('');
  137.     }
  138.     
  139.     public function loginSuccess()
  140.     {
  141.         $usuario = $this->getUser();
  142.         if (!$usuario->getActivo())
  143.         {
  144.             return $this->render('Security\\error.html.twig',
  145.                             array('error_cod' => 'No se puede ingresar.<br><br>El usuario está marcado como bloqueado', 'logout'=>true));
  146.         }
  147.         else
  148.         if ($usuario->getConectado())
  149.         {
  150.             return $this->render('Security\\error.html.twig',
  151.                             array('error_cod' => 'No se puede ingresar.<br><br>El usuario ya está conectado desde otro dispositivo', 'logout'=>true));
  152.         }
  153.         else
  154.         {
  155.             /**ACTIVAR PARA CONTROL DE SESION*/
  156.             $usuario->setConectado(true);
  157.             $usuario->setFechaAcceso(new \DateTime());
  158.         }
  160.         /*        $session = $this->session;
  161.         $data = $this->userCanExecuteAction(false);
  162.         if (!$data['allow'])
  163.         {
  164.             $session->getFlashBag()->set('danger', $data['msg']);
  165.             return $this->redirect($this->generateUrl('login')); 
  166.         }
  167. */        
  168.         $usuario->setIntentosFallidos(0);
  169. /*        if ($usuario->getTempSalt())
  170.         {
  171.             $usuario->setSalt($usuario->getTempSalt());
  172.             $usuario->setTempSalt(null);
  173.         }*/
  174.         $this->em->persist($usuario);
  175.         $this->em->flush();
  176.         
  177. /*        $parameterActiveConfiguration = $this->getParameter('SECURITY_CONF');
  178.         $configuracionSeguridad = $this->em->getRepository(SeguridadConfiguracion::class)->getActiveConfiguration($parameterActiveConfiguration);
  179.         if ($configuracionSeguridad)
  180.         {
  181.             $password = $this->request->get('_password');
  182.             if (!$configuracionSeguridad->getFortalezaPassword()->validPassword($password))
  183.             {
  184.                 return $this->redirect($this->generateUrl('usuario_cambia_password', array('idUsuario'=> $usuario->getId(), 'must'=> 'forcecambio'))); 
  185.             } 
  186.         }*/
  187.         
  188.         $fechaActual = new \DateTime();
  189.         $fechaVigenciaPassword = $usuario->getFechaVigenciaPassword();
  190.         if ($fechaVigenciaPassword)
  191.         {
  192.             if ($fechaVigenciaPassword>$fechaActual)
  193.             {
  194.                 $diasVigenciaPassword = $fechaVigenciaPassword->diff($fechaActual)->days;
  195.                 if ($diasVigenciaPassword<=10)
  196.                 {
  197.                     $this->session->getFlashBag()->set('warning', $translator->trans('seguridad.contrasena.vigencia', array('%dias%' => $$diasVigenciaPassword)));
  198.                 }    
  199.                 return $this->redirect($this->generateUrl('app_home'));
  200.             }
  201.             else 
  202.             {
  203.                 return $this->redirect($this->generateUrl('usuario_cambia_password', array('idUsuario'=> $usuario->getId(), 'must'=> 'forcecaducado'))); 
  204.             }
  205.         }
  207.         return $this->redirect($this->generateUrl('app_home'));
  208.             
  209.     }
  211.     public function loginFailure(Request $request, AuthenticationUtils $authenticationUtils)
  212.     {
  213.         $username = $authenticationUtils->getLastUsername();
  214.         $error = $authenticationUtils->getLastAuthenticationError();
  215.         if ($error)
  216.         {
  217.             if ($error instanceof BadCredentialsException || 
  218.                 $error instanceof UsernameNotFoundException)
  219.             {
  220.                 $usuario = null;
  221.                 if (isset($username))
  222.                 { 
  223.                     $usuario = $this->em->getRepository(SeguridadUsuario::class)->findOneBy(array('username' => $username));
  224.                 }
  225.                 if ($usuario)
  226.                 {
  227.                     $cantfallos = $this->bloquearUsuario($usuario);
  228.                     if ($cantfallos <= 0)
  229.                     {
  230.                         return $this->render('Security\error.html.twig', array('error_cod'=>$this->translator->trans('seguridad.activacion.error.intentos', array())));
  231.                     }    
  232.                     else
  233.                     {
  234.                         $msj = $this->translator->trans('seguridad.autenticacion.error.intentoswrongpass', array('%intentos%'=>$cantfallos));
  235.                         $this->session->set('auth_msj',$msj);
  236.                     }    
  237.                 }
  238.             }  
  239.             if ($error instanceof DisabledException)
  240.             {
  241.                 $this->session->remove(SecurityContext::AUTHENTICATION_ERROR);
  242.                 $this->session->remove(SecurityContext::LAST_USERNAME);
  243.                 return $this->render('Security\error.html.twig',
  244.                     array('error_cod' => $this->translator->trans('seguridad.autenticacion.error.bloqueado')));
  245.             }    
  246.         }    
  248.         return $this->redirect($this->generateUrl('app_login'));
  249.     }
  250.     
  251.     public function recuperaPasswordUsernameAction(Request $request)
  252.     {
  253.         $params = array('username'=>'', 'mail'=>'');
  255.         if ($request->getMethod() == 'POST')
  256.         {
  257.             $username = $request->get('username');
  258.             $from = $request->get('from');
  259.             $params['username']=$username;
  260.             $params['error_name'] = $this->translator->trans('seguridad.recuperacion.error.badinfo');
  261.             if ($from=='login')
  262.             {
  263.                 return $this->recuperaPasswordFromLogin($username, $params);
  264.             }
  265.             else
  266.             {
  267.                 return $this->recuperaPasswordFromRecover($username, $params, $request);
  268.             }
  269.         }
  270.         else
  271.             return $this->render('Security\recuperacion_username.html.twig', $params);
  272.     }
  274.     protected function recuperaPasswordFromLogin($username, $params)
  275.     {
  276.         $em = $this->em;
  277.         if (isset($username))
  278.         {
  279.             $usuario = $em->getRepository(SeguridadUsuario::class)->findOneBy(array('username' => $username));
  280.             if ($usuario)
  281.             {
  282.                 if ($usuario->getEliminado() || !$usuario->getActivo())
  283.                 {
  284.                     $error = $this->translator->trans('seguridad.mail.error.borrado');
  285.                     $kind = 'danger';
  286.                     return $this->render('Security:Security:error.html.twig', array('error_cod'=>$error, 'kind'=>$kind));
  287.                 }
  288.                 else
  289.                 {
  290.         $parameterActiveConfiguration = $this->getParameter('SECURITY_CONF');
  291.         $configuracionSeguridad = $this->em->getRepository(SeguridadConfiguracion::class)->getActiveConfiguration($parameterActiveConfiguration);
  293.                     unset($params['error_name']);
  294.                     $params['mail'] = $seguridadConfiguracion->getCodigoActivacion();
  295.                     //$params['pregunta'] = $usuario->getPreguntaRecuperacion();
  296.                     return $this->render('Security\recuperacion_username.html.twig', $params);
  297.                 }
  298.             }
  299.             else
  300.             {
  301.                 $params['error_name'] = $this->translator->trans('seguridad.mail.error.borrado');
  302.             }
  303.         }
  305.         return $this->render('Security\ingresar.html.twig',
  306.                             array('last_username' => $username, 'error_msj' => $params['error_name'], 'msj' => ''));
  307.     }
  309.     protected function recuperaPasswordFromRecover($username, $params, $request)
  310.     {
  311.         $em = $this->em;
  312.         if (isset($username))
  313.         {
  314.             $usuario = $em->getRepository(SeguridadUsuario::class)->findOneBy(array('username' => $username));
  315.             if ($usuario)
  316.             {
  317.                 if ($usuario->getEliminado() || !$usuario->getActivo())
  318.                 {
  319.                     $error = $this->translator->trans('seguridad.mail.error.borrado');
  320.                     $kind = 'danger';
  321.                     return $this->render('Security:Security:error.html.twig', array('error_cod'=>$error, 'kind'=>$kind));
  322.                 }
  323.                 else
  324.                 {
  325.         $parameterActiveConfiguration = $this->getParameter('SECURITY_CONF');
  326.         $configuracionSeguridad = $this->em->getRepository(SeguridadConfiguracion::class)->getActiveConfiguration($parameterActiveConfiguration);
  328.                     if ($seguridadConfiguracion->getCodigoActivacion())
  329.                     {
  330.                         $mail = $request->get('mail');
  331.                         $params['mail']=$mail;
  333.                         if ($usuario->getEmail()==$mail)
  334.                         {
  335.                             $params = $this->sendRecuperarPasswordMail($em, $usuario);
  337.                             return $this->render('Security\ingresar.html.twig', $params);
  338.                         }
  340.                     }
  341.                     else
  342.                     {
  343.                         $respuesta = $request->get('respuesta');
  344.                         $respuesta = str_replace(' ', '', $respuesta);
  345.                         $respuesta = strtoupper($respuesta);
  346.                         if ($usuario->getRespuestaRecuperacion()==$respuesta)
  347.                         {
  348.                             if (!$password = $seguridadConfiguracion->getDefaultPassword())
  349.                             {
  350.                                 $password = $usuario->getUserName();
  351.                             }
  352.                             $password = $this->setSecurePassword($usuario, $password);
  353.                             $usuario->setPassword($password);
  354.                             $usuario->setActivo(TRUE);
  355.                             $usuario->setPrimerIngreso(TRUE);
  356.                             $usuario->setCausaBloqueo(null);
  357.                             $em->persist($usuario);
  358.                             $em->flush();
  359.                             return $this->render('Security\ingresar.html.twig',
  360.                                                 array('last_username' => $username, 'error_msj' => '', 'msj' => ''));
  361.                         }
  362.                         else
  363.                         {
  364.                             $params['error_name'] = $this->translator->trans('seguridad.recuperacion.error.wronganswer');
  365.                             $params['pregunta'] = $usuario->getPreguntaRecuperacion();
  366.                         }
  367.                     }
  368.                 }
  369.             }
  370.         }
  371.         return $this->render('Security:Security:recuperacion_username.html.twig', $params);
  372.     }
  374.     protected function sendRecuperarPasswordMail($em, $user)
  375.     {
  376.         $token = md5(uniqid());
  377.         $fecha = new \DateTime();
  378.         $codigo = new SeguridadCodigoActivacion();
  379.         $codigo->setCodigo($token);
  380.         $codigo->setUsuario($user);
  381.         $codigo->setFechaEnvio($fecha);
  383.         $parameterActiveConfiguration = $this->getParameter('SECURITY_CONF');
  384.         $configuracionSeguridad = $this->em->getRepository(SeguridadConfiguracion::class)->getActiveConfiguration($parameterActiveConfiguration);
  385.         
  386.         $vigenciaCodigo = $configuracionSeguridad->getVigenciaCodigo();
  387.         if ($vigenciaCodigo>0)
  388.         {
  389.             $fechaMaxActivacion = clone $fecha;
  390.             $fechaMaxActivacion->add(new \DateInterval('PT'.$vigenciaCodigo.'H'));
  391.             $codigo->setFechaVigencia($fechaMaxActivacion);
  392.         }
  394.         $em->persist($codigo);
  395.         $em->flush();
  397.         $url = $this->generateUrl('usuario_register_activation', array('token' => $token), UrlGeneratorInterface::ABSOLUTE_URL);
  398.         try
  399.         {
  400.             $subject = $this->translator->trans('seguridad.mail.sender', array()).' - '.$this->translator->trans('seguridad.recuperacion.subject', array());
  401.             $email = new Email();
  402.             $email->from($this->getParameter('mailer_from'))
  403.                 ->to($user->getEmail())
  404.                 //->cc('[email protected]')
  405.                 //->bcc('[email protected]')
  406.                 //->replyTo('[email protected]')
  407.                 //->priority(Email::PRIORITY_HIGH)
  408.                 ->subject($subject)
  409.                 ->html($this->render('Security\email_recuperacion.html.twig',
  410.                         array('usuario' => $user, 'url' => $url))->getContent());
  412.             $this->mailer->send($email);
  414.             return [
  415.                 'msj' => $this->translator->trans('seguridad.recuperacion.mail'),
  416.                 'kind' => 'info',
  417.             ];
  419.         } catch (\Exception $exc)
  420.         {
  421.             return [
  422.                 'error_msj' => $this->translator->trans('seguridad.mail.error.conexion', array()).' - '.$exc->getMessage(),
  423.                 'kind' => 'danger',
  424.             ];
  425.         }
  426.     }
  428.     public function activationAction($token)
  429.     {
  430.         $em = $this->em;
  432.         $token = $em->getRepository(SeguridadCodigoActivacion::class)->findOneBy(array('codigo' => $token));
  434.         if(empty($token))
  435.         {
  436.            return $this->render('Security\ingresar.html.twig', array('error_msj'=>$this->translator->trans('seguridad.activacion.error.badtoken', array())));
  437.         }
  439.         /*if($token->getFechaUso())
  440.         {
  441.            return $this->render('Security\ingresar.html.twig', array('error_msj'=>$this->translator->trans('seguridad.activacion.error.usedtoken', array())));
  442.         }*/
  444.         $usuario = $token->getUsuario();
  446.         $vigente = true;
  447.         if ($token->getFechaVigencia())
  448.         {
  449.             $fechaActual = new \DateTime();
  450.             $vigente = $token->getFechaVigencia() > $fechaActual;
  451.         }
  453.         if ($vigente)
  454.         {
  455.             $token->setFechaUso(new \DateTime());
  456.             $em->persist($token);
  458.             $usuario->setIntentosFallidos(0);
  459.             $usuario->setActivo(TRUE);
  460.             $em->persist($usuario);
  461.             $em->flush();
  462.             $this->guardaHistorialActivacion($usuario, true, $this->translator->trans('seguridad.activacion.motivo.activacion', array()));
  463.             return $this->redirect($this->generateURL('usuario_confirma_ingreso', array('usuario' => $usuario->getId())));
  464.         }
  465.         else
  466.         {
  467.             return $this->render('Security\ingresar.html.twig', array('error_msj'=>$this->translator->trans('seguridad.activacion.error.oldtoken', array())));
  468.         }
  470.     }
  472.     public function loginAsAction($userId)
  473.     {
  474.         $em = $this->em;
  475.         $user = $em->getRepository('StrategicbschoolBundle:SegUsuario')->find($userId);
  476.         if ($user)
  477.         {
  478.             $admin = $this->get('security.context')->getToken()->getUser();
  479.             $user->setTempSalt($user->getSalt());
  480.             $user->setTempPassword($user->getPassword());
  481.             $user->setSalt($admin->getSalt());
  482.             $user->setPassword($admin->getPassword());
  483.             $em->persist($user);
  484.             $em->flush();
  485.             $request = $this->getRequest();
  486.             $session = $request->getSession();
  487.             $username = $user->getUserName();
  488.             $session->set(SecurityContext::LAST_USERNAME, $username);
  489.             return $this->redirect($this->generateUrl('login'));
  490.         }
  491.         
  492.         return new \Symfony\Component\HttpFoundation\Response('ERROR');
  493.     }
  494.     
  495.     public function setSecurePassword($usuario, $password)
  496.     {
  497. //        $encoder = new MessageDigestPasswordEncoder('sha512', true, 10);
  498. //        $encoder = new NativePasswordEncoder();
  499. //        return $encoder->encodePassword($password, $usuario->getSalt());
  501.         return $this->encoder->hashPassword($usuario, $password);
  502.     }
  504. //    public function isPasswordValid($encoded, $raw, $salt)
  505.     public function isPasswordValid($user, $raw)
  506.     {
  507.         return $this->encoder->isPasswordValid($user, $raw);
  508. //        $encoder = new MessageDigestPasswordEncoder('sha512', true, 10);
  509. //        $encoder = new NativePasswordEncoder();
  510. //        return $encoder->isPasswordValid($encoded, $raw, $salt);
  511.     }
  513.     public function confirmaIngresoAction(Request $request, $usuario)
  514.     {
  515.         $em = $this->em;
  516.         $error_msj='';
  517.         $usuario = $em->getRepository(SeguridadUsuario::class)->find($usuario);
  518.         $params['error_msj'] ='';
  519.         $params ['usuario'] = $usuario;
  520.         $params['mensaje'] = $this->translator->trans('seguridad.activacion.datos', array());
  521.         
  522.         $parameterActiveConfiguration = $this->getParameter('SECURITY_CONF');
  523.         $configuracionSeguridad = $this->em->getRepository(SeguridadConfiguracion::class)->getActiveConfiguration($parameterActiveConfiguration);
  524.         
  525.         $params['textoFuerzaPass'] = $this->getTextoFortalezaPassword($configuracionSeguridad->getFortalezaPassword());
  526. //        $params['recuperaPassword'] = $configuracionSeguridad->getModoRecuperacionContrasena()->getValue();
  528.         if ($request->getMethod() == 'POST')
  529.         {
  530.             $password = $request->get('password');
  531.             if ($configuracionSeguridad->getFortalezaPassword()->validPassword($password))
  532.             {
  533.                 $password = $this->setSecurePassword($usuario, $password);
  534.                 $usuario->setPassword($password);
  535.                 if ($configuracionSeguridad->getPasswordDiasValido()>0)
  536.                 {
  537.                     $fecha = new \DateTime();
  538.                     $fecha->add(new \DateInterval('P'.$configuracionSeguridad->getPasswordDiasValido().'D'));
  539.                     $usuario->setFechaVigenciaPassword($fecha);
  540.                 }    
  541.                 $usuario->setActivo(true);
  542.                 $usuario->setPrimerIngreso(false);
  543.                 $usuario->setIntentosFallidos(0);
  545.                 $em->persist($usuario);
  547. /*                $histPass = new SeguridadHistorialPassword();
  548.                 $histPass->setUsuario($usuario);
  549.                 $histPass->setSalt($usuario->getSalt());
  550.                 $histPass->setPassword($usuario->getPassword());
  551.                 $histPass->setFechaRegistro(new \DateTime());
  552.                 $em->persist($histPass);*/
  553.                 $em->flush();
  555.                 $msj = $this->translator->trans('seguridad.activacion.success');
  557.                 return $this->render('Security\ingresar.html.twig',
  558.                         array('last_username' => $usuario->getUsername(), 'msj' => $msj,'error_msj' => $error_msj,
  559.                         'idUsuario' => $usuario->getId()));
  560.             }
  561.             else
  562.             {
  563.                 $params['error_pass'] = $this->translator->trans('seguridad.contrasena.error.fortaleza');
  564.                 $params['error_msj'] =$this->translator->trans('seguridad.contrasena.error.fortaleza');
  565.             }
  567.         }
  568.         return $this->render('Security\confirma_ingreso.html.twig', $params);
  569.     }
  571.     public function guardaHistorialActivacion($usuario, $activacion, $descripcion)
  572.     {
  573. /*        $em = $this ->em;
  574.         $cambio = new SeguridadHistorialActivacion();
  575.         $cambio->setActivacion($activacion);
  576.         $cambio->setDescripcion($descripcion);
  577.         $cambio->setFecha(new \DateTime());
  578.         $cambio->setUsuario($usuario);
  579.         $em->persist($cambio);
  580.         $em->flush();*/
  581.     }
  583.     protected function bloquearUsuario($usuario)
  584.     {
  585.         $parameterActiveConfiguration = $this->getParameter('SECURITY_CONF');
  586.         $configuracionSeguridad = $this->em->getRepository(SeguridadConfiguracion::class)->getActiveConfiguration($parameterActiveConfiguration);
  587.         
  588.         $cantfallos = $configuracionSeguridad->getAccesosFallidosPermitidos() - $usuario->getIntentosFallidos() - 1;
  590.         if ($cantfallos <= 0)
  591.         {
  592.             $usuario->setActivo(FALSE);
  593.             $usuario->setIntentosFallidos(0);
  594.             $usuario->setCausaBloqueo('Superado el número de intentos fallidos permitidos');
  595.             $this->em->persist($usuario);
  596.             $this->em->flush();
  597.             $this->guardaHistorialActivacion($usuario, false, $this->translator->trans('seguridad.activacion.motivo.intentos', array()));
  598.             session_destroy();
  599.         }
  600.         else
  601.         {
  602.             //incrementar el número de accesos fallidos.
  603.             $usuario->setIntentosFallidos($usuario->getIntentosFallidos()+1);
  604.             $this->em->persist($usuario);
  605.             $this->em->flush();
  606.         }
  607.         return $cantfallos;
  608.     }
  610.     public function cambiaPasswordAction(Request $request, $must='force')
  611.     {
  612.         $usuario = $this->getUser();
  613.         if (is_object($usuario))
  614.         {
  615.             if (!$usuario->getActivo())
  616.             {
  617.                 return $this->render('Security\error.html.twig', array('error_cod'=>$this->translator->trans('seguridad.autenticacion.bloqueado', array())));
  618.             }
  620.             $params ['usuario'] = $usuario;
  621.             $params['mensaje'] = $this->translator->trans('seguridad.contrasena.cambiar', array());
  623.             $parameterActiveConfiguration = $this->getParameter('SECURITY_CONF');
  624.             $configuracionSeguridad = $this->em->getRepository(SeguridadConfiguracion::class)->getActiveConfiguration($parameterActiveConfiguration);
  625.             
  626.             $params['textoFuerzaPass'] = $this->getTextoFortalezaPassword($configuracionSeguridad->getFortalezaPassword());
  627.             $params ['must'] = $must;
  629.             if ($must=='forcecambio')
  630.                 $params ['error_pass'] = $this->translator->trans('seguridad.contrasena.forcecambio');
  631.             if ($must=='forcecaducado')
  632.                 $params ['error_pass'] = $this->translator->trans('seguridad.contrasena.forcecaducado');
  634.             if ($request->getMethod() == 'POST')
  635.             {
  636.                 $passwordEncoded = $usuario->getPassword();
  637.                 $password = $request->get('password_old');
  639. //                if (!$this->isPasswordValid($passwordEncoded, $password, $usuario->getSalt()))
  640.                 if (!$this->isPasswordValid($usuario, $password))
  641.                 {
  642.                     $cantfallos = $this->bloquearUsuario($usuario);
  644.                     if ($cantfallos <= 0)
  645.                     {
  646.                         return $this->render('Security\error.html.twig',
  647.                                              array('error_cod'=>$this->translator->trans('seguridad.activacion.error.intentos', array())));
  648.                     }
  649.                     else
  650.                     {
  651.                         $params['error_pass'] = $this->translator->trans('seguridad.contrasena.error.intentoswrongpass', array('%intentos%'=>$cantfallos));
  652.                         return $this->render('Security\cambia_password.html.twig',$params);
  653.                     }
  654.                 }
  656.                 $password = $request->get('password');
  657.                 if (!$configuracionSeguridad->getFortalezaPassword()->validPassword($password))
  658.                 {
  659.                     $params['error_pass'] = $this->translator->trans('seguridad.contrasena.error.fortaleza');
  660.                     return $this->render('Security\cambia_password.html.twig', $params);
  661.                 }
  663.                 $password = $this->setSecurePassword($usuario, $password);
  664.                 $usuario->setPassword($password);
  665.                 if ($configuracionSeguridad->getPasswordDiasValido()>0)
  666.                 {
  667.                     $fecha = new \DateTime();
  668.                     $fecha->add(new \DateInterval('P'.$configuracionSeguridad->getPasswordDiasValido().'D'));
  669.                     $usuario->setFechaVigenciaPassword($fecha);
  670.                 }
  671.                 $usuario->setActivo(true);
  672.                 $this->em->persist($usuario);
  674. /*                $histPass = new SeguridadHistorialPassword();
  675.                 $histPass->setUsuario($usuario);
  676.                 $histPass->setSalt($usuario->getSalt());
  677.                 $histPass->setPassword($usuario->getPassword());
  678.                 $histPass->setFechaRegistro(new \DateTime());
  679.                 $em->persist($histPass);*/
  680.                 $this->em->flush();
  682.                 $this->session->getFlashBag()->set('info', $this->translator->trans('seguridad.contrasena.success'));
  683.                 if ($must=='force')
  684.                     return $this->redirect($this->generateUrl('app_home'));
  685.                 else
  686.                     return $this->redirect($this->generateUrl('usuario_perfil'));
  687.             }
  689.             return $this->render('Security\cambia_password.html.twig', $params);
  690.         }
  691.         else
  692.             return new \Symfony\Component\HttpFoundation\Response('No hay usuario conectado');
  693.     }
  695.     public function ActivacionManualUsuarioAction($userId)
  696.     {
  697.         $em = $this->em;
  698.         $texto = $this->translator->trans('seguridad.activacion.manual.error');
  700.         $usuario = $em->getRepository(SeguridadUsuario::class)->find($userId);
  701.         if(!$usuario->getActivo())
  702.         {
  703.             $parameterActiveConfiguration = $this->getParameter('SECURITY_CONF');
  704.             $configuracionSeguridad = $this->em->getRepository(SeguridadConfiguracion::class)->getActiveConfiguration($parameterActiveConfiguration);
  705.             $clave= $usuario->getUsername(); //substr($usuario->getUsername(),0,4);
  706.             $password = $this->setSecurePassword($usuario, $clave);
  707.             $usuario->setPassword($password);
  708.             if($configuracionSeguridad->getPasswordDiasValido()>0)
  709.             {
  710.                 $fecha = new \DateTime();
  711.                 $fecha->add(new \DateInterval('P'.$configuracionSeguridad->getPasswordDiasValido().'D'));
  712.                 $usuario->setFechaVigenciaPassword($fecha);
  713.             }
  714.             $usuario->setActivo(true);
  715.             $em->persist($usuario);
  717.             $histPass = new SeguridadHistorialPassword();
  718.             $histPass->setUsuario($usuario);
  719.             $histPass->setSalt($usuario->getSalt());
  720.             $histPass->setPassword($usuario->getPassword());
  721.             $histPass->setFechaRegistro(new \DateTime());
  722.             $em->persist($histPass);
  723.             $em->flush();
  724.             $texto= $this->translator->trans('seguridad.activacion.manual.success').' - Password: '.$clave;
  726.         }
  728.         //$texto=$em->getRepository('App\\Entity\\SeguridadUsuario')->sendActivationLink($userId);
  730.         return new \Symfony\Component\HttpFoundation\Response($texto);
  731.     }
  733.     public function ResetPasswordUsuarioAction($userId)
  734.     {
  735.         $em = $this->em;
  736.         $usuario = $em->getRepository(SeguridadUsuario::class)->find($userId);
  738.         $clave= $usuario->getUsername(); //substr($usuario->getUsername(),0,4);
  739.         $password = $this->setSecurePassword($usuario, $clave);
  740.         $usuario->setPassword($password);
  741.         $usuario->setActivo(true);
  742.         $usuario->setPrimerIngreso(true);
  743.         $em->persist($usuario);
  744.         $em->flush();
  746.         $data = new Response(json_encode(array('ok'=>true)));
  747.         $data->headers->set('Content-Type', 'application/json');
  748.         return $data;
  749.     }
  751.     public function showUsuarioPerfilAction()
  752.     {
  753.         $usuario = $this->getUser();
  754.         if (is_object($usuario))
  755.         {
  756.             return $this->forward('App\Controller\UsuarioController:showAction', array('rol'=>'all', 'id'=>$usuario->getId(), 'routeClassName'=>'usuarioperfil'));
  757.         }
  758.         else
  759.         {
  760.             return $this->redirect ($this->generateUrl ('login'));
  761.         }
  762.     }
  764.     protected function getTextoFortalezaPassword($fortaleza)
  765.     {
  767.         switch ($fortaleza->getNombre())
  768.         {
  769.             case 'WEAK':
  770.                 return $this->translator->trans('seguridad.contrasena.minLong', array('%long%'=>$fortaleza->getMinLong()));
  771.                 break;
  772.             case 'AVERAGE':
  773.                 return $this->translator->trans('seguridad.contrasena.minLong', array('%long%'=>$fortaleza->getMinLong())) .
  774.                        '<br>'.$this->translator->trans('seguridad.contrasena.mayMin', array());
  775.                 break;
  776.             case 'STRONG':
  777.                 return $this->translator->trans('seguridad.contrasena.minLong', array('%long%'=>$fortaleza->getMinLong())) .
  778.                        '<br>'.$this->translator->trans('seguridad.contrasena.mayMin', array()) .
  779.                        '<br>'.$this->translator->trans('seguridad.contrasena.numeros', array());
  780.                 break;
  781.             case 'VERY_STRONG':
  782.                 return $this->translator->trans('seguridad.contrasena.minLong', array('%long%'=>$fortaleza->getMinLong())) .
  783.                        '<br>'.$this->translator->trans('seguridad.contrasena.mayMin', array()) .
  784.                        '<br>'.$this->translator->trans('seguridad.contrasena.numeros', array()) .
  785.                        '<br>'.$this->translator->trans('seguridad.contrasena.caractEspeciales', array());
  786.                 break;
  787.         }
  789.         return $this->translator->trans('seguridad.contrasena.libre', array());
  790.     }
  792.     public function registerSuscriptionAction()
  793.     {
  794.         $params = array('ok'=>false);
  795.         $request = $this->getRequest();
  796.         if ($request->getMethod() == 'POST')
  797.         {
  798.             $data = $request->get('suscription');
  799.             $data['tipoIdentificacion'] = (int)$data['tipoIdentificacion'];
  800.             $token = $this->autenticarHazloFacil();
  801.             if ($token['ok'])
  802.             {
  803.                 $token = $token['token'];
  805.                 $url = $this->container->getParameter('hazlo_facil_api').'/registrarUsuario';
  806.                 $result = $this->callHazloFacilAPI('post', $url, $token, $data);
  807.                 if ($result['ok'])
  808.                 {
  809.                     $params['identificacion'] = $data['identificacion'];
  810.                     $params['success_msj'] = 'Registro exitoso. Se le envió un correo electrónico con indicaciones para que pueda activar su suscripción.';
  811.                     return $this->render('Security/suscripcion_activar.html.twig', $params);
  812.                 }
  813.                 else
  814.                 {
  815.                     $params['ok'] = false;
  816.                     $params['data'] = $data;
  817.                     $params['error_msj'] = 'Falló la comunicación con Hazlo Fácil. Intente más tarde.<br><br>'.$result['info'];
  818.                 }
  819.             } 
  820.             else
  821.             {
  822.                 $params['ok'] = false;
  823.                 $params['data'] = $data;
  824.                 $params['error_msj'] = 'Falló la comunicación con Hazlo Fácil. Intente más tarde';
  825.             }
  826.             
  827.         }
  828.         $em = $this->em;
  829.         $tiposIdentificacion = $em->getRepository('StrategicbschoolBundle:NmclTipoIdentificacion')->find(1);        
  830.         $params['tiposIdentificacion'] = array($tiposIdentificacion);
  831.         return $this->render('Security/suscripcion_registrar.html.twig', $params);
  832.     }
  833.     
  834.     public function activateSuscriptionAction()
  835.     {
  836.         $params = array('ok'=>false);
  837.         $request = $this->getRequest();
  838.         if ($request->getMethod() == 'POST')
  839.         {
  840.             $data = $request->get('suscription');
  841.             $params['identificacion'] = $data['identificacion'];
  842.             $token = $this->autenticarHazloFacil();
  843.             if ($token['ok'])
  844.             {
  845.                 $token = $token['token'];
  847.                 $url = $this->container->getParameter('hazlo_facil_api').'/cambiapassword';
  848.                 $result = $this->callHazloFacilAPI('post', $url, $token, $data);
  849.                 if ($result['ok'])
  850.                 {
  851.                     $params['msj'] = 'Activación exitosa.';
  852.                     $params['last_username'] = $params['identificacion'];
  853.                     return $this->render('Security/ingresar.html.twig', $params);
  854.                 }
  855.                 else
  856.                 {
  857.                     $params['ok'] = false;
  858.                     $params['error_msj'] = $result['response'];
  859.                 }
  860.             } 
  861.             else
  862.             {
  863.                 $params['ok'] = false;
  864.                 $params['error_msj'] = 'Falló la comunicación con Hazlo Fácil. Intente más tarde';
  865.             }
  866.         }
  867.         return $this->render('Security/suscripcion_activar.html.twig', $params);
  868.     }
  869.     
  870.     protected function autenticarHazloFacil()
  871.     {
  872.         $url = $this->container->getParameter('hazlo_facil_api_autenticar');
  873.         
  874.         $curl = curl_init($url);
  875.         $auth_data = array(
  876.             'username' => $this->container->getParameter('hazlo_facil_api_user'),
  877.             'password' => $this->container->getParameter('hazlo_facil_api_pwd')
  878.         );
  879.         $auth_data = json_encode($auth_data);
  880.         curl_setopt($curl, CURLOPT_HTTPHEADER, array(
  881.                 'accept: application/json',
  882.                 'Content-Type: application/json',
  883.                 'Content-Length: ' . strlen($auth_data),
  884.                 ));
  885.         curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
  886.         curl_setopt($curl, CURLOPT_POST, 1);
  887.         curl_setopt($curl, CURLOPT_POSTFIELDS, $auth_data);
  888.         curl_setopt($curl, CURLINFO_HEADER_OUT, 1);
  890.         $result = curl_exec($curl);
  891.         $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
  892.         $res=['ok'=>true];
  893.         if(!$result || $httpCode != 200){
  894.             $res['ok']=false;
  895.             $res['info'] = 'Error de autenticación. '.curl_error($curl);
  896.             return $res;
  897.         }
  898.         curl_close($curl);
  900.         $result = json_decode($result, true);
  901.         $res['token'] = $result['token'];
  903.         return $res;
  904.     }
  905.     
  906.     protected function callHazloFacilAPI($method, $url, $token, $params=null)
  907.     {
  908.         $header = [
  909.             'accept: application/json',
  910.             'Content-Type: application/json',
  911. //            'Content-Length: ' . strlen($data),
  912.             'Authorization: Bearer '.$token,
  913.         ];
  914.         if ($params && is_array($params))
  915.         {
  916.             $params = json_encode($params);
  917.         }
  918.         $handle = curl_init();
  919.         curl_setopt($handle, CURLOPT_RETURNTRANSFER, true);
  920.         switch (strtoupper($method))
  921.         {
  922.             case "GET":
  923.                     curl_setopt($handle, CURLOPT_HTTPGET, true);
  924.                 break;
  925.             case "POST":
  926.                     curl_setopt($handle, CURLOPT_POST, true);
  927.                     curl_setopt($handle, CURLOPT_POSTFIELDS, $params);
  928. //                    $header[] = 'Content-Type: application/json';
  929.                 break;
  930.             case "PUT":
  931.                     curl_setopt($handle, CURLOPT_CUSTOMREQUEST, 'PUT');
  932.                     curl_setopt($handle, CURLOPT_POSTFIELDS, $params);
  933.                 break;
  934.             case "DELETE":
  935.                     curl_setopt($handle, CURLOPT_CUSTOMREQUEST, 'DELETE');
  936.                     if ($params)
  937.                     {
  938.                         curl_setopt($handle, CURLOPT_POSTFIELDS, http_build_query($params));
  939. //                        $url = sprintf("%s?%s", $url, http_build_query($params));
  940. //                        $header[] = 'Content-Type: application/x-www-form-urlencoded';
  941.                     }
  942.                 break;
  943.         }
  944.         curl_setopt($handle, CURLOPT_URL, $url);
  945.         curl_setopt($handle, CURLOPT_HTTPHEADER, $header);
  946.         $response = curl_exec($handle);
  947.         $httpCode = curl_getinfo($handle, CURLINFO_HTTP_CODE);
  949.         $res=['ok'=>true];
  950.         if(!$response || $httpCode != 200){
  951.             $res['ok']=false;
  952.             $res['httpCode']=$httpCode;
  953.             $res['info'] = 'Error: '.curl_error($handle);
  954.             if ($response)
  955.             {
  956.                 $response = json_decode($response, true);
  957.                 $res['response'] = $response;
  958.             }
  959.         }
  960.         else
  961.         {
  962.             $response = json_decode($response, true);
  963.             $res['response'] = $response;
  964.         }
  965.         return $res;
  966.     }
  968. }