src/Controller/Abstract/AuthenticationController.php line 183

  1. <?php
  3. namespace App\Controller\Abstract;
  5. use App\Service\AssociationHandlerService;
  6. use App\Service\TaggedTypesService;
  7. use App\Traits\Form\DiscriminatorFormGenerator;
  8. use Doctrine\ORM\EntityManagerInterface;
  9. use Exception;
  10. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  11. use Symfony\Component\HttpFoundation\RedirectResponse;
  12. use Symfony\Component\HttpFoundation\Request;
  13. use Symfony\Component\HttpFoundation\Response;
  14. use Symfony\Component\Mailer\MailerInterface;
  15. use Symfony\Component\Mime\Email;
  16. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  17. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  18. use Symfony\Component\Security\Http\Authentication\AuthenticationUtils;
  19. use Symfony\Component\Validator\Validator\ValidatorInterface;
  20. use Symfony\Contracts\Cache\CacheInterface;
  21. use Twig\Environment;
  23. /**
  24.  * Abstract authentication controller.
  25.  *
  26.  */
  27. class AuthenticationController extends CommonController
  28. {
  29.     use DiscriminatorFormGenerator;
  31.     const PATH_PREFIX = 'authentication';
  33.     /**
  34.      * Abstract authenticate Method
  35.      *
  36.      * @param AuthenticationUtils $authenticationUtils
  37.      * @param Environment $twig
  38.      * @param TaggedTypesService $taggedTypesService
  39.      * @return RedirectResponse|Response
  40.      *
  41.      */
  42.     public function authenticate(AuthenticationUtils $authenticationUtils, Environment $twig, TaggedTypesService $taggedTypesService): RedirectResponse|Response
  43.     {
  44.         // get entity class
  45.         $entityClass = static::class::ENTITY_CLASS;
  47.         // get template name
  48.         $method = __FUNCTION__;
  50.         // get controller prefix
  51.         $controller = static::class::PATH_PREFIX;
  53.         // get the login error if there is one
  54.         $error = $authenticationUtils->getLastAuthenticationError();
  56.         // last username entered by the user
  57.         $lastUsername = $authenticationUtils->getLastUsername();
  59.         $templatePath = $controller . '/' . __FUNCTION__ . '.html.twig';
  61.         $entityName = $taggedTypesService->getShortEntityName($entityClass);
  63.         if ($twig->getLoader()->exists($controller . '/' . $entityName . '/' . $method . '.html.twig')) {
  64.             $templatePath = $controller . '/' . $entityName . '/' . $method . '.html.twig';
  65.         } else {
  66.             if ($twig->getLoader()->exists($controller . '/' . $method . '.html.twig')) {
  67.                 $templatePath = $controller . '/' . $method . '.html.twig';
  68.             }
  69.         }
  71.         return $this->render($templatePath, array(
  72.             'path_prefix' => self::PATH_PREFIX,
  73.             'last_username' => $lastUsername,
  74.             'error' => $error,
  75.             'entity_name' => $entityName,
  76.             'path_entity_name' => $entityClass::ENTITY_PATH_IDENTIFIER,
  77.         ));
  78.     }
  80.     /**
  81.      * Abstract Verify Method
  82.      *
  83.      * @param Request $request
  84.      * @param EntityManagerInterface $entityManager
  85.      *
  86.      * @return RedirectResponse|Response
  87.      */
  88.     public function verify(Request $request, EntityManagerInterface $entityManager): RedirectResponse|Response
  89.     {
  90.         // get entity class
  91.         $entityClass = static::class::ENTITY_CLASS;
  93.         // get user
  94.         $user = $entityManager->getRepository($entityClass)->findOneBy(['verificationToken' => $request->get('token')]);
  96.         $user->setVerified(true);
  97.         $user->setVerificationToken(null);
  99.         $entityManager->flush();
  101.         $this->addFlash(
  102.             'success',
  103.             'User successfully verified'
  104.         );
  106.         return $this->redirect('/');
  107.     }
  109.     /**
  110.      * Abstract Reset Method
  111.      *
  112.      * @param Request $request
  113.      * @param ValidatorInterface $validator
  114.      * @param EntityManagerInterface $entityManager
  115.      * @param UrlGeneratorInterface $router
  116.      * @param AssociationHandlerService $associationHandlerService
  117.      * @param TaggedTypesService $taggedTypesService
  118.      * @param Environment $twig
  119.      * @param UserPasswordHasherInterface $passwordHasher
  120.      * @return RedirectResponse|Response
  121.      *
  122.      * @throws Exception
  123.      */
  124.     public function reset(Request $request, ValidatorInterface $validator, EntityManagerInterface $entityManager, UrlGeneratorInterface $router, AssociationHandlerService $associationHandlerService, TaggedTypesService $taggedTypesService, Environment $twig, UserPasswordHasherInterface $passwordHasher): RedirectResponse|Response
  125.     {
  126.         // get entity class
  127.         $entityClass = static::class::ENTITY_CLASS;
  129.         // get user
  130.         $user = $entityManager->getRepository($entityClass)->findOneBy(['resetToken' => $request->get('token')]);
  132.         // get entities
  133.         $entities = [$user];
  135.         // get controller prefix
  136.         $controller = static::class::PATH_PREFIX;
  138.         // get template name
  139.         $method = __FUNCTION__;
  141.         // generate form class pairs
  142.         $formTypeClassPairs = $taggedTypesService->getDescendantEntityFormPairs($entityClass, $controller, $method);
  144.         // post submit function
  145.         $postSubmitFunction = function ($entities, $form) use ($passwordHasher) {
  146.             foreach ($entities as $entity) {
  147.                 $entity->setResetToken(null);
  149.                 $hashedPassword = $passwordHasher->hashPassword(
  150.                     $entity,
  151.                     $entity->getPassword()
  152.                 );
  153.                 $entity->setPassword($hashedPassword);
  154.             }
  155.         };
  157.         // on success function
  158.         $successFunction = function () {
  159.             $this->addFlash(
  160.                 'success',
  161.                 'Password updated successfully'
  162.             );
  163.             return $this->redirect('/');
  164.         };
  166.         return $this->generic($request, $validator, $entityManager, $associationHandlerService, $taggedTypesService, $router, $twig, $entityClass, $method, $formTypeClassPairs, $controller, $entities, null, $postSubmitFunction, $successFunction, false);
  167.     }
  169.     /**
  170.      * Abstract Register Method
  171.      *
  172.      * @param Request $request
  173.      * @param ValidatorInterface $validator
  174.      * @param EntityManagerInterface $entityManager
  175.      * @param UrlGeneratorInterface $router
  176.      * @param AssociationHandlerService $associationHandlerService
  177.      * @param TaggedTypesService $taggedTypesService
  178.      * @param Environment $twig
  179.      * @return Response | RedirectResponse
  180.      *
  181.      * @throws Exception
  182.      */
  183.     public function register(Request $request, ValidatorInterface $validator, EntityManagerInterface $entityManager, UrlGeneratorInterface $router, AssociationHandlerService $associationHandlerService, TaggedTypesService $taggedTypesService, Environment $twig): Response | RedirectResponse
  184.     {
  185.         // get entity class
  186.         $entityClass = static::class::ENTITY_CLASS;
  188.         // get entities
  189.         $entities = [];
  191.         // get template name
  192.         $method = __FUNCTION__;
  194.         // get controller prefix
  195.         $controller = static::class::PATH_PREFIX;
  197.         // generate form class pairs
  198.         $formTypeClassPairs = $taggedTypesService->getDescendantEntityFormPairs($entityClass, $controller, $method);
  200.         // post submit function
  201.         $postSubmitFunction = function ($entities, $form) use ($entityManager) {
  202.             foreach ($entities as $entity) {
  203.                 $entityManager->persist($entity);
  204.             }
  205.         };
  207.         // on success function
  208.         $successFunction = function () {
  209.             $this->addFlash(
  210.                 'success',
  211.                 'Thank you for registering, please check your email inbox for confirmation'
  212.             );
  213.             return $this->redirect('/');
  214.         };
  216.         return $this->generic($request, $validator, $entityManager, $associationHandlerService, $taggedTypesService, $router, $twig, $entityClass, $method, $formTypeClassPairs, $controller, $entities, null, $postSubmitFunction, $successFunction);
  217.     }
  219.     /**
  220.      * Abstract Reset Request Method
  221.      *
  222.      * @param Request $request
  223.      * @param ValidatorInterface $validator
  224.      * @param EntityManagerInterface $entityManager
  225.      * @param AssociationHandlerService $associationHandlerService
  226.      * @param TaggedTypesService $taggedTypesService
  227.      * @param Environment $twig
  228.      * @param MailerInterface $mailer
  229.      * @param ParameterBagInterface $params
  230.      * @param UrlGeneratorInterface $router
  231.      * @return Response | RedirectResponse
  232.      *
  233.      * @throws Exception
  234.      */
  235.     public function request(Request $request, ValidatorInterface $validator, EntityManagerInterface $entityManager, AssociationHandlerService $associationHandlerService, TaggedTypesService $taggedTypesService, Environment $twig, MailerInterface $mailer, ParameterBagInterface $params, UrlGeneratorInterface $router): Response | RedirectResponse
  236.     {
  237.         // get entity class
  238.         $entityClass = static::class::ENTITY_CLASS;
  240.         // get entities
  241.         $entities = [];
  243.         // get template name
  244.         $method = __FUNCTION__;
  246.         // get controller prefix
  247.         $controller = static::class::PATH_PREFIX;
  249.         // generate form class pairs
  250.         $formTypeClassPairs = $taggedTypesService->getDescendantEntityFormPairs($entityClass, $controller, $method);
  252.         // post submit function
  253.         $postSubmitFunction = function ($entities, $form) use ($entityManager, $params, $mailer, $router, $entityClass, $taggedTypesService) {
  254.             $entityName = $taggedTypesService->getShortEntityName($entityClass);
  255.             $pathEntityName = strtolower(trim(preg_replace('/(?<!\ )[A-Z]/', '_$0', $entityName), '_'));
  256.             $entityArray = array_filter(array_merge([], ...array_values($form->getData())));
  257.             foreach ($entityArray as $arrayEntity) {
  258.                 $entity = $entityManager->getRepository(get_class($arrayEntity))->findOneBy(['email' => $arrayEntity->getEmail()]);
  259.                 if ($entity) {
  260.                     $token = bin2hex(random_bytes(64));
  261.                     $token = substr($token, 0, 64);
  263.                     $entity->setResetToken($token);
  265.                     $email = (new Email())
  266.                         ->from($params->get('site_from_email'))
  267.                         ->to($entity->getEmail())
  268.                         ->subject('Password reset request')
  269.                         ->text('Please visit ' . $router->generate('authentication_' . $pathEntityName . '_reset', ['token' => $token], UrlGeneratorInterface::ABSOLUTE_URL) . ' to reset your password')
  270.                         ->html('<p>Please visit <a href="' . $router->generate('authentication_' . $pathEntityName . '_reset', ['token' => $token], UrlGeneratorInterface::ABSOLUTE_URL) . '">' . $params->get('site_short_title') . '</a> to reset your password</p>');
  272.                     $mailer->send($email);
  273.                 }
  274.             }
  275.         };
  277.         // on success function
  278.         $successFunction = function () {
  279.             $this->addFlash(
  280.                 'success',
  281.                 'If a user with that address exists, a password reset link will be emailed to them'
  282.             );
  283.             return $this->redirect('/');
  284.         };
  286.         return $this->generic($request, $validator, $entityManager, $associationHandlerService, $taggedTypesService, $router, $twig, $entityClass, $method, $formTypeClassPairs, $controller, $entities, null, $postSubmitFunction, $successFunction, false);
  287.     }
  288. }