src/Controller/Api/SecurityController.php line 125

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Api;
  5. use App\Manager\UserRegisterManager;
  6. use App\Repository\OrganizationRepository;
  7. use App\Service\JWTService;
  8. use App\Utils\UserUtils;
  9. use Doctrine\ORM\EntityManagerInterface;
  10. use Evo\Infrastructure\MappingORM\Organization;
  11. use Evo\Infrastructure\MappingORM\User;
  12. use Lexik\Bundle\JWTAuthenticationBundle\Services\JWTTokenManagerInterface;
  13. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  14. use Symfony\Component\HttpFoundation\JsonResponse;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\HttpFoundation\Response;
  17. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  18. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  19. use Symfony\Component\Routing\Annotation\Route;
  20. use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
  22. class SecurityController extends AbstractController
  23. {
  24.     private UserRegisterManager $userRegisterManager;
  26.     private EntityManagerInterface $entityManager;
  28.     private UserUtils $userUtils;
  30.     private JWTTokenManagerInterface $JWTTokenManager;
  32.     private UserPasswordEncoderInterface $passwordEncoder;
  34.     private SessionInterface $session;
  36.     private JWTService $jwtService;
  38.     public function __construct(
  39.         UserRegisterManager $userRegisterManager,
  40.         EntityManagerInterface $entityManager,
  41.         UserUtils $userUtils,
  42.         JWTTokenManagerInterface $JWTTokenManager,
  43.         UserPasswordEncoderInterface $passwordEncoder,
  44.         SessionInterface $session,
  45.         JWTService $jwtService
  46.     ) {
  47.         $this->userRegisterManager = $userRegisterManager;
  48.         $this->entityManager = $entityManager;
  49.         $this->userUtils = $userUtils;
  50.         $this->JWTTokenManager = $JWTTokenManager;
  51.         $this->passwordEncoder = $passwordEncoder;
  52.         $this->session = $session;
  53.         $this->jwtService = $jwtService;
  54.     }
  56.     /**
  57.      * @Route("/invoicetoken-auth", methods={"POST"}, name="app_invoicetoken_auth")
  58.      *
  59.      * @throws \JsonException
  60.      */
  61.     public function authByInvoiceToken(Request $request, OrganizationRepository $organizationRepository): JsonResponse
  62.     {
  63.         $body = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  65.         if (!array_key_exists('invoiceToken', $body)) {
  66.             return new JsonResponse(['error' => 'No "invoiceToken" provided'], Response::HTTP_BAD_REQUEST);
  67.         }
  69.         $organization = $organizationRepository->findOneBy(['invoiceToken' => $body['invoiceToken']]);
  71.         if (!$organization instanceof Organization) {
  72.             return new JsonResponse(['error ' => 'Unknown token'], Response::HTTP_FORBIDDEN);
  73.         }
  75.         $firstUser = $organization->getUsers()[0];
  77.         return new JsonResponse(['token' => $this->JWTTokenManager->create($firstUser)]);
  78.     }
  80.     /**
  81.      * @Route("/send-back-code", name="app_send_back_code", methods={"POST"})
  82.      */
  83.     public function sendBackCode(Request $request): JsonResponse
  84.     {
  85.         $query = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  87.         if (empty($query['email'])) {
  88.             throw new NotFoundHttpException('Not found username in query to handle request new password');
  89.         }
  91.         $email = $query['email'];
  93.         /** @var User $user */
  94.         $user = $this->entityManager->getRepository(User::class)->loadUserByUsername($email, true);
  95.         if (null === $user) {
  96.             throw new NotFoundHttpException(sprintf('Not found user with username: "%s"', $email));
  97.         }
  99.         if ('admin@digidom.pro' === $user->getEmail()) {
  100.             return new JsonResponse('alert');
  101.         }
  103.         $code = $this->userUtils->generateCodeConfirmation();
  104.         $user->setCodeConfirmation($code);
  105.         $this->entityManager->persist($user);
  106.         $this->entityManager->flush();
  108.         $this->session->set('current_user', serialize($user));
  110.         return new JsonResponse('success');
  111.     }
  113.     /**
  114.      * @Route("/request-new-pwd", methods={"POST"}, name="app_request_new_pwd")
  115.      */
  116.     public function requestNewPassword(Request $request): JsonResponse
  117.     {
  118.         $query = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  120.         if (empty($query['username'])) {
  121.             throw new NotFoundHttpException('Not found username in query to handle request new password');
  122.         }
  124.         /** @var User $user */
  125.         $user = $this->entityManager->getRepository(User::class)->loadUserByUsername($query['username'], true);
  126.         if (null === $user) {
  127.             throw new NotFoundHttpException(sprintf('Not found user with username: "%s"', $query['username']));
  128.         }
  130.         if ('admin@digidom.pro' === $user->getEmail()) {
  131.             return new JsonResponse('alert');
  132.         }
  134.         $user = $this->userRegisterManager->initHashToken($user);
  135.         $this->entityManager->persist($user);
  136.         $this->entityManager->flush();
  138.         return new JsonResponse('success');
  139.     }
  141.     /**
  142.      * @Route("/login", name="app_user_login", methods={"POST"})
  143.      */
  144.     public function checkAuthentification(Request $request): JsonResponse
  145.     {
  146.         $query = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  148.         if (empty($query['username']) || empty($query['password'])) {
  149.             return new JsonResponse(['code' => 404, 'message' => 'Undefined parameter code or username'], Response::HTTP_NOT_FOUND);
  150.         }
  152.         $email = $query['username'];
  153.         $user = $this->entityManager->getRepository(User::class)->loadUserByUsername($email, true);
  155.         if (null === $user) {
  156.             return new JsonResponse(['code' => 404, 'message' => 'User not found'], Response::HTTP_NOT_FOUND);
  157.         }
  159.         if (!$this->passwordEncoder->isPasswordValid($user, $query['password'])) {
  160.             return new JsonResponse(['code' => 401, 'message' => 'Invalid credential'], Response::HTTP_UNAUTHORIZED);
  161.         }
  163.         $code = $this->userUtils->generateCodeConfirmation();
  164.         $user->setCodeConfirmation($code);
  165.         $this->entityManager->persist($user);
  166.         $this->entityManager->flush();
  168.         return new JsonResponse(['roles' => $user->getRoles()]);
  169.     }
  171.     /**
  172.      * @Route("/check-code", name="app_user_check_code", methods={"POST"})
  173.      */
  174.     public function checkConfirmationCode(Request $request): JsonResponse
  175.     {
  176.         $query = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  178.         if (empty($query['code']) || empty($query['username'])) {
  179.             return new JsonResponse(['code' => 404, 'message' => 'Undefined parameter code or username'], Response::HTTP_NOT_FOUND);
  180.         }
  182.         $username = $query['username'];
  183.         /** @var User $user */
  184.         $user = $this->entityManager->getRepository(User::class)->loadUserByUsername($username, true);
  186.         if (null === $user) {
  187.             return new JsonResponse(['code' => 404, 'message' => 'User not found'], Response::HTTP_NOT_FOUND);
  188.         }
  190.         if ($query['code'] != $user->getCodeConfirmation()) {
  191.             return new JsonResponse(['code' => 401, 'message' => 'Invalide code'], Response::HTTP_NOT_FOUND);
  192.         }
  194.         return new JsonResponse([
  195.             'id' => $user->getId(),
  196.             'email' => $user->getEmail(),
  197.             'lastname' => $user->getLastname(),
  198.             'firstname' => $user->getFirstname(),
  199.             'roles' => $user->getRoles(),
  200.             'phoneNumber' => $user->getPhoneNumber(),
  201.             'codeConfirmation' => $user->getCodeConfirmation(),
  202.         ]);
  203.     }
  205.     /**
  206.      * @Route("/change-password", name="app_user_change_password", methods={"POST"})
  207.      */
  208.     public function changePassword(Request $request): JsonResponse
  209.     {
  210.         $parameters = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  212.         if (!array_key_exists('resetToken', $parameters) || empty($parameters['resetToken'])) {
  213.             return new JsonResponse(['error' => 'emptyResetToken']);
  214.         }
  216.         /** @var User $user */
  217.         $user = $this->entityManager->getRepository(User::class)->findOneBy([
  218.             'resetToken' => $parameters['resetToken'],
  219.         ]);
  221.         if (!$user) {
  222.             return new JsonResponse(['error' => 'invalidToken']);
  223.         }
  225.         $userData = [
  226.             'email' => $user->getEmail(),
  227.             'id' => $user->getId(),
  228.         ];
  230.         if (time() > (int) $user->getResetTokenExpirationDate()) {
  231.             return new JsonResponse([
  232.                 'error' => 'tokenExpired',
  233.                 'user' => $userData,
  234.             ]);
  235.         }
  237.         if (!array_key_exists('password', $parameters) || empty($parameters['password'])) {
  238.             return new JsonResponse([
  239.                 'error' => 'emptyPassword',
  240.                 'user' => $userData,
  241.             ]);
  242.         }
  244.         if (!preg_match('/(?=^.{8,}$)((?=.*\d)|(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$/',
  245.             $parameters['password'])) {
  246.             return new JsonResponse([
  247.                 'error' => 'incorrectPassword',
  248.                 'user' => $userData,
  249.             ]);
  250.         }
  252.         $user->setPassword($parameters['password']);
  253.         $user->setResetToken(null);
  254.         $user->setResetTokenExpirationDate(null);
  255.         $this->entityManager->flush();
  257.         return new JsonResponse([
  258.             'success' => true,
  259.             'user' => $userData,
  260.         ]);
  261.     }
  263.     /**
  264.      * @Route("/token-by-email", name="app_user_token_by_email", methods={"POST"})
  265.      */
  266.     public function tokenByEmail(Request $request)
  267.     {
  268.         $query = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
  269.         $email = $query['email'];
  270.         $user = $this->entityManager->getRepository(User::class)->findOneBy(['email' => $email]);
  271.         if (!$user instanceof User) {
  272.             return new JsonResponse(['code' => 404, 'message' => 'User not found'], Response::HTTP_NOT_FOUND);
  273.         }
  275.         if ($user) {
  276.             return $this->jwtService->createNewJWT($user);
  277.         }
  279.         return $this->json([
  280.             'success' => false,
  281.         ]);
  282.     }
  283. }