src/Controller/RegistrationController.php line 288

  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\User;
  6. use App\Form\RegistrationFormType;
  7. use App\Repository\UserRepository;
  8. use App\Security\AppAuthenticator;
  9. use App\Security\EmailVerifier;
  10. use Doctrine\ORM\EntityManagerInterface;
  11. use Symfony\Bridge\Twig\Mime\TemplatedEmail;
  12. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  13. use Symfony\Component\HttpFoundation\Request;
  14. use Symfony\Component\HttpFoundation\Response;
  15. use Symfony\Component\Mime\Address;
  16. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  17. use Symfony\Component\Routing\Annotation\Route;
  18. use Symfony\Component\Security\Http\Authentication\UserAuthenticatorInterface;
  19. use Symfony\Contracts\Translation\TranslatorInterface;
  20. use SymfonyCasts\Bundle\VerifyEmail\Exception\VerifyEmailExceptionInterface;
  21. use Symfony\Component\HttpFoundation\JsonResponse;
  22. use Symfony\Component\Validator\Validator\ValidatorInterface;
  23. use Symfony\Component\Validator\Constraints as Assert;
  24. use Symfony\Component\Security\Core\Exception\AuthenticationException;
  25. class RegistrationController extends AbstractController
  26. {
  27.     private EmailVerifier $emailVerifier;
  29.     public function __construct(EmailVerifier $emailVerifier)
  30.     {
  31.         $this->emailVerifier = $emailVerifier;
  32.     }
  37. #[Route('/api/cities', name: 'get_moroccan_cities', methods: ['GET'])]
  38. public function getMoroccanCities(): JsonResponse
  39. {
  40.     $cities = [
  41.         "Casablanca", "Rabat", "Marrakech", "Fes", "Tangier", "Agadir", "Meknes",
  42.         "Oujda", "Kenitra", "Tetouan", "Safi", "El Jadida", "Nador", "Beni Mellal",
  43.         "Khouribga", "Taza", "Mohammedia", "Settat", "Laayoune", "Dakhla"
  44.     ];
  46.     return new JsonResponse($cities, JsonResponse::HTTP_OK);
  47. }
  50. #[Route('/api/register', name: 'api_register', methods: ['POST'])]
  51. public function apiRegister(Request $request, 
  52.                              UserPasswordHasherInterface $userPasswordHasher, 
  53.                              UserAuthenticatorInterface $userAuthenticator, 
  54.                              AppAuthenticator $authenticator, 
  55.                              EntityManagerInterface $entityManager,
  56.                              ValidatorInterface $validator): JsonResponse
  57. {
  58.     // Decode JSON request
  59.     $data = json_decode($request->getContent(), true);
  61.     // Check if the necessary fields are present in the request
  62.     if (!isset($data['email'], $data['password'], $data['fname'], $data['lname'], $data['phone'])) {
  63.         return new JsonResponse(['error' => 'Missing required fields'], Response::HTTP_CREATED);
  64.     }
  66.     // Validate email format
  67.     $emailConstraint = new Assert\Email();
  68.     $emailViolation = $validator->validate($data['email'], $emailConstraint);
  69.     if (count($emailViolation) > 0) {
  70.         return new JsonResponse(['error' => 'Invalid email format'], Response::HTTP_CREATED);
  71.     }
  73.     // Check if email already exists
  74.     $existingUser = $entityManager->getRepository(User::class)->findOneBy(['email' => $data['email']]);
  75.     if ($existingUser) {
  76.         return new JsonResponse(['error' => 'Email already in use'], Response::HTTP_CREATED);
  77.     }
  79.     // Validate phone number format (you can adjust the regex for more specific formats)
  80.     $phoneConstraint = new Assert\Regex([
  81.         'pattern' => '/^\+?[0-9]{10,15}$/', // Example regex: Adjust according to your phone number format
  82.         'message' => 'Invalid phone number format'
  83.     ]);
  84.     $phoneViolation = $validator->validate($data['phone'], $phoneConstraint);
  85.     if (count($phoneViolation) > 0) {
  86.         return new JsonResponse(['error' => 'Invalid phone number format'], Response::HTTP_CREATED);
  87.     }
  89.     // Create a new User entity
  90.     $user = new User();
  91.     $user->setEmail($data['email']);
  92.     $user->setFname($data['fname']);
  93.     $user->setLName($data['lname']);
  94.     $user->setPhone($data['phone']);
  95.    if (isset($data['type'])) {
  96.       $user->setType($data['type']);
  97.     }
  98.  if (isset($data['identity'])) {
  99.       $user->setIdentity($data['identity']);
  100.     }
  101.  if (isset($data['city'])) {
  102.       $user->setCity($data['city']);
  103.     }
  104.     // Hash the password
  105.     $user->setPassword($userPasswordHasher->hashPassword($user, $data['password']));
  107.     // Set default roles and other properties
  108.     $user->setStatus(0);
  109.     $user->setRoles(["ROLE_USER"]);
  110.     
  112.     // Persist the user to the database
  113.     try {
  114.         $entityManager->persist($user);
  115.         $entityManager->flush();
  116.     } catch (\Exception $e) {
  117.         return new JsonResponse(['error' => 'Error while saving user to database'], Response::HTTP_INTERNAL_SERVER_ERROR);
  118.     }
  120.     // Send email confirmation (if needed for your API, you can skip this if not required)
  123.     // Authenticate the user (optional, if you want to log them in automatically after registration)
  124.     try {
  125.         $userAuthenticator->authenticateUser(
  126.             $user,
  127.             $authenticator,
  128.             $request
  129.         );
  130.     } catch (AuthenticationException $e) {
  131.         return new JsonResponse(['error' => 'Authentication error'], Response::HTTP_CREATED);
  132.     }
  134.     // Return success response with user details (excluding sensitive data like password)
  135.     return new JsonResponse([
  136.         'message' => 'User registered successfully',
  137.         'user' => [
  138.             'id' => $user->getId(),
  139.             'email' => $user->getEmail(),
  140.             'roles' => $user->getRoles()
  141.         ]
  142.     ], Response::HTTP_CREATED);
  143. }
  146. #[Route('/api/update-profile', name: 'api_update_profile', methods: ['PATCH'])]
  147. public function updateProfile(Request $request, 
  148.                               EntityManagerInterface $entityManager, 
  149.                               ValidatorInterface $validator,
  150.                               UserPasswordHasherInterface $userPasswordHasher): JsonResponse
  151. {
  152.     // Assuming user is authenticated via token or session and we fetch the user ID from the token/session
  153.     // Here we assume that the user object is retrieved from the security context (i.e., the logged-in user).
  154.     $user = $this->getUser(); // Get the authenticated user
  156.     if (!$user) {
  157.         return new JsonResponse(['error' => 'User not authenticated'], Response::HTTP_OK);
  158.     }
  160.     // Decode JSON request
  161.     $data = json_decode($request->getContent(), true);
  163.     // Check if the necessary fields are present
  165.  if (isset($data['email'])) {
  166.     // Validate email format
  167.     $emailConstraint = new Assert\Email();
  168.     $emailViolation = $validator->validate($data['email'], $emailConstraint);
  169.     if (count($emailViolation) > 0) {
  170.         return new JsonResponse(['error' => 'Invalid email format'], Response::HTTP_OK);
  171.     }
  173.     // Check if the email already exists for another user (excluding the current user)
  174.     $existingUser = $entityManager->getRepository(User::class)->findOneBy(['email' => $data['email']]);
  175.     if ($existingUser && $existingUser->getId() !== $user->getId()) {
  176.         return new JsonResponse(['error' => 'Email already in use by another user'], Response::HTTP_OK);
  177.     }
  178.  }
  179.  if (isset($data['phone'])) {
  180.     // Validate phone number format (adjust regex as needed)
  181.     $phoneConstraint = new Assert\Regex([
  182.         'pattern' => '/^\+?[0-9]{10,15}$/',
  183.         'message' => 'Invalid phone number format'
  184.     ]);
  185.     $phoneViolation = $validator->validate($data['phone'], $phoneConstraint);
  186.     if (count($phoneViolation) > 0) {
  187.         return new JsonResponse(['error' => 'Invalid phone number format'], Response::HTTP_OK);
  188.     }
  189.  }
  190.     // Update the user information
  191.  
  192.  if (isset($data['email'])) {
  193.       $user->setEmail($data['email']);
  194.     }
  196.    
  197.  if (isset($data['fname'])) {
  198.       $user->SetFname($data['fname']);
  199.     }
  201.  
  202.  if (isset($data['lname'])) {
  203.       $user->SetLname($data['lname']);
  204.     }
  206.  
  207.  if (isset($data['phone'])) {
  208.       $user->SetPhone($data['phone']);
  209.     }
  211.    if (isset($data['type'])) {
  212.       $user->setType($data['type']);
  213.     }
  214.    if (isset($data['identity'])) {
  215.       $user->setIdentity($data['identity']);
  216.     }
  218.  if (isset($data['city'])) {
  219.       $user->setCity($data['city']);
  220.     }
  223.     // Optionally update password if provided (ensure password is hashed)
  224.     if (isset($data['password']) && !empty($data['password'])) {
  225.         $user->setPassword($userPasswordHasher->hashPassword($user, $data['password']));
  226.     }
  228.     // Persist the updated user to the database
  229.     try {
  230.         $entityManager->persist($user);
  231.         $entityManager->flush();
  232.     } catch (\Exception $e) {
  233.         return new JsonResponse(['error' => 'Error while updating user in the database'], Response::HTTP_OK);
  234.     }
  236.     // Return success response with updated user details (excluding sensitive data like password)
  237.     return new JsonResponse([
  238.         'message' => 'User profile updated successfully',
  239.         'user' => [
  240.             'id' => $user->getId(),
  241.             'email' => $user->getEmail(),
  242.             'fname' => $user->getFname(),
  243.             'lname' => $user->getLName(),
  244.             'phone' => $user->getPhone(),
  245.             'roles' => $user->getRoles()
  246.         ]
  247.     ], Response::HTTP_OK);
  248. }
  249.     #[Route('/register', name: 'app_register')]
  250.     public function register(Request $request, UserPasswordHasherInterface $userPasswordHasher, UserAuthenticatorInterface $userAuthenticator, AppAuthenticator $authenticator, EntityManagerInterface $entityManager): Response
  251.     {
  252.         $user = new User();
  253.         $form = $this->createForm(RegistrationFormType::class, $user);
  254.         $form->handleRequest($request);
  256.         if ($form->isSubmitted() && $form->isValid()) {
  257.             // encode the plain password
  258.             $user->setPassword(
  259.                 $userPasswordHasher->hashPassword(
  260.                     $user,
  261.                     $form->get('plainPassword')->getData()
  262.                 )
  263.             );
  265.             $user->setStatus(1);
  266.             $user->setRoles(["ROLE_USER","ROLE_BTOB_ADMIN"]);
  267.             $user->setType('B2B');
  268.             $entityManager->persist($user);
  269.             $entityManager->flush();
  271.             // generate a signed url and email it to the user
  272.             $this->emailVerifier->sendEmailConfirmation('app_verify_email', $user,
  273.                 (new TemplatedEmail())
  274.                     ->from(new Address('no-reply@metacard.gift', 'Email confirmation - Metacard'))
  275.                     ->to($user->getEmail())
  276.                     ->subject('Please Confirm your Email')
  277.                     ->htmlTemplate('registration/confirmation_email.html.twig')
  278.             );
  279.             // do anything else you need here, like send an email
  281.             return $userAuthenticator->authenticateUser(
  282.                 $user,
  283.                 $authenticator,
  284.                 $request
  285.             );
  286.         }
  288.         return $this->render('registration/register.html.twig', [
  289.             'registrationForm' => $form->createView(),
  290.         ]);
  291.     }
  293.     #[Route('/verify/email', name: 'app_verify_email')]
  294.     public function verifyUserEmail(Request $request, TranslatorInterface $translator, UserRepository $userRepository): Response
  295.     {
  296.         $id = $request->get('id');
  298.         if (null === $id) {
  299.             return $this->redirectToRoute('app_register');
  300.         }
  302.         $user = $userRepository->find($id);
  304.         if (null === $user) {
  305.             return $this->redirectToRoute('app_register');
  306.         }
  308.         // validate email confirmation link, sets User::isVerified=true and persists
  309.         try {
  310.             $this->emailVerifier->handleEmailConfirmation($request, $user);
  311.         } catch (VerifyEmailExceptionInterface $exception) {
  312.             $this->addFlash('verify_email_error', $translator->trans($exception->getReason(), [], 'VerifyEmailBundle'));
  314.             return $this->redirectToRoute('app_register');
  315.         }
  317.         // @TODO Change the redirect on success and handle or remove the flash message in your templates
  318.         $this->addFlash('success', 'Your email address has been verified.');
  320.         return $this->redirectToRoute('dashboard');
  321.     }
  322. }