src/Controller/Frontend/SecurityController.php line 21

  1. <?php
  3. namespace App\Controller\Frontend;
  5. use App\Entity\User\User;
  6. use App\Exception\User\PasswordRecovery\InvalidLink;
  7. use App\Forms\Types\User\RegistrationType;
  8. use App\Service\User\Event\UserCreatedEvent;
  9. use App\Service\User\UserManager;
  10. use Doctrine\ORM\EntityManagerInterface;
  11. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  12. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  13. use Symfony\Component\HttpFoundation\Request;
  14. use Symfony\Component\HttpFoundation\Response;
  15. use Symfony\Component\Routing\Annotation\Route;
  16. use Symfony\Component\Security\Http\Authentication\AuthenticationUtils;
  18. class SecurityController extends AbstractController
  19. {
  20.     #[Route(path: '/login', name: 'login', priority: 50)]
  21.     public function login(AuthenticationUtils $authenticationUtils): Response
  22.     {
  23.         // if ($this->getUser()) {
  24.         //     return $this->redirectToRoute('target_path');
  25.         // }
  26.         // get the login error if there is one
  27.         $error = $authenticationUtils->getLastAuthenticationError();
  28.         // last username entered by the user
  29.         $lastUsername = $authenticationUtils->getLastUsername();
  31.         return $this->render('security/login.html.twig', ['last_username' => $lastUsername, 'error' => $error]);
  32.     }
  34.     #[Route(path: '/password-recover/{token}', name: 'password_restore')]
  35.     public function passwordRestore(
  36.         \App\Entity\User\PasswordRecovery  $passwordRecovery,
  37.         \App\Service\User\PasswordRecovery $prService,
  38.         EntityManagerInterface             $em
  39.     ) {
  40.         if ($this->getUser()) {
  41.             return $this->redirectToRoute('main_olymp');
  42.         }
  43.         try {
  44.             $result = $prService->createNewPassword($passwordRecovery);
  45.             $em->flush();
  46.         } catch (InvalidLink $e) {
  47.             return $this->render(
  48.                 'security/password-restore-invalid-link.html.twig',
  49.                 []
  50.             );
  51.         }
  53.         return $this->render(
  54.             'security/password-restore-send.html.twig',
  55.             []
  56.         );
  57.     }
  60.     /**
  61.      * @return Response
  62.      */
  63.     #[Route(path: '/password-recover', name: 'password_recovery')]
  64.     public function passwordRecoveryForm(
  65.         \App\Service\User\PasswordRecovery $prService,
  66.         EntityManagerInterface             $em,
  67.         Request                            $request
  68.     ) {
  69.         $data = new \App\Model\User\PasswordRecovery();
  70.         $form = $this->createForm(\App\Forms\Types\User\PasswordRecoveryType::class, $data);
  71.         $form->handleRequest($request);
  72. //        $form->addError(new FormError('test'));
  73.         $send = false;
  74.         $haveError = false;
  75.         if ($form->isSubmitted() && $form->isValid()) {
  76.             $prService->initPasswordRecovery($data);
  77.             $em->flush();
  78.             $send = true;
  79. //            if ($form->isValid()) {
  80. //                $em->flush();
  81. //                return $this->json(['ok' => true]);
  82. //            }
  83.         }
  85.         return $this->render(
  86.             'security/password-recovery-form.html.twig',
  87.             [
  88.                 'send' => $send,
  89.                 'form' => $form->createView(),
  90.             ]
  91.         );
  92.     }
  94.     #[Route(path: '/logout', name: 'app_logout')]
  95.     public function logout()
  96.     {
  97.         throw new \LogicException(
  98.             'This method can be blank - it will be intercepted by the logout key on your firewall.'
  99.         );
  100.     }
  103.     /**
  104.      * @return Response
  105.      */
  106.     #[Route(path: '/registration', name: 'registration')]
  107.     public function registration(
  108.         Request                  $request,
  109.         EntityManagerInterface   $em,
  110.         UserManager              $userManager,
  111.         EventDispatcherInterface $ed
  112.     ): Response {
  113.         $user = new User();
  114. //        $user->setEmail("kulebyakin@gmail.com");
  115. //        $user->setPhone("+79266970986");
  116. //        $user->setFirstName("Миша");
  117.         $send = false;
  118.         $form = $this->createForm(RegistrationType::class, $user);
  119.         $form->handleRequest($request);
  120.         if ($form->isSubmitted() && $form->isValid()) {
  121.             $userManager->create($user);
  122.             $event = new UserCreatedEvent(
  123.                 $user/*, [
  124.                          UserCreatedEvent::SUBSCRIBE => $form->get('subscribe')->getData(),
  125.                      ]
  126.            */
  127.             );
  128.             $ed->dispatch($event, $event::NAME);
  129.             $em->persist($user);
  130. //            if ($form->get('subscribe')->getData()) {
  131. //                try {
  132. //                    $subscribe->subscribe($user->getEmail());
  133. //                } catch (DuplicateException $e) {
  134. //                }
  135. //            }
  136.             $em->flush();
  138.             $send = true;
  139.         }
  141.         return $this->render(
  142.             'security/registration-form.html.twig',
  143.             [
  144.                 'send' => $send,
  145.                 'form' => $form->createView(),
  146.             ]
  147.         );
  148.     }
  150.     /**
  151.      * @param Request $request
  152.      * @param EntityManagerInterface $em
  153.      * @param UserManager $userManager
  154.      * @return \Symfony\Component\HttpFoundation\JsonResponse
  155.      */
  156.     #[Route(path: '/reg/ajax', name: 'registration_ajax', methods: ['post'])]
  157.     public function ajaxRegistration(
  158.         Request                  $request,
  159.         EntityManagerInterface   $em,
  160.         UserManager              $userManager,
  161.         EventDispatcherInterface $ed
  162.     ) {
  163.         $form = $this->createForm(RegistrationType::class);
  164.         $form->handleRequest($request);
  165.         if ($form->isSubmitted() && $form->isValid()) {
  166.             $user = $form->getData();
  167.             $userManager->create($user);
  168.             $event = new UserCreatedEvent(
  169.                 $user,
  170.                 [
  171.                     UserCreatedEvent::SUBSCRIBE => $form->get('subscribe')->getData(),
  172.                 ]
  173.             );
  174.             $ed->dispatch($event, $event::NAME);
  175.             $em->persist($user);
  176.             if ($form->get('subscribe')->getData()) {
  177.             }
  178.             $em->flush();
  180.             return $this->json(['ok' => true]);
  181.         }
  182.         $errors = [];
  183. //        $form->get('phone')->addError(new FormError('sdf'));
  184.         foreach ($form->getErrors(true) as $error) {
  185.             $name = $error->getOrigin()->getName();
  186.             if (empty($errors[$name])) {
  187.                 $errors[$name] = [];
  188.             }
  189.             $errors[$name][] = $error->getMessage();
  190.         }
  192.         return $this->json(
  193.             [
  194.                 'ok' => false,
  195.                 "errors" => $errors,
  196.             ]
  197.         );
  198.     }
  199. }