src/Controller/UsuarioController.php line 526

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Role;
  6. use App\Entity\Unidad;
  7. use App\Entity\Usuario;
  8. use App\Form\ChangePasswordFormType;
  9. use App\Form\SolicitudAccesoType;
  10. use App\Security\EmailVerifier;
  11. use Doctrine\DBAL\Exception;
  12. use Doctrine\ORM\EntityManagerInterface;
  13. use Doctrine\ORM\EntityRepository;
  14. use Symfony\Bridge\Doctrine\Form\Type\EntityType;
  15. use Symfony\Bridge\Twig\Mime\TemplatedEmail;
  16. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  17. use Symfony\Component\Asset\Packages;
  18. use Symfony\Component\HttpFoundation\JsonResponse;
  19. use Symfony\Component\HttpFoundation\Request;
  20. use Symfony\Component\HttpFoundation\Response;
  21. use Symfony\Component\Mime\Address;
  22. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  23. use Symfony\Component\Routing\Annotation\Route;
  24. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  26. #[Route('/usuario')]
  27. class UsuarioController extends AbstractController
  28. {
  29.     public EntityManagerInterface $entityManager;
  30.     public EmailVerifier $emailVerifier;
  32.     /**
  33.      * @param EntityManagerInterface $entityManager
  34.      * @param EmailVerifier $emailVerifier
  35.      */
  36.     public function __construct(EntityManagerInterface $entityManager, EmailVerifier $emailVerifier)
  37.     {
  38.         $this->entityManager = $entityManager;
  39.         $this->emailVerifier = $emailVerifier;
  40.     }
  42.     #[Route('/', name: 'usuario_index')]
  43.     public function index(Request $request): Response
  44.     {
  45.         /** @var Usuario $user */
  46.         $user = $this->getUser();
  48.         $perfil = $request->getSession()->get('perfil');
  49.         $nivel = $perfil[1]["nivel"];
  51.         if ($nivel == 0) {
  52.             $this->addFlash('danger', 'El acceso al módulo de "Usuarios" está restringido.');
  53.             return $this->redirectToRoute('homepage');
  54.         }
  56.         $data = [];
  58.         if ($user->getRol()->getIdRol() == 1) {
  59.             $form = $this->createFormBuilder()
  60.                 ->add('unidad', EntityType::class, [
  61.                     'class' => Unidad::class,
  62.                     'attr' => ['class' => 'form-control'],
  63.                     'placeholder' => 'Todo',
  64.                     'query_builder' => function (EntityRepository $er) {
  65.                         return $er->createQueryBuilder('u')
  66.                             ->orderBy('u.nombre', 'ASC')
  67.                             ;
  68.                     }
  69.                 ])
  70.                 ->add('rol', EntityType::class, [
  71.                     'class' => Role::class,
  72.                     'attr' => ['class' => 'form-control'],
  73.                     'placeholder' => 'Todo',
  74.                     'query_builder' => function (EntityRepository $er) {
  75.                         return $er->createQueryBuilder('r')
  76.                             ->orderBy('r.idRol', 'ASC')
  77.                             ;
  78.                     }
  79.                 ])
  80.                 ->getForm();
  81.             $form->handleRequest($request);
  83.             $users = $this->entityManager->getRepository(Usuario::class)->findAll();
  85.             if ($request->isMethod('POST')) {
  86.                 if ($form['unidad']->getData() == null && $form['rol']->getData() == null){
  87.                     $users = $this->entityManager->getRepository(Usuario::class)->findAll();
  88.                 } elseif($form['unidad']->getData() != null && $form['rol']->getData() == null) {
  89.                     $users = $this->entityManager->getRepository(Usuario::class)->findBy([
  90.                         'unidad' => $form['unidad']->getData()
  91.                     ]);
  92.                 } elseif ($form['unidad']->getData() == null && $form['rol']->getData() != null) {
  93.                     $users = $this->entityManager->getRepository(Usuario::class)->findBy([
  94.                         'rol' => $form['rol']->getData()
  95.                     ]);
  96.                 } else {
  97.                     $users = $this->entityManager->getRepository(Usuario::class)->findBy([
  98.                         'rol' => $form['rol']->getData(),
  99.                         'unidad' => $form['unidad']->getData()
  100.                     ]);
  101.                 }
  102.                 foreach ($users as $u){
  103.                     $urlEditar = $this->generateUrl('usuario_editar', ['id' => $u->getIdUsu()]);
  104.                     $urlContrasena = $this->generateUrl('usuario_contrasena', ['idUsu' => $u->getIdUsu()]);
  105.                     $urlActivar = $this->generateUrl('usuario_activar', ['idUsu' => $u->getIdUsu()]);
  106.                     $urlRechazar = $this->generateUrl('usuario_rechazar', ['idUsu' => $u->getIdUsu()]);
  107.                     $urlSuspender = $this->generateUrl('usuario_suspender', ['idUsu'=> $u->getIdUsu()]);
  108.                     $urlEliminar = $this->generateUrl('usuario_eliminar', ['idUsu'=> $u->getIdUsu()]);
  109.                     $data[] = [
  110.                         'id' => $u->getIdUsu(),
  111.                         'nombre' => $u->getNombre() . " " . $u->getPapellido() . " " . $u->getSapellido(),
  112.                         'correo' => $u->getCorreo(),
  113.                         'rol' => $u->getRol()->getNombre(),
  114.                         'unidad' => $u->getUnidad()->getNombre(),
  115.                         'estatus' => $u->getEstatus(),
  116.                         'urlEditar' => $urlEditar,
  117.                         'urlContrasena' => $urlContrasena,
  118.                         'urlActivar' => $urlActivar,
  119.                         'urlRechazar' => $urlRechazar,
  120.                         'urlSuspender' => $urlSuspender,
  121.                         'urlEliminar' => $urlEliminar
  122.                     ];
  123.                 }
  125.                 return new JsonResponse($data, Response::HTTP_OK);
  126.             }
  127.         }
  128.         if ($user->getRol()->getIdRol() == 2) {
  129.             $form = $this->createFormBuilder()
  130.                 ->add('unidad', EntityType::class, [
  131.                     'class' => Unidad::class,
  132.                     'attr' => ['class' => 'form-control'],
  133.                     'placeholder' => 'Todo',
  134.                     'query_builder' => function (EntityRepository $er) {
  135.                         return $er->createQueryBuilder('u')
  136.                             ->orderBy('u.nombre', 'ASC')
  137.                             ;
  138.                     }
  139.                 ])
  140.                 ->add('rol', EntityType::class, [
  141.                     'class' => Role::class,
  142.                     'attr' => ['class' => 'form-control'],
  143.                     'query_builder' => function (EntityRepository $er) {
  144.                         return $er->createQueryBuilder('r')
  145.                             ->where('r.idRol = 3')
  146.                             ;
  147.                     }
  148.                 ])
  149.                 ->getForm();
  150.             $form->handleRequest($request);
  152.             $users = $this->entityManager->getRepository(Usuario::class)->findBy([
  153.                 'rol' => 3
  154.             ]);
  156.             if ($request->isMethod('POST')) {
  157.                 if ($form['unidad']->getData() == null){
  158.                     $users = $this->entityManager->getRepository(Usuario::class)->findBy([
  159.                         'rol' => $form['rol']->getData()
  160.                     ]);
  161.                 } else {
  162.                     $users = $this->entityManager->getRepository(Usuario::class)->findBy([
  163.                         'unidad' => $form['unidad']->getData(),
  164.                         'rol' => $form['rol']->getData()
  165.                     ]);
  166.                 }
  167.                 foreach ($users as $u){
  168.                     $urlEditar = $this->generateUrl('usuario_editar', ['id' => $u->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  169.                     $urlContrasena = $this->generateUrl('usuario_contrasena', ['idUsu' => $u->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  170.                     $urlActivar = $this->generateUrl('usuario_activar', ['idUsu' => $u->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  171.                     $urlRechazar = $this->generateUrl('usuario_rechazar', ['idUsu' => $u->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  172.                     $urlSuspender = $this->generateUrl('usuario_suspender', ['idUsu'=> $u->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  173.                     $urlEliminar = $this->generateUrl('usuario_eliminar', ['idUsu'=> $u->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  174.                     $data[] = [
  175.                         'id' => $u->getIdUsu(),
  176.                         'nombre' => $u->getNombre() . " " . $u->getPapellido() . " " . $u->getSapellido(),
  177.                         'correo' => $u->getCorreo(),
  178.                         'rol' => $u->getRol()->getNombre(),
  179.                         'unidad' => $u->getUnidad()->getNombre(),
  180.                         'estatus' => $u->getEstatus(),
  181.                         'urlEditar' => $urlEditar,
  182.                         'urlContrasena' => $urlContrasena,
  183.                         'urlActivar' => $urlActivar,
  184.                         'urlRechazar' => $urlRechazar,
  185.                         'urlSuspender' => $urlSuspender,
  186.                         'urlEliminar' => $urlEliminar
  187.                     ];
  188.                 }
  189.                 return new JsonResponse($data, Response::HTTP_OK);
  190.             }
  191.         }
  192.         if ($user->getRol()->getIdRol() == 3) {
  193.             $form = $this->createFormBuilder()
  194.                 ->add('unidad', EntityType::class, [
  195.                     'class' => Unidad::class,
  196.                     'attr' => ['class' => 'form-control'],
  197.                     'query_builder' => function (EntityRepository $er) {
  198.                         return $er->createQueryBuilder('u')
  199.                             ->orderBy('u.nombre', 'ASC')
  200.                             ;
  201.                     }
  202.                 ])
  203.                 ->add('rol', EntityType::class, [
  204.                     'class' => Role::class,
  205.                     'attr' => ['class' => 'form-control'],
  206.                     'query_builder' => function (EntityRepository $er) {
  207.                         return $er->createQueryBuilder('r')
  208.                             ->where('r.idRol = 3')
  209.                             ;
  210.                     }
  211.                 ])
  212.                 ->getForm();
  213.             $form->handleRequest($request);
  215.             $users = $this->entityManager->getRepository(Usuario::class)->findBy([
  216.                 'unidad' => $user->getUnidad()->getIdUni(),
  217.                 'rol' => [3, 4]
  218.             ]);
  220.             if ($request->isMethod('POST')) {
  221.                 if (empty($form['unidad']->getData()) && empty($form['rol']->getData())) {
  222.                     $users = $this->entityManager->getRepository(Usuario::class)->findAll();
  223.                 } else {
  224.                     $users = $this->entityManager->getRepository(Usuario::class)->findBy([
  225.                         'unidad' => $form['unidad']->getData(),
  226.                         'rol' => $form['rol']->getData()
  227.                     ]);
  228.                 }
  229.                 foreach ($users as $u){
  230.                     $urlEditar = $this->generateUrl('usuario_editar', ['id' => $u->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  231.                     $urlContrasena = $this->generateUrl('usuario_contrasena', ['idUsu' => $u->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  232.                     $urlActivar = $this->generateUrl('usuario_activar', ['idUsu' => $u->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  233.                     $urlRechazar = $this->generateUrl('usuario_rechazar', ['idUsu' => $u->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  234.                     $urlSuspender = $this->generateUrl('usuario_suspender', ['idUsu'=> $u->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  235.                     $urlEliminar = $this->generateUrl('usuario_eliminar', ['idUsu'=> $u->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  236.                     $data[] = [
  237.                         'id' => $u->getIdUsu(),
  238.                         'nombre' => $u->getNombre() . " " . $u->getPapellido() . " " . $u->getSapellido(),
  239.                         'correo' => $u->getCorreo(),
  240.                         'rol' => $u->getRol()->getNombre(),
  241.                         'unidad' => $u->getUnidad()->getNombre(),
  242.                         'estatus' => $u->getEstatus(),
  243.                         'urlEditar' => $urlEditar,
  244.                         'urlContrasena' => $urlContrasena,
  245.                         'urlActivar' => $urlActivar,
  246.                         'urlRechazar' => $urlRechazar,
  247.                         'urlSuspender' => $urlSuspender,
  248.                         'urlEliminar' => $urlEliminar
  249.                     ];
  250.                 }
  251.                 return new JsonResponse($data, Response::HTTP_OK);
  252.             }
  253.         }
  255.         return $this->render('usuario/index.html.twig', [
  256.             'usuarios' => $users,
  257.             'form' => $form->createView(),
  258.             'data' => $data
  259.         ]);
  260.     }
  262.     /**
  263.      * @Route("/edit/{id}", name="usuario_editar", methods={"GET", "POST"})
  264.      * @param EntityManagerInterface $emi
  265.      * @param Request $request
  266.      * @param Usuario $usuario
  267.      * @param Packages $packages
  268.      * @return Response | JsonResponse
  269.      */
  270.     public function editar(EntityManagerInterface $emi, Request $request, Usuario $usuario, Packages $packages): Response
  271.     {
  272.         /** @var Usuario $user */
  273.         $user = $this->getUser();
  275.         $perfil = $request->getSession()->get('perfil');
  276.         $nivel = $perfil[1]["nivel"];
  278.         if ($nivel == 0) {
  279.             $this->addFlash('danger', 'El acceso al módulo de "Usuarios" está restringido.');
  280.             return $this->redirectToRoute('homepage');
  281.         }
  283.         if ($user->getRol()->getIdRol() == 1){
  284.             $form = $this->createForm(SolicitudAccesoType::class, $usuario, array('data_info' => 1));
  285.         } elseif ($user->getRol()->getIdRol() == 2) {
  286.             $form = $this->createForm(SolicitudAccesoType::class, $usuario, array('data_info' => 2));
  287.         } else {
  288.             $form = $this->createForm(SolicitudAccesoType::class, $usuario, array('data_info' => 3));
  289.         }
  291.         if($user->getRol()->getIdRol() == 3){
  292.             $form->remove('nombre');
  293.             $form->remove('papellido');
  294.             $form->remove('sapellido');
  295.             $form->remove('correo');
  296.             $form->remove('contrasena');
  297.             $form->remove('unidad');
  298.             $form->remove('estatus');
  299.         } else {
  300.             $form->remove("contrasena");
  301.         }
  302.         $form->handleRequest($request);
  304.         if ($form->isSubmitted() && $form->isValid()) {
  305.             $emi->persist($usuario);
  306.             $emi->flush();
  308.             # Se genera la url del documento subido
  309.             $link_activar = $this->generateUrl('usuario_activar', ['idUsu' => $usuario->getIdUsu()], UrlGeneratorInterface::ABSOLUTE_URL);
  311.             $data = array(
  312.                 'id' => $usuario->getIdUsu(),
  313.                 'nombre' => $usuario->getNombre() . " " . $usuario->getPapellido() . " " . $usuario->getSapellido(),
  314.                 'correo' => $usuario->getCorreo(),
  315.                 'unidad' => $usuario->getUnidad()->getNombre(),
  316.                 'rol' => "",
  317.                 'estatus' => $usuario->getEstatus(),
  318.                 'link_activar' => $link_activar,
  319.                 'mensaje' => 'Información actualizada.'
  320.             );
  322.             if (!empty($usuario->getRol())){
  323.                 $data['rol'] = $usuario->getRol()->getNombre();
  324.             }
  326.             return new JsonResponse($data);
  327.         }
  329.         if ($form->isSubmitted() && !$form->isValid()) {
  330.             $view = $this->renderView('usuario/modificar_usuario.html.twig', [
  331.                 'form' => $form->createView(),
  332.             ]);
  333.             $response = new JsonResponse(['form' => $view]);
  334.             $response->setStatusCode(Response::HTTP_BAD_REQUEST);
  335.             return $response;
  336.         }
  338.         $data = [
  339.             'id' => $usuario->getIdUsu(),
  340.             'nombre' => $usuario->getNombre(),
  341.             'papellido' => $usuario->getPapellido(),
  342.             'sapellido' => $usuario->getSapellido(),
  343.             'correo' => $usuario->getCorreo(),
  344.             'unidad' => $usuario->getUnidad()->getNombre(),
  345.             'estatus' => $usuario->getEstatus()
  346.         ];
  348.         return $this->render('usuario/modificar_usuario.html.twig', [
  349.             'form' => $form->createView(),
  350.             'data' => $data
  351.         ]);
  352.     }
  354.     /*
  355.      * @Route("/estatus/{idUsu}/{estatus}", name="usuario_estatus", methods={"GET", "POST"})
  356.      * @param EntityManagerInterface $entityManager
  357.      * @param Request $request
  358.      * @ParamConverter("idUsu", class="App\Entity\Usuario")
  359.      * @return Response | JsonResponse
  360.      *
  361.     public function cambiarEstatus(EntityManagerInterface $entityManager, Request $request, Usuario $usuario): Response
  362.     {
  363.         $u = $entityManager->getRepository(Usuario::class)->findOneBy(['idUsu' => $request->get('idUsu')]);
  366.         #if ($request->get('estatus') == 0){
  367.             $u->setEstatus('Suspendido');
  368.             $entityManager->persist($u);
  369.             $entityManager->flush();
  370.         #} else {
  371.         #    $usuario->setEstatus('Rechazado');
  372.         #    $entityManager->persist($u);
  373.         #    $entityManager->flush();
  374.         #}
  376.         return new JsonResponse([
  377.             'mensaje' => 'El usuario ' . $u->getNombre() . ' ' . $u->getPapellido() . ' ha cambiado de estatus a ' . $u->getEstatus() . '.',
  378.             'id' => $u->getIdUsu(),
  379.             'accion' => $request->get('estatus'),
  380.             'estatus' => $u->getEstatus()
  381.         ]);
  382.     }*/
  384.     /**
  385.      * @Route("/rechazar/{idUsu}", name="usuario_rechazar", methods={"GET", "POST"})
  386.      * @param EntityManagerInterface $entityManager
  387.      * @param Request $request
  388.      * @param Usuario $usuario
  389.      * @return Response | JsonResponse
  390.      */
  391.     public function rechazar(EntityManagerInterface $entityManager, Request $request, Usuario $usuario): Response
  392.     {
  393.         $usuario->setEstatus('Rechazado');
  394.         $entityManager->persist($usuario);
  395.         $entityManager->flush();
  397.         return new JsonResponse([
  398.             'mensaje' => 'El usuario ' . $usuario->getNombre() . ' ' . $usuario->getPapellido() . ' ha cambiado de estatus a ' . $usuario->getEstatus() . '.',
  399.             'id' => $usuario->getIdUsu(),
  400.             'estatus' => $usuario->getEstatus()
  401.         ]);
  402.     }
  404.     /**
  405.      * @Route("/suspender/{idUsu}", name="usuario_suspender", methods={"GET", "POST"})
  406.      * @param EntityManagerInterface $entityManager
  407.      * @param Request $request
  408.      * @param Usuario $usuario
  409.      * @return Response | JsonResponse
  410.      */
  411.     public function suspender(EntityManagerInterface $entityManager, Request $request, Usuario $usuario): Response
  412.     {
  413.         $usuario->setEstatus('Suspendido');
  414.         $entityManager->persist($usuario);
  415.         $entityManager->flush();
  417.         return new JsonResponse([
  418.             'mensaje' => 'El usuario ' . $usuario->getNombre() . ' ' . $usuario->getPapellido() . ' ha cambiado de estatus a ' . $usuario->getEstatus() . '.',
  419.             'id' => $usuario->getIdUsu(),
  420.             'estatus' => $usuario->getEstatus()
  421.         ]);
  422.     }
  424.     /**
  425.      * @Route("/eliminar/{idUsu}", name="usuario_eliminar", methods={"GET", "POST"})
  426.      * @param EntityManagerInterface $emi
  427.      * @param Request $request
  428.      * @param Usuario $usuario
  429.      * @return Response | JsonResponse
  430.      * @throws Exception
  431.      */
  432.     public function eliminar(EntityManagerInterface $emi, Request $request, Usuario $usuario): Response
  433.     {
  434.         $perfil = $request->getSession()->get('perfil');
  435.         $nivel = $perfil[3]["nivel"];
  437.         if ($nivel == 0) {
  438.             $this->addFlash('danger', 'El acceso al módulo de "Usuarios" está restringido.');
  439.             return $this->redirectToRoute('homepage');
  440.         }
  441.         $conn = $emi->getConnection();
  443.         # Se inicia la transacción
  444.         $conn->setAutoCommit(false);
  445.         $conn->beginTransaction();
  447.         $deleteQuery = "DELETE FROM usuario WHERE usuario.id_usu = :usuario";
  448.         $statement = $conn->prepare($deleteQuery);
  449.         $statement->bindValue('usuario', $usuario->getIdUsu());
  450.         $statement->executeQuery();
  452.         $conn->commit();
  454.         $data = [
  455.             'id' => $usuario->getIdUsu(),
  456.             'mensaje' => 'El usuario ' . $usuario->getNombre() . " " . $usuario->getPapellido() . " ha sido removido"
  457.         ];
  459.         return new JsonResponse($data);
  460.     }
  462.     /**
  463.      * @Route("/contrasena/{idUsu}", name="usuario_contrasena", methods={"GET", "POST"})
  464.      * @param Request $request
  465.      * @param EntityManagerInterface $entityManager
  466.      * @param Usuario $usuario
  467.      * @param UserPasswordHasherInterface $userPasswordHasher
  468.      * @return Response | JsonResponse
  469.      */
  470.     public function cambioContrasena(Request $request, EntityManagerInterface $entityManager, Usuario $usuario, UserPasswordHasherInterface $userPasswordHasher): Response
  471.     {
  472.         $perfil = $request->getSession()->get('perfil');
  473.         $nivel = $perfil[3]["nivel"];
  475.         if ($nivel == 0) {
  476.             $this->addFlash('danger', 'El acceso al módulo de "Usuarios" está restringido.');
  477.             return $this->redirectToRoute('homepage');
  478.         }
  479.         $form = $this->createForm(SolicitudAccesoType::class);
  480.         $form->remove("nombre");
  481.         $form->remove("papellido");
  482.         $form->remove("sapellido");
  483.         $form->remove("correo");
  484.         $form->remove("unidad");
  485.         $form->remove("rol");
  486.         $form->remove("estatus");
  487.         $form->handleRequest($request);
  489.         if ($form->isSubmitted() && $form->isValid()) {
  490.             $encodedPassword = $userPasswordHasher->hashPassword(
  491.                 $usuario,
  492.                 $form->get('contrasena')->getData()
  493.             );
  495.             $usuario->setContrasena($encodedPassword);
  496.             $entityManager->persist($usuario);
  497.             $entityManager->flush();
  499.             return new JsonResponse(array('mensaje' => 'Se cambio la contraseña.'));
  500.         }
  502.         if ($form->isSubmitted() && !$form->isValid()) {
  503.             $view = $this->renderView('usuario/contrasena.html.twig', [
  504.                 'form' => $form->createView(),
  505.                 'nombre' => $usuario->getNombre() . " " . $usuario->getPapellido()
  506.             ]);
  507.             $response = new JsonResponse(['form' => $view]);
  508.             $response->setStatusCode(Response::HTTP_BAD_REQUEST);
  509.             return $response;
  510.         }
  512.         return $this->render('usuario/contrasena.html.twig', [
  513.             'form' => $form->createView(),
  514.             'nombre' => $usuario->getNombre() . " " . $usuario->getPapellido()
  515.         ]);
  516.     }
  518.     /**
  519.      * @Route("/activar/{idUsu}", name="usuario_activar", methods={"GET", "POST"})
  520.      * @param Request $request
  521.      * @param EntityManagerInterface $entityManager
  522.      * @param Usuario $usuario
  523.      * @param UserPasswordHasherInterface $userPasswordHasher
  524.      * @return Response | JsonResponse
  525.      */
  526.     public function activar(Request $request, EntityManagerInterface $entityManager, Usuario $usuario, UserPasswordHasherInterface $userPasswordHasher): Response
  527.     {
  528.         $data = [
  529.             'password' => '',
  530.             'correo' => ''
  531.         ];
  533.         $data['password'] = $this->randomPassword();
  534.         $data['correo'] = $usuario->getCorreo();
  536.         // Encode(hash) the plain password, and set it.
  537.         $encodedPassword = $userPasswordHasher->hashPassword(
  538.             $usuario,
  539.             $data['password']
  540.         );
  541.         $usuario->setContrasena($encodedPassword);
  542.         $usuario->setEstatus('Aceptado');
  543.         $entityManager->flush();
  545.         // generate a signed url and email it to the user
  546.         $this->emailVerifier->sendEmailConfirmation('app_verify_email', $usuario,
  547.             (new TemplatedEmail())
  548.                 ->from(new Address('no-reply-ti@conalepmex.edu.mx', 'Sistema de Gestión de Mantenimiento para Equipos de Computo'))
  549.                 ->to($data['correo'])
  550.                 ->subject('Solicitud de acceso aprobada')
  551.                 ->context(['data' => $data])
  552.                 ->htmlTemplate('usuario/confirmation_email.html.twig')
  553.         );
  554.         // do anything else you need here, like send an email
  556.         $data = array(
  557.             'id' => $usuario->getIdUsu(),
  558.             'nombre' => $usuario->getNombre() . " " . $usuario->getPapellido() . " " . $usuario->getSapellido(),
  559.             'correo' => $usuario->getCorreo(),
  560.             'unidad' => $usuario->getUnidad()->getNombre(),
  561.             'rol' => "",
  562.             'estatus' => $usuario->getEstatus(),
  563.             'mensaje' => 'Se activó y notificó al usuario con el correo: ' . $usuario->getCorreo()
  564.         );
  566.         if (!empty($usuario->getRol())){
  567.             $data['rol'] = $usuario->getRol()->getNombre();
  568.         }
  570.         return new JsonResponse($data);
  571.     }
  573.     /**
  574.      * Validates and process the reset URL that the user clicked in their email.
  575.      *
  576.      * @Route("/reset", name="app_cambiar_contrasena")
  577.      */
  578.     public function reset(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $em): Response
  579.     {
  580.         /** @var Usuario $user */
  581.         $user = $this->getUser();
  582.         $form = $this->createForm(ChangePasswordFormType::class);
  583.         $form->handleRequest($request);
  585.         if ($form->isSubmitted() && $form->isValid()) {
  586.             // Encode(hash) the plain password, and set it.
  587.             $encodedPassword = $userPasswordHasher->hashPassword(
  588.                 $user,
  589.                 $form->get('plainPassword')->getData()
  590.             );
  591.             $user->setContrasena($encodedPassword);
  592.             $em->flush();
  594.             $this->addFlash('success', 'Se ha actualizado la contraseña correctamente.');
  595.             return $this->redirectToRoute('homepage');
  596.         }
  598.         return $this->render('usuario/reset.html.twig', [
  599.             'resetForm' => $form->createView(),
  600.         ]);
  601.     }
  603.     /**
  604.      * Acción para generar contraseñas aleatorias
  605.      *
  606.      * @return string
  607.      */
  608.     protected function randomPassword(): string
  609.     {
  610.         $alphabet = "abcdefghijklmnopqrstuwxyzABCDEFGHIJKLMNOPQRSTUWXYZ0123456789";
  611.         $pass = array(); //remember to declare $pass as an array
  612.         $alphaLength = strlen($alphabet) - 1; //put the length -1 in cache
  613.         for ($i = 0; $i < 8; $i++) {
  614.             $n = rand(0, $alphaLength);
  615.             $pass[] = $alphabet[$n];
  616.         }
  617.         return implode($pass); //turn the array into a string
  618.     }   
  619. }