src/Controller/Frontend/Customer/CustomersController.php line 238

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Frontend\Customer;
  5. use App\Entity\Assay\Assay;
  6. use App\Entity\Customer\Customer;
  7. use App\Entity\Customer\CustomerArea;
  8. use App\Entity\Customer\DeleteAccounts;
  9. use App\Entity\QrCode\QrAssayRelation;
  10. use App\Entity\QrCode\QRData;
  11. use App\Entity\User\User;
  12. use App\Form\Type\Frontend\Base64UploadedFileType;
  13. use App\Form\Type\Frontend\CustomerAreaType;
  14. use App\Form\Type\Frontend\CustomerType;
  15. use App\Form\Type\Frontend\DeleteAccountType;
  16. use App\Service\AccessTokenService;
  17. use App\Uploader\CustomerAreaUploader;
  18. use App\Uploader\CustomerUploader;
  19. use App\ViewModel\Frontend\AccessTokenViewModel;
  20. use App\Service\StabVidaTokenService;
  21. use App\ViewModel\Frontend\StabVidaTokenViewModel;
  22. use App\ViewModel\Frontend\CustomerAreaViewModel;
  23. use App\ViewModel\Frontend\CustomerViewModel;
  24. use DateTime;
  25. use Doctrine\ORM\EntityManagerInterface;
  26. use Exception;
  27. use Nelmio\ApiDocBundle\Annotation\Model;
  28. use Nelmio\ApiDocBundle\Annotation\Security;
  29. use OpenApi\Annotations as OA;
  30. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  31. use Symfony\Component\Form\FormFactoryInterface;
  32. use Symfony\Component\HttpFoundation\File\UploadedFile;
  33. use Symfony\Component\HttpFoundation\JsonResponse;
  34. use Symfony\Component\HttpFoundation\Request;
  35. use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
  36. use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
  37. use Symfony\Component\HttpKernel\Exception\ConflictHttpException;
  38. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  39. use Symfony\Component\Routing\Annotation\Route;
  40. use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
  41. use Symfony\Component\Validator\Constraints as Assert;
  43. /**
  44.  * Class CustomersController
  45.  *
  46.  * @package App\Controller
  47.  */
  48. class CustomersController extends AbstractController {
  50.     /**
  51.      * @var EntityManagerInterface
  52.      */
  53.     private $entityManager;
  55.     /**
  56.      * @var FormFactoryInterface
  57.      */
  58.     private $formFactory;
  60.     /**
  61.      * @var CustomerUploader
  62.      */
  63.     private $customerUploader;
  65.     /**
  66.      * @var CustomerAreaUploader
  67.      */
  68.     private $customerAreaUploader;
  70.     /**
  71.      * @var UserPasswordEncoderInterface
  72.      */
  73.     private $passwordEncoder;
  75.     /**
  76.      * @var AccessTokenService
  77.      */
  78.     private $accessTokenService;
  80.     /**
  81.      * @var StabVidaTokenService
  82.      */
  83.     private $stabVidaTokenService;
  85.     /**
  86.      * CustomersController constructor.
  87.      *
  88.      * @param EntityManagerInterface $entityManager
  89.      * @param FormFactoryInterface $formFactory
  90.      * @param AccessTokenService $accessTokenService
  91.      * @param StabVidaTokenService $stabVidaTokenService
  92.      * @param UserPasswordEncoderInterface $passwordEncoder
  93.      * @param CustomerUploader $customerUploader ,
  94.      * @param CustomerAreaUploader $customerAreaUploader
  95.      */
  96.     public function __construct(
  97.         EntityManagerInterface $entityManager,
  98.         FormFactoryInterface $formFactory,
  99.         AccessTokenService $accessTokenService,
  100.         StabVidaTokenService $stabVidaTokenService,
  101.         UserPasswordEncoderInterface $passwordEncoder,
  102.         CustomerUploader $customerUploader,
  103.         CustomerAreaUploader $customerAreaUploader
  104.     ) {
  105.         $this->entityManager = $entityManager;
  106.         $this->formFactory = $formFactory;
  107.         $this->accessTokenService = $accessTokenService;
  108.         $this->stabVidaTokenService = $stabVidaTokenService;
  109.         $this->passwordEncoder = $passwordEncoder;
  110.         $this->customerUploader = $customerUploader;
  111.         $this->customerAreaUploader = $customerAreaUploader;
  112.     }
  114.     /**
  115.      * Get the currently logged-in customer profile
  116.      *
  117.      * @Route(path="/me", methods={"GET"})
  118.      * @Security(name="Bearer")
  119.      * @OA\Response(
  120.      *     response="200",
  121.      *     ref="#/components/schemas/Customer"
  122.      * )
  123.      * @OA\Response(
  124.      *     response="401",
  125.      *     description="Authentication needed",
  126.      *     ref="#/components/schemas/UnauthorizedResponseError"
  127.      * )
  128.      */
  129.     public function meAction(): JsonResponse {
  130.         $customer = $this->entityManager
  131.             ->getRepository(Customer::class)
  132.             ->getCustomerForUser($this->getUser());
  134.         return $this->json($customer, 200, [], CustomerViewModel::create($customer, $this->customerUploader));
  135.     }
  137.     /**
  138.      * Update customer information
  139.      *
  140.      * @Route(path="/me", methods={"PATCH"})
  141.      * @param Request $request
  142.      * @return JsonResponse
  143.      * @throws Exception
  144.      * @Security(name="Bearer")
  145.      * @OA\Response(
  146.      *     response="200",
  147.      *     description="The access token",
  148.      *     @Model(type=AccessTokenViewModel::class)
  149.      * )
  150.      * @OA\Response(
  151.      *     response="400",
  152.      *     description="Authentication needed",
  153.      *     ref="#/components/schemas/BadRequestError"
  154.      * )
  155.      * @OA\Response(
  156.      *     response="401",
  157.      *     description="Authentication needed",
  158.      *     ref="#/components/schemas/UnauthorizedResponseError"
  159.      * )
  160.      * @OA\Response(
  161.      *     response="404",
  162.      *     description="Invalid password",
  163.      *     ref="#/components/schemas/NotFoundError"
  164.      * )
  165.      * @OA\Response(
  166.      *     response="409",
  167.      *     description="Invalid e-mail",
  168.      *     ref="#/components/schemas/ConflictError"
  169.      * )
  170.      */
  171.     public function updateAction(Request $request): JsonResponse {
  172.         /** @var User $user */
  173.         $user = $this->getUser();
  174.         $customer = $this->entityManager
  175.             ->getRepository(Customer::class)
  176.             ->getCustomerForUser($user);
  178.         $form = $this->formFactory->create(CustomerType::class, $customer);
  179.         $form->submit(json_decode($request->getContent(), true));
  180.         
  181.         if(!$form->isSubmitted() || !$form->isValid()) {
  182.             throw new BadRequestHttpException($form->getErrors(true, false)); // 400 - Bad Request
  183.         }
  185.         $currentPassword = $form->get('currentPassword')->getData();
  186.         $plainPassword = $form->get('password')->getData();
  188.         if(!$this->passwordEncoder->isPasswordValid($user, $currentPassword)) {
  189.             throw new NotFoundHttpException();
  190.         }
  192.         $this->entityManager->beginTransaction();
  194.         if($customer->getEmail() !== $user->getEmail()) {
  195.             $existingUser = $this->entityManager
  196.                 ->getRepository(User::class)
  197.                 ->findOneBy(['email' => $customer->getEmail()]);
  199.             if($existingUser !== null) {
  200.                 throw new ConflictHttpException(); //409 - Conflict
  201.             }
  203.             $user->setEmail($customer->getEmail());
  204.         }
  206.         if(!empty($plainPassword)) {
  207.             $passwordEncoded = $this->passwordEncoder->encodePassword($user, $plainPassword);
  208.             $user->setPassword($passwordEncoded);
  209.             $user->setResetPasswordToken(null);
  210.             $user->setResetPasswordExpiresAt(null);
  211.         }
  213.         $this->entityManager->persist($user);
  214.         $this->entityManager->persist($customer);
  215.         $this->entityManager->flush();
  216.         $this->entityManager->commit();
  218.         $accessToken = $this->accessTokenService->createAccessToken($user);
  220.         return $this->json(AccessTokenViewModel::create($accessToken));
  221.     }
  223.     /**
  224.      * Get customer settings
  225.      *
  226.      * @Route(path="/myArea", methods={"GET"})
  227.      * @Security(name="Bearer")
  228.      * @OA\Response(
  229.      *     response="200",
  230.      *     ref="#/components/schemas/CustomerArea"
  231.      * )
  232.      * @OA\Response(
  233.      *     response="401",
  234.      *     description="Authentication needed",
  235.      *     ref="#/components/schemas/UnauthorizedResponseError"
  236.      * )
  237.      */
  238.     public function myAreaAction(): JsonResponse {
  239.         $customerArea = $this->entityManager
  240.             ->getRepository(CustomerArea::class)
  241.             ->getCustomerAreaForUser($this->getUser());
  243.         if(!$customerArea) {
  244.             $customerArea = new CustomerArea();
  245.             $customerArea->setUser($this->getUser());
  246.             $this->entityManager->persist($customerArea);
  247.             $this->entityManager->flush();
  248.         }
  250.         return $this->json(
  251.             $customerArea,
  252.             200,
  253.             [],
  254.             CustomerAreaViewModel::create($customerArea, $this->customerAreaUploader)
  255.         );
  256.     }
  258.     /**
  259.      * Update customer settings
  260.      *
  261.      * @Route(path="/setMyArea", methods={"POST"})
  262.      * @Security(name="Bearer")
  263.      * @OA\RequestBody(
  264.      *     @Model(type=CustomerAreaType::class)
  265.      * )
  266.      * @OA\Response(
  267.      *     response="200",
  268.      *     ref="#/components/schemas/CustomerArea"
  269.      * )
  270.      * @OA\Response(
  271.      *     response="400",
  272.      *     ref="#/components/schemas/BadRequestError"
  273.      * )
  274.      * @OA\Response(
  275.      *     response="401",
  276.      *     description="Authentication needed",
  277.      *     ref="#/components/schemas/UnauthorizedResponseError"
  278.      * )
  279.      */
  280.     public function setMyArea(Request $request): JsonResponse {
  281.         $customerArea = $this->entityManager
  282.             ->getRepository(CustomerArea::class)
  283.             ->getCustomerAreaForUser($this->getUser());
  285.         $customerAreaForm = $this->formFactory
  286.             ->create(CustomerAreaType::class, $customerArea);
  288.         $customerAreaForm->submit(json_decode($request->getContent(), true));
  290.         if(!$customerAreaForm->isSubmitted() || !$customerAreaForm->isValid()) {
  291.             throw new BadRequestHttpException($customerAreaForm->getErrors());
  292.         }
  294.         /** @var UploadedFile $uploadedFile */
  295.         $uploadedFile = $customerAreaForm->get('signature')->getData();
  297.         /** @var CustomerArea $newArea * */
  298.         $newArea = $customerAreaForm->getData();
  300.         if (isset($uploadedFile)) {
  301.             $uploadedFilename = $this->customerAreaUploader->upload($uploadedFile);
  302.             $newArea->setSignatureFilename($uploadedFilename);
  303.         } 
  304.         else {
  305.             $newArea->setSignatureFilename(null);
  306.         }
  308.         $this->entityManager->persist($newArea);
  309.         $this->entityManager->flush();
  311.         return $this->json($newArea, 200, [], CustomerAreaViewModel::VIEW_CONTEXT);
  312.     }
  314.     /**
  315.      * Upload customer logo
  316.      *
  317.      * @Route(path="/uploadLogo", methods={"POST"})
  318.      * @param Request $request
  319.      * @return JsonResponse
  320.      * @Security(name="Bearer")
  321.      * @OA\RequestBody(
  322.      *     @Model(type=Base64UploadedFileType::class)
  323.      * )
  324.      * @OA\Response(
  325.      *     response="200",
  326.      *     description="Empty response",
  327.      *     @OA\Schema(type="array")
  328.      * )
  329.      * @OA\Response(
  330.      *     response="400",
  331.      *     ref="#/components/schemas/BadRequestError"
  332.      * )
  333.      * @OA\Response(
  334.      *     response="401",
  335.      *     description="Authentication needed",
  336.      *     ref="#/components/schemas/UnauthorizedResponseError"
  337.      * )
  338.      */
  339.     public function uploadLogo(Request $request): JsonResponse {
  340.         /** @var Customer $customer */
  341.         $customer = $this->entityManager
  342.             ->getRepository(Customer::class)
  343.             ->getCustomerForUser($this->getUser());
  345.         $form = $this->formFactory
  346.             ->create(
  347.                 Base64UploadedFileType::class,
  348.                 null,
  349.                 [
  350.                     'constraints' => [
  351.                         new Assert\Image(),
  352.                     ],
  353.                 ]
  354.             );
  356.         $form->submit($request->getContent());
  358.         if(!$form->isSubmitted() || !$form->isValid()) {
  359.             throw new BadRequestHttpException($form->getErrors());
  360.         }
  362.         /** @var UploadedFile $uploadedFile */
  363.         $uploadedFile = $form->getData();
  365.         if(isset($uploadedFile)) {
  366.             $uploadedFilename = $this->customerUploader->upload($uploadedFile);
  367.             $customer->setLogoFilename($uploadedFilename);
  368.         } 
  369.         else {
  370.             $customer->setLogoFilename(null);
  371.         }
  373.         $this->entityManager->persist($customer);
  374.         $this->entityManager->flush();
  376.         return $this->json([]);
  377.     }
  379.     /**
  380.      * Delete the customer account
  381.      *
  382.      * @Route(path="/deleteAccount", methods={"PATCH"})
  383.      * @param Request $request
  384.      * @return JsonResponse
  385.      * @throws Exception
  386.      * @Security(name="Bearer")
  387.      * @OA\RequestBody(
  388.      *     @Model(type=DeleteAccountType::class)
  389.      * )
  390.      * @OA\Response(
  391.      *     response="200",
  392.      *     description="Empty response",
  393.      *     @OA\Schema(type="array")
  394.      * )
  395.      * @OA\Response(
  396.      *     response="400",
  397.      *     ref="#/components/schemas/BadRequestError"
  398.      * )
  399.      * @OA\Response(
  400.      *     response="401",
  401.      *     description="Authentication needed",
  402.      *     ref="#/components/schemas/UnauthorizedResponseError"
  403.      * )
  404.      * @OA\Response(
  405.      *     response="404",
  406.      *     description="Invalid password",
  407.      *     ref="#/components/schemas/NotFoundError"
  408.      * )
  409.      * @OA\Response(
  410.      *     response="409",
  411.      *     description="Conflict",
  412.      *     ref="#/components/schemas/ConflictError"
  413.      * )
  414.      */
  415.     public function deleteAccountAction(Request $request): JsonResponse {
  416.         $user = $this->getUser();
  417.         $customer = $this->entityManager
  418.             ->getRepository(Customer::class)
  419.             ->getCustomerForUser($user);
  421.         $form = $this->formFactory->create(DeleteAccountType::class, null);
  422.         $form->submit(json_decode($request->getContent(), true));
  423.         
  424.         if(!$form->isSubmitted() || !$form->isValid()) {
  425.             throw new BadRequestHttpException($form->getErrors(true, false)); // 400 - Bad Request
  426.         }
  428.         $email = $form->get('email')->getData();
  429.         $currentPassword = $form->get('currentPassword')->getData();
  431.         if(!$this->passwordEncoder->isPasswordValid($user, $currentPassword)) {
  432.             throw new NotFoundHttpException();
  433.         }
  435.         $this->entityManager->beginTransaction();
  437.         if($customer->getEmail() === $user->getEmail()) {
  438.             $existingUser = $this->entityManager
  439.                 ->getRepository(User::class)
  440.                 ->findOneBy(['email' => $user->getUsername()]);
  442.             if($existingUser === null) {
  443.                 throw new ConflictHttpException(); //409 - Conflict
  444.             }
  446.             if($email !== $user->getEmail()) {
  447.                 throw new ConflictHttpException(); //409 - Conflict
  448.             }
  450.             $pocketsInfo = $this->entityManager
  451.                 ->getRepository(Assay::class)
  452.                 ->getDistinctHardwareVersionDevicesFromAssays($user);
  454.             $pocketsSts = "";
  455.             $i = 0;
  456.             
  457.             foreach($pocketsInfo as $jsonPockets) {
  458.                 $pockets = $jsonPockets['hardwareVersion'];
  459.                 
  460.                 if(trim($pockets) != null) {
  461.                     if($i > 0) {
  462.                         $pocketsSts = $pocketsSts.";".$pockets;
  463.                     } 
  464.                     else {
  465.                         $pocketsSts = $pockets;
  466.                     }
  468.                     $i++;
  469.                 }
  470.             }
  472.             $IdsInfo = $this->entityManager
  473.                 ->getRepository(Assay::class)
  474.                 ->getAssaysIds($user);
  476.             $idsSt = "";
  477.             $i = 0;
  479.             foreach ($IdsInfo as $jsonIds) {
  480.                 $ids = $jsonIds['assayId'];
  481.                 
  482.                 if(trim($ids) != null) {
  483.                     if($i > 0) {
  484.                         $idsSt = $idsSt.";".$ids;
  485.                     } 
  486.                     else {
  487.                         $idsSt = $ids;
  488.                     }
  490.                     $i++;
  491.                 }
  492.             }
  494.             $deleteAcc = new DeleteAccounts();
  495.             $deleteAcc->setUserId($customer->getCustomerId());
  496.             $deleteAcc->setAssayIds($idsSt);
  497.             $deleteAcc->setPockets($pocketsSts);
  498.             $deleteAcc->setDeleteDatetime(new DateTime());
  499.             $this->entityManager->persist($deleteAcc);
  501.             //######### DELETE QR DATA ############//
  502.             $qrData = $this->entityManager
  503.                 ->getRepository(QRData::class)
  504.                 ->deleteQrDataByUser($user);
  506.             $qrAssayRelation = $this->entityManager
  507.                 ->getRepository(QrAssayRelation::class)
  508.                 ->deleteQrAssayRelationByUser($user);
  510.             //######### DELETE USER AND CASCADE ############//
  511.             $this->entityManager->remove($user);
  513.             // ON DELETE CASCADE // //# UESRS #//
  514.             //# ACCESS TOKEN #//    //# ASSAYS #//  //# ASSAY_DATA #//
  515.             //# ASSAY_RESULTS #//   //# CUSTOMERS #//   //# CUSTOMER_AREA #//
  517.             $this->entityManager->flush();
  518.             $this->entityManager->commit();
  519.         } 
  520.         else {
  521.             throw new ConflictHttpException(); //409 - Conflict
  522.         }
  524.         return $this->json([]);
  525.     }
  527.     /**
  528.      * Get the stab vida access token
  529.      *
  530.      * @Route(path="/stabVidaToken", methods={"GET"})
  531.      * @Security(name="Bearer")
  532.      * @OA\Response(
  533.      *     response="200",
  534.      *     description="The stab vida access token",
  535.      *     @Model(type=StabVidaTokenViewModel::class)
  536.      * )
  537.      * @OA\Response(
  538.      *     response="400",
  539.      *     ref="#/components/schemas/BadRequestError"
  540.      * )
  541.      * @throws Exception
  542.      */
  543.     public function getStabVidaAccessToken(): JsonResponse {
  544.         $user = $this->getUser();
  545.         $stabVidaToken = $this->stabVidaTokenService->getStabVidaToken($user);
  547.         if($stabVidaToken === null) {
  548.             throw new BadRequestHttpException("User is not registered in clients.stabvida.com");
  549.         }
  551.         $stabVidaTokenViewModel = StabVidaTokenViewModel::create($stabVidaToken);
  552.         return $this->json($stabVidaTokenViewModel);
  553.     }
  554. }