src/Controller/Website/CartController.php line 4370

Open in your IDE?
  1. <?php
  3. namespace EADPlataforma\Controller\Website;
  5. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Cache;
  6. use Symfony\Component\HttpFoundation\Request;
  7. use Symfony\Component\Routing\Annotation\Route;
  8. use Symfony\Component\HttpFoundation\RedirectResponse;
  9. use EADPlataforma\Entity\Cart;
  10. use EADPlataforma\Entity\Product;
  11. use EADPlataforma\Entity\ProductCharge;
  12. use EADPlataforma\Entity\ProductOffer;
  13. use EADPlataforma\Entity\ProductCoupon;
  14. use EADPlataforma\Entity\ProductOpportunity;
  15. use EADPlataforma\Entity\ProductSuggestion;
  16. use EADPlataforma\Entity\Whishlist;
  17. use EADPlataforma\Entity\Transaction;
  18. use EADPlataforma\Entity\TransactionItem;
  19. use EADPlataforma\Entity\User;
  20. use EADPlataforma\Entity\Country;
  21. use EADPlataforma\Entity\State;
  22. use EADPlataforma\Entity\City;
  23. use EADPlataforma\Entity\UserCard;
  24. use EADPlataforma\Entity\UserCheckoutInfo;
  25. use EADPlataforma\Entity\UserSubscription;
  26. use EADPlataforma\Entity\UserCustomField;
  27. use EADPlataforma\Entity\Course;
  28. use EADPlataforma\DataTransferObject\UserDTO;
  29. use EADPlataforma\Enum\CartEnum;
  30. use EADPlataforma\Enum\ProductEnum;
  31. use EADPlataforma\Enum\ProductChargeEnum;
  32. use EADPlataforma\Enum\GeoDataEnum;
  33. use EADPlataforma\Enum\ReceiverEnum;
  34. use EADPlataforma\Enum\TransactionEnum;
  35. use EADPlataforma\Enum\TransactionItemEnum;
  36. use EADPlataforma\Enum\ProductOfferEnum;
  37. use EADPlataforma\Enum\ProductCouponEnum;
  38. use EADPlataforma\Enum\ProductSuggestionEnum;
  39. use EADPlataforma\Enum\ProductOpportunityEnum;
  40. use EADPlataforma\Enum\TagsMarketingEnum;
  41. use EADPlataforma\Enum\UserEnum;
  42. use EADPlataforma\Enum\UserCardEnum;
  43. use EADPlataforma\Enum\UserCheckoutInfoEnum;
  44. use EADPlataforma\Enum\UserSubscriptionEnum;
  45. use EADPlataforma\Enum\WhishlistEnum;
  46. use EADPlataforma\Enum\EnrollmentEnum;
  47. use EADPlataforma\Enum\NotificationEnum;
  48. use EADPlataforma\Enum\WebhookEnum;
  49. use EADPlataforma\Enum\UserCustomFieldEnum;
  50. use EADPlataforma\Enum\CourseEnum;
  51. use EADPlataforma\Enum\TrashEnum;
  52. use EADPlataforma\Enum\ErrorEnum;
  54. /**
  55.  * @Route(
  56.  *      schemes         = {"http|https"}
  57.  * )
  58.  * @Cache(
  59.  *      maxage          = "0",
  60.  *      smaxage         = "0",
  61.  *      expires         = "now",
  62.  *      public          = false
  63.  * )
  64.  */
  65. class CartController extends AbstractWebsiteController {
  67.     /**
  68.      * @Route(
  69.      *      path          = "/installment/interest",
  70.      *      name          = "getInstallmentInterest",
  71.      *      methods       = {"GET"}
  72.      * )
  73.      */
  74.     public function getInstallmentInterest(Request $request) {
  75.         $this->requestUtil->setRequest($request)->setData();
  77.         $numberUtil = $this->generalService->getUtil('NumberUtil');
  79.         $installments = (int)$this->requestUtil->getField('installments');
  80.         $freeInstallments = (int)$this->requestUtil->getField('freeInstallments');
  81.         $amount = (float)$this->requestUtil->getField('amount');
  83.         $productOfferIds = $this->requestUtil->getField('productIds');
  84.         $productOfferIds = json_decode($productOfferIds);
  85.         $poRepository = $this->em->getRepository(ProductOffer::class);
  86.         
  87.         if(empty($freeInstallments)){
  88.             $freeInstallments = CartEnum::YES;
  89.         }
  91.         $pagarMeTransaction = $this->generalService->getService(
  92.             'PagarMe\\PagarMeTransaction'
  93.         );
  95.         $paymentConfig = $this->configuration->getPaymentConfig();
  97.         $parcelItems = [];
  99.         if(!empty($productOfferIds)){
  100.             foreach ($productOfferIds as $key => $offerId) {
  101.                 $productOffer = $poRepository->find($offerId);
  103.                 $parcels = (array) $pagarMeTransaction->calculateInstallments([
  104.                     'amount' => $numberUtil->numberToCents($productOffer->getPriceReal()),
  105.                     'free_installments' => $freeInstallments,
  106.                     'max_installments' => $installments,
  107.                     'interest_rate' => $paymentConfig->installmentInterest
  108.                 ]);
  110.                 foreach ($parcels as $key => $value) {
  111.                     $value->amount = $numberUtil->centsToNumber($value->amount);
  112.                     $value->installment_amount = $numberUtil->centsToNumber(
  113.                         $value->installment_amount
  114.                     );
  115.                     $parcels[$key] = $value;
  116.                 }
  118.                 $parcelItems[$offerId] = $parcels;
  119.             }
  120.         }
  122.         $installmentsOptions = (array) $pagarMeTransaction->calculateInstallments([
  123.             'amount' => $numberUtil->numberToCents($amount),
  124.             'free_installments' => $freeInstallments,
  125.             'max_installments' => $installments,
  126.             'interest_rate' => $paymentConfig->installmentInterest
  127.         ]);
  129.         if(empty($installmentsOptions[$installments])){
  130.             return $this->eadResponse([
  131.                 "parcelItems" => $parcelItems,
  132.                 "installmentsOptions" => [
  133.                     "1" => [
  134.                         "installment" => 1,
  135.                         "amount" => $amount,
  136.                         "installment_amount" => $amount,
  137.                     ]
  138.                 ],
  139.                 "amountTotal" => $amount,
  140.                 "amountParcel" => $amount
  141.             ]);
  142.         }
  144.         foreach ($installmentsOptions as $key => $value) {
  145.             $value->amount = $numberUtil->centsToNumber($value->amount);
  146.             $value->installment_amount = $numberUtil->centsToNumber(
  147.                 $value->installment_amount
  148.             );
  149.             $installmentsOptions[$key] = $value;
  150.         }
  152.         return $this->eadResponse([
  153.             "parcelItems" => $parcelItems,
  154.             "installmentsOptions" => $installmentsOptions,
  155.             "amountTotal" => $installmentsOptions[$installments]->amount,
  156.             "amountParcel" => $installmentsOptions[$installments]->installment_amount
  157.         ]);
  158.     }
  160.     /**
  161.      * @Route(
  162.      *      path          = "/charge/payment/{hash}",
  163.      *      name          = "getChargePage",
  164.      *      methods       = {"GET"}
  165.      * )
  166.      */
  167.     public function getChargePage(Request $request) {
  168.         if(!$this->configuration->isModuleActive("product_charge_module")){
  169.             return $this->redirectToRoute('notFound');
  170.         }
  171.         
  172.         $hash = $request->get('hash');
  173.         $debug = (int)$request->get('debug');
  175.         $productCharge = $this->em->getRepository(ProductCharge::class)->findOneBy([
  176.             "chargeKey" => $hash,
  177.             "deleted" => ProductChargeEnum::ITEM_NO_DELETED
  178.         ]);
  179.         
  180.         if (!$productCharge) {
  181.             return $this->redirectToRoute('notFound');
  182.         }
  184.         if($productCharge->getPublish() == ProductChargeEnum::NO){
  185.             return $this->redirectToRoute('notFound');
  186.         }
  188.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  190.         $user = $productCharge->getUser();
  192.         $numberUserCheckoutInfo = $userCheckoutInfoRepository->count([
  193.             "user" => $user->getId(),
  194.             "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED
  195.         ]);
  197.         if(empty($numberUserCheckoutInfo)){
  198.             $userCheckoutInfo = new UserCheckoutInfo();
  200.             $userCheckoutInfo->setName($user->getName());
  201.             $userCheckoutInfo->setEmail($user->getEmail());
  202.             $userCheckoutInfo->setDocument($user->getDocument());
  203.             $userCheckoutInfo->setPhone($user->getPhone());
  204.             $userCheckoutInfo->setZipCode($user->getZipCode());
  205.             $userCheckoutInfo->setAddress($user->getAddress());
  206.             $userCheckoutInfo->setAddressNumber($user->getAddressNumber());
  207.             $userCheckoutInfo->setAddressComplement($user->getAddressComplement());
  208.             $userCheckoutInfo->setAddressNeighborhood($user->getAddressNeighborhood());
  209.             $userCheckoutInfo->setCity($user->getCity());
  210.             $userCheckoutInfo->setState($user->getState());
  211.             $userCheckoutInfo->setCountry($user->getCountry());
  212.             $userCheckoutInfo->setUser($user);
  213.             $userCheckoutInfo->setReceiveEmail(UserCheckoutInfoEnum::NO);
  214.             $userCheckoutInfo->setDefault(UserCheckoutInfoEnum::YES);
  216.             $this->em->persist($userCheckoutInfo);
  217.         }
  218.         
  219.         if($productCharge->getStatus() == ProductChargeEnum::WAITING){
  220.             $today = strtotime(date('Y-m-d'));
  221.             $dateExpire = strtotime($productCharge->getDateExpire());
  223.             if($today > $dateExpire){
  224.                 $productCharge->setStatus(ProductChargeEnum::EXPIRED_PAYMENT);
  225.             }
  226.         }
  228.         $this->em->flush();
  230.         $userCheckoutInfos = $userCheckoutInfoRepository->findBy([
  231.             "user" => $user->getId(),
  232.             "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED
  233.         ]);
  235.         $userCardRepository = $this->em->getRepository(UserCard::class);
  236.         
  237.         $userCards = null;
  238.         if($this->user && $this->user->getId() == $user->getId()){
  239.             $userCards = $userCardRepository->getValidUserCard();
  240.         }
  242.         $pagarMeTransaction = $this->generalService->getService(
  243.             'PagarMe\\PagarMeTransaction'
  244.         );
  246.         $paymentConfig = $this->configuration->getPaymentConfig();
  248.         $this->data['installmentsOptions'] = (array) $pagarMeTransaction->calculateInstallments([
  249.             'amount' => $productCharge->getAmount(true),
  250.             'free_installments' => $productCharge->getInstallmentNumberInterest(),
  251.             'max_installments' => $productCharge->getInstallmentNumberMax(),
  252.             'interest_rate' => $paymentConfig->installmentInterest
  253.         ]);
  255.         $this->data['productCharge'] = $productCharge;
  256.         $this->data['userCheckoutInfos'] = $userCheckoutInfos;
  257.         $this->data['userCards'] = $userCards;
  258.         $this->data['debug'] = $debug;
  260.         return $this->renderEAD('cart/charge/charge.html.twig');
  261.     }
  263.     /**
  264.      * @Route(
  265.      *      path          = "/cart/opportunity/{hash}",
  266.      *      name          = "getCartOpportunity",
  267.      *      methods       = {"GET"}
  268.      * )
  269.      */
  270.     public function getCartOpportunity(Request $request) {
  271.         
  272.         $hash = $request->get('hash');
  274.         $cartRepository = $this->em->getRepository(Cart::class);
  275.         $userRepository = $this->em->getRepository(User::class);
  276.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  277.         $productOpportunityRepository = $this->em->getRepository(ProductOpportunity::class);
  279.         $op = (object)$productOpportunityRepository->getDetailProductOpportunityByHash(
  280.             $hash
  281.         );
  283.         $user = $userRepository->findOneBy([
  284.             "id" => $op->user->userId,
  285.             "deleted" => UserEnum::ITEM_NO_DELETED,
  286.         ]);
  288.         if($user){
  289.             $this->generalService->setCookie('hashcartoff', $user->getHashIdentify());
  291.             if($this->user && $this->user->getId() != $user->getId()){
  292.                 return $this->redirectToRoute('notFound');
  293.             }
  294.         }
  296.         $this->requestUtil->setRequest($request)->setData();
  298.         $data = $this->requestUtil->getData();
  299.         
  300.         $dataUtml = [
  301.             "utm_source"   => $request->get('utm_source'),
  302.             "utm_medium"   => $request->get('utm_medium'),
  303.             "utm_campaign" => $request->get('utm_campaign'),
  304.             "utm_term"     => $request->get('utm_term'),
  305.             "utm_content"  => $request->get('utm_content'),
  306.         ];
  308.         $utmsUrl = json_encode($dataUtml);
  310.         foreach ($op->order as $key => $value){
  312.             $productOffer = $productOfferRepository->findOneBy([
  313.                 "id" => $value->offerId,
  314.                 "deleted" => ProductOfferEnum::ITEM_NO_DELETED,
  315.             ]);
  317.             if($productOffer){
  318.                 $cartRepository->addCartByProductOffer(
  319.                     $productOffer, 
  320.                     $user, 
  321.                     null,
  322.                     null,
  323.                     $utmsUrl
  324.                 );
  325.             }
  326.         }
  327.         
  328.         return $this->redirectToRoute('cart');
  329.     }
  331.     /**
  332.      * @Route(
  333.      *      path          = "/cart/items/menu",
  334.      *      name          = "getCartItemsMenu",
  335.      *      methods       = {"GET"}
  336.      * )
  337.      */
  338.     public function getCartItemsMenu(Request $request) {
  340.         $itemsNumber = (int)$request->get('itemsNumber');
  342.         $this->data['itemsNumber'] = $itemsNumber;
  344.         return $this->renderEAD('includes/submenu-cart-items.html.twig');
  345.     }
  347.     /**
  348.      * @Route(
  349.      *      path          = "/cart/initiate/checkout",
  350.      *      name          = "cartInitiateCheckout",
  351.      *      methods       = {"GET"}
  352.      * )
  353.      */
  354.     public function cartInitiateCheckout(Request $request){
  356.         $pixelService = $this->generalService->getService('Marketing\\PixelService');
  357.         $pixelService->sendConversion('InitiateCheckout');
  359.         return $this->eadResponse([ "message" => "Success" ]);
  360.     }
  362.     /**
  363.      * @Route(
  364.      *      path          = "/checkout/{type}/{productId}/{couponKey}/{productSuggestionId}",
  365.      *      name          = "checkoutOldCart",
  366.      *      methods       = {"GET"},
  367.      *      defaults      = { "couponKey" = 0, "productSuggestionId" = 0 },
  368.      *      requirements  = { "productId" = "\d+" }
  369.      * )
  370.      */
  371.     public function getCheckoutOldCart(Request $request) {
  373.         $couponKey = $request->get('couponKey');
  375.         $dataUtml = [
  376.             "utm_source" => $request->get('utm_source'),
  377.             "utm_medium" => $request->get('utm_medium'),
  378.             "utm_campaign" => $request->get('utm_campaign'),
  379.             "utm_term" => $request->get('utm_term'),
  380.             "utm_content" => $request->get('utm_content'),
  381.         ];
  383.         $product = $this->em->getRepository(Product::class)->findOneBy([ 
  384.             "id" => (int)$request->get('productId')
  385.         ]);
  387.         if(!$product){
  388.             return $this->redirectToRoute('notFound');
  389.         }
  391.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  392.         $productOffer = $productOfferRepository->getProductOfferDefaultByProduct(
  393.             $product
  394.         );
  396.         if(!$productOffer){
  397.             return $this->redirectToRoute('notFound');
  398.         }
  400.         $productCoupon = null;
  401.         if(!empty($couponKey)){
  402.             $productCouponRepository = $this->em->getRepository(ProductCoupon::class);
  403.             $productCoupon = $productCouponRepository->findValidProductCouponByProductOffer(
  404.                 $couponKey, 
  405.                 $productOffer
  406.             );
  407.         }
  409.         if(
  410.             $product->getType() == ProductEnum::SUBSCRIPTION ||
  411.             (
  412.                 $product->getType() != ProductEnum::SUBSCRIPTION && 
  413.                 $productOffer->getAllowRecurrency() == ProductOfferEnum::YES
  414.             )
  415.         ){
  416.             if($productOffer->getAllowTrial() == ProductOfferEnum::YES){
  418.                 $params = [
  419.                     "poHash" => $productOffer->getOfferLink(),
  420.                     "pcKey" => $couponKey,
  421.                 ];
  423.                 $params = array_merge($params, $dataUtml);
  425.                 return $this->redirectToRoute('cartIndividual', $params);
  426.             }
  427.         }
  429.         $params = [
  430.             "poID" => $productOffer->getId(),
  431.             "pcID" => ( $productCoupon ? $productCoupon->getId() : 0 ),
  432.             "psID" => $request->get('productSuggestionId'),
  433.         ];
  435.         $params = array_merge($params, $dataUtml);
  437.         return $this->redirectToRoute('cartAdd', $params);
  438.     }
  440.     /**
  441.      * @Route(
  442.      *      path          = "/checkout/offer/{type}/{productId}/{offerLink}/{courseId}",
  443.      *      name          = "checkoutNewCart",
  444.      *      methods       = {"GET"},
  445.      *      defaults      = { "courseId" = 0 },
  446.      *      requirements  = { "productId" = "\d+", "courseId" = "\d+" }
  447.      * )
  448.      */
  449.     public function getCheckoutNewCart(Request $request) {
  451.         $offerLink = $request->get('offerLink');
  452.         $courseId = (int)$request->get('courseId');
  454.         $product = $this->em->getRepository(Product::class)->findOneBy([ 
  455.             "id" => $request->get('productId')
  456.         ]);
  458.         if(!$product){
  459.             return $this->redirectToRoute('notFound');
  460.         }
  462.         $dataUtml = [
  463.             "utm_source" => $request->get('utm_source'),
  464.             "utm_medium" => $request->get('utm_medium'),
  465.             "utm_campaign" => $request->get('utm_campaign'),
  466.             "utm_term" => $request->get('utm_term'),
  467.             "utm_content" => $request->get('utm_content'),
  468.         ];
  470.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  471.         $productOffer = $productOfferRepository->getProductOfferDefaultByProduct(
  472.             $product, 
  473.             $offerLink
  474.         );
  476.         if(!$productOffer){
  477.             return $this->redirectToRoute('notFound');
  478.         }
  480.         if(
  481.             $product->getType() == ProductEnum::SUBSCRIPTION || 
  482.             (
  483.                 $product->getType() != ProductEnum::SUBSCRIPTION && 
  484.                 $productOffer->getAllowRecurrency() == ProductOfferEnum::YES
  485.             )
  486.         ){
  487.             if($productOffer->getAllowTrial() == ProductOfferEnum::YES){
  488.                 $params = [
  489.                     "poHash" => $productOffer->getOfferLink(),
  490.                     "pcKey" => null,
  491.                 ];
  493.                 $params = array_merge($params, $dataUtml);
  495.                 return $this->redirectToRoute('cartIndividual', $params);
  496.             }
  497.         }
  499.         $params = [
  500.             "poID" => $productOffer->getId(),
  501.             "courseId" => $courseId,
  502.         ];
  504.         $params = array_merge($params, $dataUtml);
  506.         return $this->redirectToRoute('cartAdd', $params);
  507.     }
  509.     /**
  510.      * @Route(
  511.      *      path          = "/checkout/coupon/{type}/{productId}/{productCouponId}",
  512.      *      name          = "checkoutCartWithCoupon",
  513.      *      methods       = {"GET"},
  514.      *      requirements  = { "productId" = "\d+", "productCouponId" = "\d+" }
  515.      * )
  516.      */
  517.     public function getCheckoutCartWithCoupon(Request $request) {
  519.         $product = $this->em->getRepository(Product::class)->findOneBy([ 
  520.             "id" => (int)$request->get('productId')
  521.         ]);
  523.         if(!$product){
  524.             return $this->redirectToRoute('notFound');
  525.         }
  527.         $dataUtml = [
  528.             "utm_source" => $request->get('utm_source'),
  529.             "utm_medium" => $request->get('utm_medium'),
  530.             "utm_campaign" => $request->get('utm_campaign'),
  531.             "utm_term" => $request->get('utm_term'),
  532.             "utm_content" => $request->get('utm_content'),
  533.         ];
  535.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  536.         $productOffer = $productOfferRepository->getProductOfferDefaultByProduct(
  537.             $product 
  538.         );
  540.         if(!$productOffer){
  541.             return $this->redirectToRoute('notFound');
  542.         }
  544.         if(
  545.             $product->getType() == ProductEnum::SUBSCRIPTION ||
  546.             (
  547.                 $product->getType() != ProductEnum::SUBSCRIPTION && 
  548.                 $productOffer->getAllowRecurrency() == ProductOfferEnum::YES
  549.             )
  550.         ){
  551.             if($productOffer->getAllowTrial() == ProductOfferEnum::YES){
  553.                 $params = [
  554.                     "poHash" => $productOffer->getOfferLink(),
  555.                     "pcKey" => null,
  556.                 ];
  558.                 $params = array_merge($params, $dataUtml);
  560.                 return $this->redirectToRoute('cartIndividual', $params);
  561.             }
  562.         }
  564.         $params = [
  565.             "poID" => $productOffer->getId(),
  566.             "pcID" => (int)$request->get('productCouponId'),
  567.         ];
  569.         $params = array_merge($params, $dataUtml);
  571.         return $this->redirectToRoute('cartAdd', $params);
  572.     }
  574.     /**
  575.      * @Route(
  576.      *      path          = "/cart/add/{poID}/{psID}/{pcID}/{isAjaxRequest}/{courseId}",
  577.      *      name          = "cartAdd",
  578.      *      methods       = {"GET"},
  579.      *      defaults      = { 
  580.      *                          "psID" = 0, 
  581.      *                          "pcID" = 0, 
  582.      *                          "isAjaxRequest" = 0, 
  583.      *                          "courseId" = 0 
  584.      *                      }
  585.      * )
  586.      */
  587.     public function registerCart(Request $request) {
  589.         $cartRepository = $this->em->getRepository(Cart::class);
  591.         $productOfferId = (int)$request->get('poID');
  592.         $productSuggestionId = (int)$request->get('psID');
  593.         $productCouponId = (int)$request->get('pcID');
  594.         $isAjaxRequest = (int)$request->get('isAjaxRequest');
  595.         $courseId = (int)$request->get('courseId');
  597.         $hash = base64_encode($request->getUri());
  599.         $this->requestUtil->setRequest($request)->setData();
  601.         $data = $this->requestUtil->getData();
  602.         
  603.         $dataUtml = [
  604.             "utm_source" => $request->get('utm_source'),
  605.             "utm_medium" => $request->get('utm_medium'),
  606.             "utm_campaign" => $request->get('utm_campaign'),
  607.             "utm_term" => $request->get('utm_term'),
  608.             "utm_content" => $request->get('utm_content'),
  609.         ];
  611.         $utmsUrl = json_encode($dataUtml);
  613.         $course = $this->em->getRepository(Course::class)->findOneBy([ 
  614.             "id" => $courseId, 
  615.             "status" => CourseEnum::PUBLISHED,
  616.             "deleted" => CourseEnum::ITEM_NO_DELETED
  617.         ]);
  619.         $productOffer = $this->em->getRepository(ProductOffer::class)->findOneBy([ 
  620.             "id" => $productOfferId, 
  621.             "status" => ProductOfferEnum::PUBLISHED,
  622.             "deleted" => ProductOfferEnum::ITEM_NO_DELETED
  623.         ]);
  625.         if(!$productOffer){
  626.             if($isAjaxRequest == CartEnum::YES){
  627.                 return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  628.             }
  629.             return $this->redirectToRoute('notFound');
  630.         }
  632.         $hasModule = $this->configuration->isModuleActive("product_coupon_module");
  634.         $enrollmentService = $this->generalService->getService('EnrollmentService');
  635.         $pcRepository = $this->em->getRepository(ProductCoupon::class);
  636.         $psRepository = $this->em->getRepository(ProductSuggestion::class);
  638.         $productSuggestion = null;
  640.         if(!empty($productSuggestionId)){
  641.             $productSuggestion = $psRepository->findOneBy([ 
  642.                 "id" => $productSuggestionId, 
  643.                 "status" => ProductSuggestionEnum::PUBLISHED,
  644.                 "deleted" => ProductSuggestionEnum::ITEM_NO_DELETED
  645.             ]);
  646.         }
  648.         $productCoupon = null;
  649.         $product = $productOffer->getProduct();
  651.         if($hasModule){
  652.             $productCoupon = $pcRepository->findValidProductCouponByIdAndProductOffer(
  653.                 $productCouponId,
  654.                 $productOffer
  655.             );
  657.             if($productCoupon && $this->user){
  658.                 if($pcRepository->checkApplyCoupon($productCoupon, $productOffer)){
  659.                     $price = $pcRepository->applyDiscount(
  660.                         $productCoupon,
  661.                         $productOffer->getPriceReal()
  662.                     );
  664.                     if(empty($price)){
  665.                         $enrollmentService->setOrigin(EnrollmentEnum::ORIGIN_COUPOM);
  666.                         $enrollmentService->setCouponKey($productCoupon->getKey());
  667.                         $enrollmentService->enrollUserByProduct(
  668.                             $this->user, 
  669.                             $product,
  670.                             ($product->isTypeResource() ? $course : null)
  671.                         );
  673.                         return $this->redirectToRoute('resume');
  674.                     }
  675.                 }
  676.             }
  677.         }
  679.         if($productOffer->getSaleChannel() == ProductOfferEnum::EXTERNAL){
  680.             $externalCheckoutLink = $productOffer->getExternalCheckoutLink();
  681.             if(!empty($externalCheckoutLink)){
  682.                 return $this->redirect($externalCheckoutLink, 301);
  683.             }
  684.         }
  686.         $cartRepository->addCartByProductOffer(
  687.             $productOffer, 
  688.             $this->user, 
  689.             $productSuggestion,
  690.             $productCoupon,
  691.             $utmsUrl,
  692.             ($course ? [ $course ] : null)
  693.         );
  695.         $allowSuggestion = (
  696.             !$product->isTypeResource() || 
  697.             ($course && $product->isTypeResource())
  698.         );
  700.         $psRedirect = null;
  702.         if($allowSuggestion){
  703.             $psRedirect = $psRepository->getProductSuggestionRedirectByProductOffer(
  704.                 $productOffer, 
  705.                 ProductSuggestionEnum::EXECUTE_ON_ADD_CART
  706.             );
  707.         }
  709.         if($isAjaxRequest == CartEnum::YES){
  710.             return $this->eadResponse([
  711.                 "cartItemsQuantity" => $cartRepository->countUserOnCart(),
  712.                 "urlRedirect" => ( $psRedirect ? $psRedirect->getLinkRedirect() : null ),
  713.                 "success" => CartEnum::YES
  714.             ]);
  715.         }
  717.         if($psRedirect){
  718.             return $this->redirect($psRedirect->getLinkRedirect());
  719.         }
  721.         $productOfferSuggestions = null;
  722.         if($allowSuggestion){
  723.             $productOfferSuggestions = $psRepository->getProductSuggestionsByOfferOrigin(
  724.                 $productOffer, 
  725.                 ProductSuggestionEnum::EXECUTE_ON_ADD_CART
  726.             );
  727.         }
  729.         if(!empty($productOfferSuggestions)){
  730.             if($productCoupon && $hasModule){
  731.                 foreach ($productOfferSuggestions as $key => $offerSuggestion) {
  732.                     $pcSuggestion = $pcRepository->findValidProductCouponByIdAndProductOffer(
  733.                         $productCoupon->getId(), 
  734.                         $offerSuggestion,
  735.                         true
  736.                     );
  738.                     if($pcSuggestion){
  740.                         $amount = $offerSuggestion->getPriceReal();
  742.                         if($pcRepository->checkApplyCoupon($pcSuggestion, $offerSuggestion)){
  743.                             $amount = $pcRepository->applyDiscount($pcSuggestion, $amount);
  744.                         }
  746.                         if(!empty($amount)){
  747.                             $offerSuggestion->setPriceRealCopy($amount);
  748.                             $productOfferSuggestions[$key] = $offerSuggestion;
  749.                         }else{
  750.                             if($this->user){
  751.                                 $pcSuggestion->setUsageNumber(
  752.                                     $pcSuggestion->getUsageNumber() + 1
  753.                                 );
  755.                                 $this->em->flush();
  757.                                 $offerProd = $offerSuggestion->getProduct();
  759.                                 $enrollmentService->setOrigin(EnrollmentEnum::ORIGIN_COUPOM);
  760.                                 $enrollmentService->setCouponKey($couponKey);
  761.                                 $enrollmentService->enrollUserByProduct(
  762.                                     $this->user,
  763.                                     $offerProd,
  764.                                     ($offerProd->isTypeResource() ? $course : null)
  765.                                 );
  767.                                 unset($productOfferSuggestions[$key]);
  768.                             }
  769.                         }
  770.                     }
  771.                 }
  772.             }
  774.             $this->data['productOfferId'] = $productOfferId;
  775.             $this->data['productCoupon'] = $productCoupon;
  776.             $this->data['productOfferSuggestions'] = $productOfferSuggestions;
  778.             return $this->renderEAD('cart/suggestions.html.twig');
  779.         }
  780.         
  781.         if($productCoupon){
  782.             return $this->redirectToRoute('cart', [ 
  783.                 "coupon" => $productCoupon->getKey()
  784.             ]);
  785.         }
  787.         return $this->redirectToRoute('cart');
  788.     }
  790.     /**
  791.      * @Route(
  792.      *      path          = "/cart/add/suggestion/{productOfferId}/{productCouponId}",
  793.      *      name          = "cartAddSuggestion",
  794.      *      methods       = {"POST"},
  795.      *      defaults      = { "productCouponId" = 0 }
  796.      * )
  797.      */
  798.     public function registerCartBySuggestion(Request $request) {
  800.         $this->requestUtil->setRequest($request)->setData();
  802.         $cartRepository = $this->em->getRepository(Cart::class);
  804.         $productSuggestions = json_decode(
  805.             $this->requestUtil->getField('productSuggestions')
  806.         );
  808.         if(empty($productSuggestions)){
  809.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  810.         }
  812.         $productCouponId = (int)$request->get('productCouponId');
  813.         $productOfferId = (int)$request->get('productOfferId');
  815.         $hasModule = $this->configuration->isModuleActive("product_coupon_module");
  816.         $enrollmentService = $this->generalService->getService('EnrollmentService');
  817.         $pcRepository = $this->em->getRepository(ProductCoupon::class);
  818.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  820.         $productOffer = $productOfferRepository->findOneBy([ 
  821.             "id" => $productOfferId,
  822.             "status" => ProductOfferEnum::PUBLISHED,
  823.             "deleted" => ProductOfferEnum::ITEM_NO_DELETED
  824.         ]);
  826.         if(!$productOffer){
  827.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  828.         }
  830.         if($productOffer->getSaleChannel() == ProductOfferEnum::EXTERNAL){
  831.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  832.         }
  834.         $product = $productOffer->getProduct();
  835.         $productCouponOffer = null;
  837.         $course = null;
  838.         if(
  839.             $product->getType() == ProductEnum::COURSE ||
  840.             $product->getType() == ProductEnum::COMBO
  841.         ){
  842.             $courseRepository = $this->em->getRepository(Course::class);
  843.             $courses = $courseRepository->getCoursesByProduct($product->getId());
  844.         }
  845.         
  846.         if($hasModule){
  847.             $productCouponOffer = $pcRepository->findValidProductCouponByIdAndProductOffer(
  848.                 $productCouponId, 
  849.                 $productOffer
  850.             );
  852.             if($productCouponOffer && $this->user){
  853.                 if($pcRepository->checkApplyCoupon($productCouponOffer, $productOffer)){
  854.                     $priceOffer = $pcRepository->applyDiscount(
  855.                         $productCouponOffer, 
  856.                         $priceOffer
  857.                     );
  859.                     if(empty($priceOffer)){
  860.                         $enrollmentService->setOrigin(EnrollmentEnum::ORIGIN_COUPOM);
  861.                         $enrollmentService->setCouponKey($productCouponOffer->getKey());
  862.                         $enrollmentService->enrollUserByProduct(
  863.                             $this->user, 
  864.                             $product,
  865.                             null,
  866.                             ($product->isTypeResource() ? $courses : null)
  867.                         );
  868.                     }
  869.                 }
  870.             }
  871.         }
  873.         $cartRepository->addCartByProductOffer(
  874.             $productOffer,
  875.             $this->user,
  876.             null,
  877.             $productCouponOffer,
  878.             null,
  879.             ($product->isTypeResource() ? $courses : null)
  880.         );
  882.         $psRepository = $this->em->getRepository(ProductSuggestion::class);
  883.         foreach ($productSuggestions as $key => $productSuggestionId) {
  885.             $productSuggestion = $psRepository->findOneBy([ 
  886.                 "id" => $productSuggestionId, 
  887.                 "status" => ProductSuggestionEnum::PUBLISHED,
  888.                 "deleted" => ProductSuggestionEnum::ITEM_NO_DELETED
  889.             ]);
  891.             if($productSuggestion){
  893.                 $offerSuggestion = $productSuggestion->getProductOffer();
  894.                 $pcSuggestion = null;
  895.                 $priceOfferSuggestion = $offerSuggestion->getPriceReal();
  896.                 $offerProd = $offerSuggestion->getProduct();
  898.                 if($hasModule){
  899.                     $pcSuggestion = $pcRepository->findValidProductCouponByIdAndProductOffer(
  900.                         $productCouponId, 
  901.                         $offerSuggestion,
  902.                         true
  903.                     );
  905.                     if($pcSuggestion && $this->user){
  906.                         if($pcRepository->checkApplyCoupon($pcSuggestion, $offerSuggestion)){
  907.                             $priceOfferSuggestion = $pcRepository->applyDiscount(
  908.                                 $pcSuggestion, 
  909.                                 $priceOfferSuggestion
  910.                             );
  912.                             if(empty($priceOfferSuggestion)){
  913.                                 $enrollmentService->setOrigin(EnrollmentEnum::ORIGIN_COUPOM);
  914.                                 $enrollmentService->setCouponKey($pcSuggestion->getKey());
  915.                                 $enrollmentService->enrollUserByProduct(
  916.                                     $this->user,
  917.                                     $offerProd,
  918.                                     ($offerProd->isTypeResource() ? $courses : null)
  919.                                 );
  920.                             }
  921.                         }
  922.                     }
  923.                 }
  925.                 $cartRepository->addCartByProductOffer(
  926.                     $offerSuggestion, 
  927.                     $this->user, 
  928.                     $productSuggestion,
  929.                     $pcSuggestion,
  930.                     null,
  931.                     ($offerProd->isTypeResource() ? $courses : null)
  932.                 );
  933.             }
  934.         }
  936.         return $this->eadResponse([
  937.             "cartItemsQuantity" => $cartRepository->countUserOnCart(),
  938.             "success" => CartEnum::YES
  939.         ]);
  940.     }
  942.     /**
  943.      * @Route(
  944.      *      path          = "/cart/enroll/{productOfferId}",
  945.      *      name          = "cartCreateEnroll",
  946.      *      methods       = {"GET"}
  947.      * )
  948.      */
  949.     public function cartCreateEnroll(Request $request){
  950.         $this->checkUserSession($request);
  952.         $productOfferId = $request->get('productOfferId');
  953.         $productOffer = $this->em->getRepository(ProductOffer::class)->findOneBy([ 
  954.             "id" => $productOfferId, 
  955.             "status" => ProductOfferEnum::PUBLISHED,
  956.             "deleted" => ProductOfferEnum::ITEM_NO_DELETED
  957.         ]);
  959.         if(!$productOffer){
  960.             return $this->redirectToRoute('notFound');
  961.         }
  963.         $product = $productOffer->getProduct();
  964.         if($product->isDisable()){
  965.             return $this->redirectToRoute('notFound');
  966.         }
  968.         if($productOffer->getSaleOption() != ProductOfferEnum::FREE){
  969.             return $this->redirectToRoute('notFound');
  970.         }
  972.         $enrollmentService = $this->generalService->getService('EnrollmentService');
  973.         $enrollmentService->setNotification(true);
  974.         $enrollmentService->enrollUserByProduct($this->user, $product);
  976.         return $this->redirectToRoute('resume');
  977.     }
  979.     /**
  980.      * @Route(
  981.      *      path          = "/whishlist/add/{productId}",
  982.      *      name          = "addProductWhishlist",
  983.      *      methods       = {"GET"}
  984.      * )
  985.      */
  986.     public function addProductWhishlist(Request $request){
  987.         $this->checkUserSession($request);
  989.         $productId = $request->get('productId');
  990.         $product = $this->em->getRepository(Product::class)->findOneBy([ 
  991.             "id" => $productId, 
  992.             "status" => ProductEnum::PUBLISHED,
  993.             "deleted" => ProductEnum::ITEM_NO_DELETED
  994.         ]);
  996.         if(!$product){
  997.             return $this->redirectToRoute('notFound');
  998.         }
  1000.         if($product->isDisable()){
  1001.             return $this->redirectToRoute('notFound');
  1002.         }
  1004.         $productOfferId = $request->get('productOfferId');
  1005.         $productOffer = $this->em->getRepository(ProductOffer::class)->findOneBy([ 
  1006.             "id" => $productOfferId, 
  1007.             "status" => ProductOfferEnum::PUBLISHED,
  1008.             "deleted" => ProductOfferEnum::ITEM_NO_DELETED
  1009.         ]);
  1011.         $whishlist = new Whishlist();
  1013.         $whishlistSave = $this->em->getRepository(Whishlist::class)->findOneBy([ 
  1014.             "product" => $productId,
  1015.             "user" => $this->user->getId(),
  1016.         ]);
  1018.         if($whishlistSave){
  1019.             $whishlist = $whishlistSave;
  1020.         }
  1022.         $whishlist->setUser($this->user);
  1023.         $whishlist->setProduct($product);
  1025.         if($productOffer){
  1026.             $whishlist->setProductOffer($productOffer);
  1027.         }
  1029.         $errors = $this->validateEntity($whishlist);
  1030.         if($errors){
  1031.             return $this->redirectToRoute('notFound');
  1032.         }
  1034.         if(!$whishlistSave) {
  1035.             $this->em->persist($whishlist);
  1036.         }
  1038.         $this->em->flush();
  1040.         return $this->redirectToRoute('resume');
  1041.     }
  1043.     /**
  1044.      * @Route(
  1045.      *      path          = "/apply",
  1046.      *      name          = "applyCartCoupon",
  1047.      *      methods       = {"POST"},
  1048.      * )
  1049.      */
  1050.     public function applyProductCoupon(Request $request) {
  1051.         if(!$this->configuration->isModuleActive("product_coupon_module")){
  1052.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  1053.         }
  1055.         $this->requestUtil->setRequest($request)->setData();
  1056.         
  1057.         $couponKey = $this->requestUtil->getField('couponKey');
  1059.         $cookieName = 'hashcartoff';
  1060.         $hashId = $this->generalService->getCookie($cookieName);
  1062.         $cartRepository = $this->em->getRepository(Cart::class);
  1063.         $return = $cartRepository->applyCouponUserCart($couponKey, $this->user, $hashId);
  1065.         return $this->eadResponse([ "success" => ( $return ? 1 : 0 ) ]);
  1066.     }
  1068.     /**
  1069.      * @Route(
  1070.      *      path          = "/apply/offer",
  1071.      *      name          = "applyProductCouponOnOffer",
  1072.      *      methods       = {"POST"},
  1073.      * )
  1074.      */
  1075.     public function applyProductCouponOnOffer(Request $request) {
  1076.         if(!$this->configuration->isModuleActive("product_coupon_module")){
  1077.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  1078.         }
  1080.         $this->requestUtil->setRequest($request)->setData();
  1081.         
  1082.         $couponKey = $this->requestUtil->getField('couponKey');
  1083.         $productOfferIds = $this->requestUtil->getField('productIds');
  1084.         $cartIds = $this->requestUtil->getField('cartIds');
  1086.         if(empty($couponKey)){
  1087.             return $this->eadResponse([ "couponKey" ], ErrorEnum::FIELD_EMPTY);
  1088.         }
  1090.         $cartIds = json_decode($cartIds);
  1091.         $productOfferIds = json_decode($productOfferIds);
  1092.         if(empty($productOfferIds) || !is_array($productOfferIds)){
  1093.             return $this->eadResponse([ "productIds" ], ErrorEnum::FIELD_EMPTY);
  1094.         }
  1096.         $poRepository = $this->em->getRepository(ProductOffer::class);
  1097.         $pcRepository = $this->em->getRepository(ProductCoupon::class);
  1099.         $items = [];
  1100.         $total = 0;
  1101.         $totalWithDiscount = 0;
  1103.         $find = false;
  1105.         foreach ($productOfferIds as $key => $offerId) {
  1106.             $productOffer = $poRepository->find($offerId);
  1108.             $productCoupon = $pcRepository->findValidProductCouponByProductOffer(
  1109.                 $couponKey,
  1110.                 $productOffer
  1111.             );
  1113.             $amountDisplay = (float)$productOffer->getPriceDisplay();
  1114.             $amount = (float)$productOffer->getPriceReal();
  1116.             if(in_array($offerId, $cartIds)){
  1117.                 $total = $total + (!empty($amountDisplay) ? $amountDisplay : $amount);
  1118.             }
  1119.             
  1120.             if($productCoupon){
  1121.                 $find = true;
  1122.                 $amount = $pcRepository->applyDiscount($productCoupon, $amount);
  1123.             }
  1125.             if(in_array($offerId, $cartIds)){
  1126.                 $totalWithDiscount = $totalWithDiscount + $amount;
  1127.             }
  1129.             $items[] = (object)[
  1130.                 "id" => $offerId,
  1131.                 "amount" => $amount,
  1132.             ];
  1133.         }
  1135.         if(!$find){
  1136.             return $this->eadResponse([ 
  1137.                 "message" => "Invalid Coupon" 
  1138.             ], ErrorEnum::ACTION_INVALID);
  1139.         }
  1141.         $data = [
  1142.             "total" => $total,
  1143.             "totalDiscount" => $total - $totalWithDiscount,
  1144.             "totalWithDiscount" => $totalWithDiscount,
  1145.             "items" => $items,
  1146.         ];
  1148.         return $this->eadResponse($data);
  1149.     }
  1151.     /**
  1152.      * @Route(
  1153.      *      path          = "/cart",
  1154.      *      name          = "cart",
  1155.      *      methods       = {"GET"}
  1156.      * )
  1157.      */
  1158.     public function cartPage(Request $request) {
  1159.         $cookieName = 'hashcartoff';
  1160.         $hashId = $this->generalService->getCookie($cookieName);
  1162.         $cartRepository = $this->em->getRepository(Cart::class);
  1163.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  1164.         $pcRepository = $this->em->getRepository(ProductCoupon::class);
  1166.         $cartRepository->updateCartsWithProductCouponExpired(
  1167.             ($this->user ? $this->user->getId() : null),
  1168.             $hashId
  1169.         );
  1171.         $couponKey = $request->get('coupon');
  1172.         $this->data['couponKeyValid'] = false;
  1173.         if(!empty($couponKey)){
  1174.             $this->data['couponKeyValid'] = $cartRepository->applyCouponUserCart(
  1175.                 $couponKey, 
  1176.                 $this->user, 
  1177.                 $hashId
  1178.             );
  1179.         }
  1181.         $this->data['formName'] = "formRegisterUserCart";
  1182.         $this->data['carts'] = null;
  1183.         $this->data['cartSubtotal'] = 0;
  1184.         $this->data['cartDisplaySubtotal'] = 0;
  1185.         $this->data['couponKey'] = $couponKey;
  1186.         $this->data['showInfoStep'] = true;
  1188.         $cartRepository = $this->em->getRepository(Cart::class);
  1189.         $customCart = false;
  1190.         $displayTotal = 0;
  1191.         $cartSubtotal = 0;
  1192.         $paymentConfig = $this->configuration->getPaymentConfig();
  1193.         if($this->user){
  1195.             $userCheckoutInfoRepository = $this->em->getRepository(
  1196.                 UserCheckoutInfo::class
  1197.             );
  1198.             $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  1199.                 "user" => $this->user->getId(),
  1200.                 "default" => UserCheckoutInfoEnum::YES,
  1201.                 "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED
  1202.             ]);
  1204.             if($userCheckoutInfo){
  1205.                 $this->data['showInfoStep'] = false;
  1206.             }
  1208.             $userId = $this->user->getId();
  1210.             $carts = $cartRepository->getUserValidCarts($userId);
  1212.             $userCards = $this->em->getRepository(UserCard::class)->getValidUserCard();
  1214.             $customCart = (
  1215.                 $cartRepository->countCustomCheckout($userId) > 0 ? true : false
  1216.             );
  1218.             $hasOnlyCourseInCart = $cartRepository->hasOnlyCourseInCart($userId);
  1220.             $cartSubtotal = $cartRepository->getUserSubTotal($userId);
  1222.             $pagarMeTransaction = $this->generalService->getService(
  1223.                 'PagarMe\\PagarMeTransaction'
  1224.             );
  1225.             $numberUtil = $this->generalService->getUtil('NumberUtil');
  1227.             $methods = [
  1228.                 ProductOfferEnum::CARD,
  1229.                 ProductOfferEnum::BILL,
  1230.                 ProductOfferEnum::PIX,
  1231.             ];
  1233.             $cardOptions = [
  1234.                 ProductOfferEnum::ALL_METHODS,
  1235.                 ProductOfferEnum::CARD,
  1236.                 ProductOfferEnum::CARD_PIX,
  1237.                 ProductOfferEnum::CARD_BILL,
  1238.             ];
  1240.             $pixOptions = [
  1241.                 ProductOfferEnum::ALL_METHODS,
  1242.                 ProductOfferEnum::PIX,
  1243.                 ProductOfferEnum::CARD_PIX,
  1244.                 ProductOfferEnum::BILL_PIX,
  1245.             ];
  1247.             $billOptions = [
  1248.                 ProductOfferEnum::ALL_METHODS,
  1249.                 ProductOfferEnum::BILL,
  1250.                 ProductOfferEnum::CARD_BILL,
  1251.                 ProductOfferEnum::BILL_PIX,
  1252.             ];
  1254.             $getPaymentOption = function(ProductOffer $productOffer) use (
  1255.                 $productOfferRepository, 
  1256.                 $cardOptions, 
  1257.                 $pixOptions, 
  1258.                 $billOptions
  1259.             ){
  1261.                 $billTypeExpire = ProductOfferEnum::BILL_PERIOD;
  1262.                 $billPeriodExpire = 7;
  1263.                 $billDateExpire = null;
  1264.                 $pixTypeExpire = ProductOfferEnum::PIX_PERIOD;
  1265.                 $pixPeriodExpire = 7;
  1266.                 $pixDateExpire = null;
  1267.                 $installmentNumberMax = 12;
  1268.                 $installmentNumberInterest = 1;
  1269.                 $freeInstallments = 1;
  1271.                 $paymentMethodOption = $productOffer->getPaymentMethod();
  1273.                 if(in_array($paymentMethodOption, $cardOptions)){
  1274.                     $installmentNumberMax = $productOffer->getInstallmentNumberMax();
  1275.                     $installmentNumberInterest = $productOffer->getInstallmentNumberInterest();
  1276.                     $freeInstallments = $productOfferRepository->getFreeInstallment(
  1277.                         $productOffer
  1278.                     );
  1279.                 }else if(in_array($paymentMethodOption, $pixOptions)){
  1280.                     $pixTypeExpire = $productOffer->getPixTypeExpire();
  1281.                     $pixPeriodExpire = $productOffer->getPixPeriodExpire();
  1282.                     $pixDateExpire = $productOffer->getPixDateExpire();
  1283.                 }else if(in_array($paymentMethodOption, $billOptions)){
  1284.                     $billTypeExpire = $productOffer->getBillTypeExpire();
  1285.                     $billPeriodExpire = $productOffer->getBillPeriodExpire();
  1286.                     $billDateExpire = $productOffer->getBillDateExpire();
  1287.                 }
  1289.                 return (object)[
  1290.                     "typeCheckout" => $productOffer->getTypeCheckout(),
  1291.                     "saleOption" => $productOffer->getSaleOption(),
  1292.                     "paymentMethod" => $paymentMethodOption,
  1293.                     "billTypeExpire" => $billTypeExpire,
  1294.                     "billPeriodExpire" => $billPeriodExpire,
  1295.                     "billDateExpire" => $billDateExpire,
  1296.                     "pixTypeExpire" => $pixTypeExpire,
  1297.                     "pixPeriodExpire" => $pixPeriodExpire,
  1298.                     "pixDateExpire" => $pixDateExpire,
  1299.                     "installmentNumberMax" => $installmentNumberMax,
  1300.                     "installmentNumberInterest" => $installmentNumberInterest,
  1301.                     "freeInstallments" => $freeInstallments,
  1302.                     "items" => [],
  1303.                 ];
  1304.             };
  1306.             $offerPaymentOptions = [];
  1308.             $internalOptions = [
  1309.                 ProductOfferEnum::INTERNAL_EAD,
  1310.                 ProductOfferEnum::INTERNAL_PAYPAL,
  1311.                 ProductOfferEnum::INTERNAL_PAGSEGURO,
  1312.                 ProductOfferEnum::INTERNAL_MERCADOPAGO,
  1313.             ];
  1315.             foreach ($carts as $key => $cart) {
  1316.                 $productOffer = $cart->getProductOffer();
  1318.                 $offerInternalOptions = json_decode($productOffer->getSaleOptionInternal());
  1319.                 if(is_array($offerInternalOptions)){
  1320.                     $internalOptions = array_intersect(
  1321.                         $internalOptions, 
  1322.                         $offerInternalOptions
  1323.                     );
  1324.                 }
  1326.                 $productOfferCouponTotal = $pcRepository->countPublicCouponByProductOffer(
  1327.                     $productOffer
  1328.                 );
  1330.                 $cart->offerPaymentOptions = null;
  1331.                 if($customCart){
  1332.                     $cart->offerPaymentOptions = $getPaymentOption($productOffer);
  1333.                     $offerPaymentOptions[] = $cart->offerPaymentOptions;
  1334.                 }
  1336.                 $cart->productOfferCouponTotal = $productOfferCouponTotal;
  1337.                 $carts[$key] = $cart;
  1338.             }
  1340.             $customCartSame = true;
  1341.             $optionCustomDefault = null;
  1342.             if(count($offerPaymentOptions) == count($carts)){
  1343.                 foreach ($offerPaymentOptions as $key => $option) {
  1344.                     if(empty($optionCustomDefault)){
  1345.                         $optionCustomDefault = $option;
  1346.                     }
  1348.                     if($optionCustomDefault != $option){
  1349.                         $customCartSame = false;
  1350.                         break;
  1351.                     }
  1352.                 }
  1353.             }
  1355.             $this->data['use_card'] = $this->configuration->get('use_card');
  1356.             $this->data['use_pix'] = $this->configuration->get('use_pix');
  1357.             $this->data['use_bill'] = $this->configuration->get('use_bill');
  1359.             $this->data['use_paypal'] = CartEnum::NO;
  1360.             $this->data['use_pagseguro'] = CartEnum::NO;
  1361.             $this->data['use_mercadopago'] = CartEnum::NO;
  1362.                 
  1363.             if(is_array($internalOptions)){
  1365.                 $this->data['use_paypal'] = (
  1366.                     in_array(ProductOfferEnum::INTERNAL_PAYPAL, $internalOptions) ? 
  1367.                     CartEnum::YES : 
  1368.                     CartEnum::NO
  1369.                 );
  1371.                 $this->data['use_pagseguro'] = (
  1372.                     in_array(ProductOfferEnum::INTERNAL_PAGSEGURO, $internalOptions) ? 
  1373.                     CartEnum::YES : 
  1374.                     CartEnum::NO
  1375.                 );
  1377.                 $this->data['use_mercadopago'] = (
  1378.                     in_array(ProductOfferEnum::INTERNAL_MERCADOPAGO, $internalOptions) ? 
  1379.                     CartEnum::YES : 
  1380.                     CartEnum::NO
  1381.                 );
  1382.             }
  1384.             $this->data['isOneMethod'] = CartEnum::NO;
  1385.             $this->data['isOneMethodType'] = null;
  1387.             if($customCartSame && $optionCustomDefault){
  1388.                 $customCart = false;
  1390.                 $methodsInUse = [];
  1392.                 $this->data['use_card'] = CartEnum::NO;
  1393.                 $this->data['use_pix'] = CartEnum::NO;
  1394.                 $this->data['use_bill'] = CartEnum::NO;
  1396.                 if(in_array($optionCustomDefault->paymentMethod, $cardOptions)){
  1397.                     $this->data['use_card'] = CartEnum::YES;
  1398.                     $methodsInUse[] = CartEnum::PAYMENT_CARD;
  1399.                 }
  1401.                 if(in_array($optionCustomDefault->paymentMethod, $pixOptions)){
  1402.                     $this->data['use_pix'] = CartEnum::YES;
  1403.                     $methodsInUse[] = CartEnum::PAYMENT_PIX;
  1404.                 }
  1406.                 if(in_array($optionCustomDefault->paymentMethod, $billOptions)){
  1407.                     $this->data['use_bill'] = CartEnum::YES;
  1408.                     $methodsInUse[] = CartEnum::PAYMENT_BILL;
  1409.                 }
  1411.                 if(count($methodsInUse) == CartEnum::YES){
  1412.                     $this->data['isOneMethod'] = CartEnum::YES;
  1413.                     $this->data['isOneMethodType'] = end($methodsInUse);
  1414.                 }
  1416.                 $freeInstallments = $optionCustomDefault->installmentNumberInterest;
  1417.                 /*if($paymentConfig->assumeInstallmentInterest == ProductOfferEnum::YES){
  1418.                     $freeInstallments = 12;
  1419.                 }*/
  1421.                 $parcelInfo = $numberUtil->getNumberMaxParcel(
  1422.                     $cartSubtotal * 100,
  1423.                     $optionCustomDefault->installmentNumberMax, 
  1424.                     $freeInstallments, 
  1425.                     ProductOfferEnum::EAD,
  1426.                     ProductOfferEnum::CHECKOUT_CUSTOM
  1427.                 );
  1429.                 $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  1430.                     'amount' => $numberUtil->numberToCents($cartSubtotal),
  1431.                     'free_installments' => $freeInstallments,
  1432.                     'max_installments' => $parcelInfo->maxInstallments,
  1433.                     'interest_rate' => $paymentConfig->installmentInterest
  1434.                 ]);
  1435.                 $this->data['installmentsOptions'] = (array)$installmentsOptions;
  1437.             }else if($customCart){
  1439.                 $steps = [];
  1441.                 $auxOption = [];
  1442.                 foreach ($offerPaymentOptions as $key => $value) {
  1443.                     if(!in_array($value, $auxOption)){
  1444.                         $auxOption[] = $value;
  1445.                     }
  1446.                 }
  1448.                 $offerPaymentOptions = $auxOption;
  1450.                 $defaultObj = (object)[
  1451.                     "amountStep" => 0,
  1452.                     "amountStepCent" => 0,
  1453.                     "items" => [],
  1454.                     "installmentsOptions" => null,
  1455.                     "freeInstallments" => 1,
  1456.                     "useCard" => $this->configuration->get('use_card'),
  1457.                     "usePix" => $this->configuration->get('use_pix'),
  1458.                     "useBill" => $this->configuration->get('use_bill'),
  1459.                     "installmentNumberMax" => $paymentConfig->installmentNumberMax,
  1460.                     "assumeInstallmentInterest" => $paymentConfig->assumeInstallmentInterest,
  1461.                     "installmentNumberInterest" => $paymentConfig->installmentNumberInterest,
  1462.                     "default" => true,
  1463.                 ];
  1465.                 $defaultSubtotalCent = 0;
  1466.                 $defaultInstallmentsOptions = null;
  1468.                 foreach ($carts as $key => $cart) {
  1470.                     $cart->setAble(CartEnum::YES);
  1472.                     $productOffer = $cart->getProductOffer();
  1473.                     if($productOffer->getTypeCheckout() == ProductOfferEnum::CHECKOUT_DEFAULT){
  1474.                         $price = $cart->getPrice() + $cart->getMembershipFee();
  1475.                         $priceCents = $cart->getPrice(true) + $cart->getMembershipFee(true);
  1477.                         $defaultObj->amountStep = $defaultObj->amountStep + $price;
  1478.                         $defaultObj->amountStepCent = $defaultObj->amountStepCent + $priceCents;
  1479.                         $defaultObj->items[] = $cart;
  1480.                     }else{
  1481.                         $indexOptions = array_search(
  1482.                             $cart->offerPaymentOptions,
  1483.                             $offerPaymentOptions
  1484.                         );
  1486.                         if(isset($offerPaymentOptions[$indexOptions])){
  1487.                             $offerPaymentOptions[$indexOptions]->items[] = $cart;
  1488.                         }
  1489.                     }
  1490.                 }
  1492.                 foreach ($offerPaymentOptions as $key => $option) {
  1493.                     if(count($option->items)){
  1494.                         $option->useCard = in_array($option->paymentMethod, $cardOptions);
  1495.                         $option->usePix = in_array($option->paymentMethod, $pixOptions);
  1496.                         $option->useBill = in_array($option->paymentMethod, $billOptions);
  1498.                         $amountOption = 0;
  1499.                         $amountOptionCents = 0;
  1501.                         foreach ($option->items as $keyItem => $item) {
  1502.                             $productOffer = $item->getProductOffer();
  1503.                             $amountOption = $amountOption + $item->getPrice() + $item->getMembershipFee();
  1504.                             $amountOptionCents = $amountOptionCents + $item->getPrice(true) + $item->getMembershipFee(true);
  1505.                         }
  1506.                         
  1507.                         $installmentsOptions = null;
  1508.                         if($option->useCard){
  1509.                             $parcelInfo = $numberUtil->getNumberMaxParcel(
  1510.                                 $amountOptionCents,
  1511.                                 $option->installmentNumberMax,
  1512.                                 $option->freeInstallments,
  1513.                                 $option->saleOption,
  1514.                                 $option->typeCheckout
  1515.                             );
  1517.                             $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  1518.                                 'amount' => $amountOptionCents,
  1519.                                 'free_installments' => $option->freeInstallments,
  1520.                                 'max_installments' => $parcelInfo->maxInstallments,
  1521.                                 'interest_rate' => $paymentConfig->installmentInterest
  1522.                             ]);
  1524.                             $installmentsOptions = (array)$installmentsOptions;
  1525.                         }
  1527.                         $newStep = (object)[
  1528.                             'amountStep' => $amountOption,
  1529.                             'amountStepCent' => $amountOptionCents,
  1530.                             "items" => $option->items,
  1531.                             "installmentsOptions" => $installmentsOptions,
  1532.                             "freeInstallments" => 1,
  1533.                             "useCard" => $option->useCard,
  1534.                             "usePix" => $option->usePix,
  1535.                             "useBill" => $option->useBill,
  1536.                             "installmentNumberMax" => $option->installmentNumberMax,
  1537.                             "assumeInstallmentInterest" => ProductOfferEnum::NO,
  1538.                             "installmentNumberInterest" => $option->installmentNumberInterest,
  1539.                             "default" => false
  1540.                         ];
  1542.                         if($option->useCard){
  1543.                             $this->data['use_card'] = CartEnum::YES;
  1544.                         }
  1546.                         if($option->usePix){
  1547.                             $this->data['use_pix'] = CartEnum::YES;
  1548.                         }
  1550.                         if($option->useBill){
  1551.                             $this->data['use_bill'] = CartEnum::YES;
  1552.                         }
  1554.                         $steps[] = $newStep;
  1555.                     }
  1556.                 }
  1558.                 if(count($defaultObj->items)){
  1559.                     
  1560.                     $defaultObj->freeInstallments = $paymentConfig->installmentNumberInterest;
  1561.                     if($paymentConfig->assumeInstallmentInterest == ProductOfferEnum::YES){
  1562.                         $defaultObj->freeInstallments = 12;
  1563.                     }
  1565.                     $parcelInfo = $numberUtil->getNumberMaxParcel(
  1566.                         $defaultObj->amountStepCent, 
  1567.                         $paymentConfig->installmentNumberMax, 
  1568.                         $defaultObj->freeInstallments, 
  1569.                         ProductOfferEnum::EAD,
  1570.                         ProductOfferEnum::CHECKOUT_DEFAULT
  1571.                     );
  1573.                     $defaultOptions = (array)$pagarMeTransaction->calculateInstallments([
  1574.                         'amount' => $defaultObj->amountStepCent,
  1575.                         'free_installments' => $defaultObj->freeInstallments,
  1576.                         'max_installments' => $parcelInfo->maxInstallments,
  1577.                         'interest_rate' => $paymentConfig->installmentInterest
  1578.                     ]);
  1580.                     $defaultObj->installmentsOptions = $defaultOptions;
  1581.                     
  1582.                     array_unshift($steps, $defaultObj);
  1583.                 }
  1585.                 $this->data['steps'] = $steps;
  1586.             }else{
  1588.                 $freeInstallments = $paymentConfig->installmentNumberInterest;
  1589.                 if($paymentConfig->assumeInstallmentInterest == ProductOfferEnum::YES){
  1590.                     $freeInstallments = 12;
  1591.                 }
  1593.                 $parcelInfo = $numberUtil->getNumberMaxParcel(
  1594.                     $cartSubtotal * 100,
  1595.                     $paymentConfig->installmentNumberMax, 
  1596.                     $freeInstallments, 
  1597.                     ProductOfferEnum::EAD,
  1598.                     ProductOfferEnum::CHECKOUT_DEFAULT
  1599.                 );
  1601.                 $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  1602.                     'amount' => $numberUtil->numberToCents($cartSubtotal),
  1603.                     'free_installments' => $freeInstallments,
  1604.                     'max_installments' => $parcelInfo->maxInstallments,
  1605.                     'interest_rate' => $paymentConfig->installmentInterest
  1606.                 ]);
  1607.                 $this->data['installmentsOptions'] = (array)$installmentsOptions;
  1608.             }
  1610.             $receiverSchoolEad = $this->configuration->getReceiverSchool(
  1611.                 ReceiverEnum::EAD_CHECKOUT
  1612.             );
  1613.             $receiverSchoolPayPal = $this->configuration->getReceiverSchool(
  1614.                 ReceiverEnum::PAYPAL
  1615.             );
  1616.             $receiverSchoolPagSeguro = $this->configuration->getReceiverSchool(
  1617.                 ReceiverEnum::PAGSEGURO
  1618.             );
  1619.             $receiverSchoolMercadoPago = $this->configuration->getReceiverSchool(
  1620.                 ReceiverEnum::MERCADO_PAGO
  1621.             );
  1623.             $displayTotal = $cartRepository->getUserDisplaySubTotal($userId);
  1625.             $this->data['receiverSchoolEad'] = $receiverSchoolEad;
  1626.             $this->data['receiverSchoolPayPal'] = $receiverSchoolPayPal;
  1627.             $this->data['receiverSchoolPagSeguro'] = $receiverSchoolPagSeguro;
  1628.             $this->data['receiverSchoolMercadoPago'] = $receiverSchoolMercadoPago;
  1629.             $this->data['cartSubtotal'] = $cartSubtotal;
  1630.             $this->data['cartDisplaySubtotal'] = $displayTotal;
  1631.             $this->data['userCards'] = $userCards;
  1632.             $this->data['hasOnlyCourseInCart'] = $hasOnlyCourseInCart;
  1633.             $this->data['carts'] = $carts;
  1635.         }else if(!empty($hashId)){
  1637.             $cartInfo = $cartRepository->getHashValidCartsInfo($hashId);
  1638.             $customCart = ($cartInfo->totalCustom > 0 ? true : false);
  1639.             $carts = $cartInfo->data;
  1641.             foreach ($carts as $key => $cart) {
  1643.                 $cart->setAble(CartEnum::YES);
  1645.                 $productOffer = $cart->getProductOffer();
  1646.                 $productOfferCouponTotal = $pcRepository->countPublicCouponByProductOffer(
  1647.                     $productOffer
  1648.                 );
  1650.                 $cart->productOfferCouponTotal = $productOfferCouponTotal;
  1651.                 $carts[$key] = $cart;
  1652.             }
  1654.             $this->data['carts'] = $carts;
  1655.             $this->data['cartSubtotal'] = $cartInfo->totalPrice;
  1656.             $this->data['cartDisplaySubtotal'] = $cartInfo->totalDisplay;
  1657.         }
  1659.         $this->data['keyCaptcha'] = $this->createCaptchaKey($request);
  1661.         $this->data['customCart'] = $customCart;
  1662.         $this->data['cartSubtotalDiff'] = $displayTotal - $cartSubtotal;
  1663.         $this->data['isCart'] = true;
  1664.         $this->data['urlPost'] = $this->generalService->generateUrl("cartCheckoutDefault");
  1665.         $this->data['urlConclusion'] = $this->generalService->generateUrl("cartConclusion");
  1666.         $this->em->flush();
  1668.         if(empty($this->data['carts'])){
  1669.             $this->data['carts'] = [];
  1670.         }
  1672.         return $this->renderEAD('cart/cart.html.twig');
  1673.     }
  1675.     /**
  1676.      * @Route(
  1677.      *      path          = "/cart/indvidual/{poHash}/{pcKey}",
  1678.      *      name          = "cartIndividual",
  1679.      *      methods       = {"GET"},
  1680.      *      defaults      = { "pcKey" = "" }
  1681.      * )
  1682.      */
  1683.     public function cartPageIndvidual(Request $request) {
  1685.         $cartRepository = $this->em->getRepository(Cart::class);
  1686.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  1687.         $productCouponRepository = $this->em->getRepository(ProductCoupon::class);
  1688.         $productRepository = $this->em->getRepository(Product::class);
  1690.         $offerHash = $request->get('poHash');
  1691.         $productOffer = $productOfferRepository->getProductByOfferLink($offerHash);
  1692.         if(!$productOffer){
  1693.             return $this->redirectToRoute('notFound');
  1694.         }
  1696.         $product = $productOffer->getProduct();
  1697.         if($productOffer->getAllowTrial() == ProductOfferEnum::NO){
  1698.             return $this->redirectToRoute('notFound');
  1699.         }
  1701.         $productPage = $productOffer->getProductPage();
  1702.         if(!$productPage){
  1703.             return $this->redirectToRoute('notFound');
  1704.         }
  1706.         if($productOffer->getSaleChannel() == ProductOfferEnum::EXTERNAL){
  1707.             $externalCheckoutLink = $productOffer->getExternalCheckoutLink();
  1708.             return $this->redirect($externalCheckoutLink, 301);
  1709.         }
  1710.         
  1711.         $externalPage = $productPage->getExternalPage();
  1712.         $externalPageLink = $productPage->getExternalPageLink();
  1713.         if($externalPage == ProductEnum::YES && !empty($externalPageLink)){
  1714.             //return $this->redirect($externalPageLink, 301);
  1715.         }
  1716.         
  1717.         $productCoupon = null;
  1718.         $couponKey = $request->get('pcKey');
  1719.         $couponKeyValid = false;
  1720.         
  1721.         if(!empty($couponKey)){
  1722.             $productCoupon = $productCouponRepository->findValidProductCouponByProductOffer(
  1723.                 $couponKey,
  1724.                 $productOffer
  1725.             );
  1727.             if($productCoupon){
  1728.                 $amount = $productOffer->getPriceReal();
  1730.                 if(
  1731.                     $productCouponRepository->checkApplyCoupon($productCoupon, $productOffer)
  1732.                 ){
  1733.                     $amount = $productCouponRepository->applyDiscount(
  1734.                         $productCoupon,
  1735.                         $amount
  1736.                     );
  1738.                     $couponKeyValid = true;
  1739.                 }
  1741.                 if(!empty($amount)){
  1742.                     $productOffer->setPriceRealCopy($amount);
  1743.                 }
  1744.             }
  1745.         }
  1747.         if(
  1748.             $this->user &&
  1749.             (
  1750.                 $product->getType() == ProductEnum::SUBSCRIPTION || 
  1751.                 $productOffer->getAllowRecurrency() == ProductEnum::YES
  1752.             )
  1753.         ){
  1754.             $userSubscriptionRepository = $this->em->getRepository(UserSubscription::class);
  1755.             $userSubscription = $userSubscriptionRepository->findOneBy([
  1756.                 "user" => $this->user->getId(),
  1757.                 "product" => $product->getId(),
  1758.                 "deleted" => UserSubscriptionEnum::ITEM_NO_DELETED,
  1759.             ]);
  1761.             if($userSubscription){
  1762.                 if(
  1763.                     $userSubscription->getStatus() == UserSubscriptionEnum::STATUS_COMPLETED ||
  1764.                     $userSubscription->getStatus() == UserSubscriptionEnum::STATUS_CANCELED
  1765.                 ){
  1766.                     $params = [
  1767.                         "poID" => $productOffer->getId(),
  1768.                         "pcID" => ( $productCoupon ? $productCoupon->getId() : 0 ),
  1769.                     ];
  1771.                     return $this->redirectToRoute('cartAdd', $params);
  1772.                 }
  1774.                 return $this->redirectToRoute('notFound');
  1775.             }
  1776.         }
  1778.         $this->data['couponKey'] = $couponKey;
  1779.         $this->data['couponKeyValid'] = $couponKeyValid;
  1780.         $this->data['showInfoStep'] = true;
  1782.         $customCart = false;
  1783.         $displayTotal = $productOffer->getPriceDisplay();
  1784.         $cartSubtotal = $productOffer->getPriceRealCopy();
  1785.         $hasOnlyCourseInCart = true;
  1786.         $paymentConfig = $this->configuration->getPaymentConfig();
  1787.         $userCards = [];
  1789.         if($this->user){
  1791.             $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  1792.             $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  1793.                 "user" => $this->user->getId(),
  1794.                 "default" => UserCheckoutInfoEnum::YES,
  1795.                 "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED
  1796.             ]);
  1798.             if($userCheckoutInfo){
  1799.                 $this->data['showInfoStep'] = false;
  1800.             }
  1802.             $userCards = $this->em->getRepository(UserCard::class)->getValidUserCard();
  1803.         }
  1805.         $pagarMeTransaction = $this->generalService->getService('PagarMe\\PagarMeTransaction');
  1806.         $numberUtil = $this->generalService->getUtil('NumberUtil');
  1808.         $useCard = $productOfferRepository->produtOfferAllowCard($productOffer);
  1809.         $useBill = $productOfferRepository->produtOfferAllowBill($productOffer);
  1810.         $usePix = $productOfferRepository->produtOfferAllowPix($productOffer);
  1812.         $internalOptions = json_decode($productOffer->getSaleOptionInternal());
  1813.         
  1814.         $this->data['use_paypal'] = CartEnum::NO;
  1815.         $this->data['use_pagseguro'] = CartEnum::NO;
  1816.         $this->data['use_mercadopago'] = CartEnum::NO;
  1818.         if(is_array($internalOptions)){
  1819.             $this->data['use_paypal'] = (
  1820.                 in_array(ProductOfferEnum::INTERNAL_PAYPAL, $internalOptions) ? 
  1821.                 CartEnum::YES : 
  1822.                 CartEnum::NO
  1823.             );
  1825.             $this->data['use_pagseguro'] = (
  1826.                 in_array(ProductOfferEnum::INTERNAL_PAGSEGURO, $internalOptions) ? 
  1827.                 CartEnum::YES : 
  1828.                 CartEnum::NO
  1829.             );
  1831.             $this->data['use_mercadopago'] = (
  1832.                 in_array(ProductOfferEnum::INTERNAL_MERCADOPAGO, $internalOptions) ? 
  1833.                 CartEnum::YES : 
  1834.                 CartEnum::NO
  1835.             );
  1836.         }
  1838.         $hasTrue = [
  1839.             $useCard == CartEnum::YES && $useBill == CartEnum::NO && $usePix == CartEnum::NO,
  1840.             $useCard == CartEnum::NO && $useBill == CartEnum::YES && $usePix == CartEnum::NO,
  1841.             $useCard == CartEnum::NO && $useBill == CartEnum::NO && $usePix == CartEnum::YES,
  1842.         ];
  1844.         $paymentMethod = [
  1845.             CartEnum::PAYMENT_CARD,
  1846.             CartEnum::PAYMENT_BILL,
  1847.             CartEnum::PAYMENT_PIX,
  1848.         ];
  1850.         $this->data['use_card'] = $useCard;
  1851.         $this->data['use_bill'] = $useBill;
  1852.         $this->data['use_pix'] = $usePix;
  1854.         $key = array_search(true, $hasTrue);
  1856.         $this->data['isOneMethod'] = (!empty($key) ? CartEnum::YES : CartEnum::NO);
  1857.         $this->data['isOneMethodType'] = (!empty($key) ? $paymentMethod[$key] : null);
  1859.         $freeInstallments = $productOfferRepository->getFreeInstallment($productOffer);
  1860.         $maxInstallments = $productOfferRepository->getInstallmentNumberMax($productOffer);
  1862.         $parcelInfo = $numberUtil->getNumberMaxParcel(
  1863.             $cartSubtotal * 100,
  1864.             $maxInstallments, 
  1865.             $freeInstallments, 
  1866.             ProductOfferEnum::EAD,
  1867.             $productOffer->getTypeCheckout()
  1868.         );
  1870.         $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  1871.             'amount' => $numberUtil->numberToCents($cartSubtotal),
  1872.             'free_installments' => $freeInstallments,
  1873.             'max_installments' => $parcelInfo->maxInstallments,
  1874.             'interest_rate' => $paymentConfig->installmentInterest
  1875.         ]);
  1877.         $this->data['installmentsOptions'] = (array)$installmentsOptions;
  1879.         $receiverSchoolEad = $this->configuration->getReceiverSchool(
  1880.             ReceiverEnum::EAD_CHECKOUT
  1881.         );
  1882.         $receiverSchoolPayPal = $this->configuration->getReceiverSchool(
  1883.             ReceiverEnum::PAYPAL
  1884.         );
  1885.         $receiverSchoolPagSeguro = $this->configuration->getReceiverSchool(
  1886.             ReceiverEnum::PAGSEGURO
  1887.         );
  1888.         $receiverSchoolMercadoPago = $this->configuration->getReceiverSchool(
  1889.             ReceiverEnum::MERCADO_PAGO
  1890.         );
  1892.         $this->data['receiverSchoolEad'] = $receiverSchoolEad;
  1893.         $this->data['receiverSchoolPayPal'] = $receiverSchoolPayPal;
  1894.         $this->data['receiverSchoolPagSeguro'] = $receiverSchoolPagSeguro;
  1895.         $this->data['receiverSchoolMercadoPago'] = $receiverSchoolMercadoPago;
  1897.         $this->data['cartSubtotal'] = CartEnum::NO;//$cartSubtotal;
  1898.         $this->data['cartDisplaySubtotal'] = CartEnum::NO;//$displayTotal;
  1899.         $this->data['cartSubtotalDiff'] = CartEnum::NO;//$displayTotal - $cartSubtotal;
  1901.         $this->data['userCards'] = $userCards;
  1902.         $this->data['hasOnlyCourseInCart'] = $hasOnlyCourseInCart;
  1904.         $cart = new Cart();
  1906.         $hashIdentify = $this->generalService->getCookieHashIdentify();
  1907.         
  1908.         $cart->setProductOffer($productOffer);
  1909.         $cart->setProduct($product);
  1911.         if($productCoupon && $couponKeyValid){
  1912.             $cart->setProductCoupon($productCoupon);
  1913.         }
  1915.         if($this->user){
  1916.             $cart->setUser($this->user);
  1917.             $cart->setHashIdentify($this->user->getHashIdentify());
  1918.         }else if(!empty($hashIdentify)){
  1919.             $cart->setHashIdentify($hashIdentify);
  1920.         }
  1922.         $cart->setPrice($productOffer->getPriceRealCopy());
  1924.         if(
  1925.             $product->getType() == ProductEnum::SUBSCRIPTION || 
  1926.             $productOffer->getAllowRecurrency() == ProductEnum::YES
  1927.         ){
  1928.             $cart->setMembershipFee($productOffer->getMembershipFeeCopy());
  1929.         }
  1931.         $cart->setProductType($product->getType());
  1933.         $productOfferCouponTotal = $productCouponRepository->countPublicCouponByProductOffer(
  1934.             $productOffer
  1935.         );
  1937.         $cart->offerPaymentOptions = null;
  1938.         $cart->productOfferCouponTotal = $productOfferCouponTotal;
  1940.         $this->data['carts'] = [
  1941.             $cart
  1942.         ];
  1944.         $this->data['keyCaptcha'] = $this->createCaptchaKey($request);
  1945.         $this->data['customCart'] = $customCart;
  1946.         $this->data['isCart'] = false;
  1947.         $this->data['urlPost'] = $this->generalService->generateUrl(
  1948.             "cartCheckoutPlanTrial", 
  1949.             [
  1950.                 "poID" => $productOffer->getId(),
  1951.                 "pcID" => ($productCoupon ? $productCoupon->getId() : null),
  1952.             ]
  1953.         );
  1955.         $this->data['urlRedirect'] = $this->generalService->generateUrl(
  1956.             "cartIndividual", 
  1957.             [
  1958.                 "poHash" => $offerHash,
  1959.                 "pcKey" => ($couponKey ? $couponKey : null),
  1960.             ]
  1961.         ) . "#cart-step-info";
  1963.         $this->data['urlConclusion'] = $this->generalService->generateUrl("cartConclusion");
  1965.         $this->em->flush();
  1967.         if(empty($this->data['carts'])){
  1968.             $this->data['carts'] = [];
  1969.         }
  1971.         return $this->renderEAD('cart/cart.html.twig');
  1972.     }
  1974.     /**
  1975.      * @Route(
  1976.      *      path    = "/admin/cart/user/valid",
  1977.      *      name    = "getUserValidCarts",
  1978.      *      methods = {"GET"}
  1979.      * )
  1980.      */
  1981.     public function getUserValidCarts(Request $request){
  1982.         if (!$this->user) {
  1983.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  1984.         }
  1986.         $cartRepository = $this->em->getRepository(Cart::class);
  1987.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  1989.         $userId = $this->user->getId();
  1991.         $carts = $cartRepository->getUserValidCarts($userId);
  1993.         $paymentConfig = $this->configuration->getPaymentConfig();
  1995.         $fileService = $this->generalService->getService('FileService');
  1996.         $data = [];
  1998.         foreach ($carts as $key => $cart) {
  2000.             $productOffer = $cart->getProductOffer();
  2001.             $billDateExpire = $productOfferRepository->getDateExpireBill($productOffer);
  2002.             $pixDateExpire = $productOfferRepository->getDateExpirePix($productOffer);
  2004.             $photo = $fileService->getFilePathComplete(
  2005.                 $cart->getProductOffer()->getProductPage()->getPhoto(),
  2006.                 ProductEnum::PATH_PRODUCT_PHOTO,
  2007.                 true,
  2008.                 false,
  2009.                 'product-photo',
  2010.                 true
  2011.             );
  2013.             $onErrorPhoto = $fileService->getFilePathComplete(
  2014.                 $cart->getProductOffer()->getProductPage()->getPhoto(),
  2015.                 ProductEnum::PATH_PRODUCT_PHOTO,
  2016.                 true,
  2017.                 false,
  2018.                 'product-photo',
  2019.                 false
  2020.             );
  2022.             $price = (float)($cart->getPrice() + $cart->getMembershipFee());
  2023.             $membershipFee = (float)$productOffer->getMembershipFee();
  2024.             $priceReal = (float)($productOffer->getPriceReal() + $membershipFee);
  2025.             $priceDiscount = (float)$price - $priceReal;
  2026.             $priceDisplay = (float)$productOffer->getPriceDisplay();
  2027.             
  2028.             if(!empty($priceDisplay)){
  2029.                 $priceDisplay = (float)($priceDisplay + $membershipFee);
  2030.                 $priceDiscount = $price - $priceDisplay;
  2031.             }
  2033.             $recurrency = (
  2034.                 $cart->getProduct()->getType() == ProductEnum::SUBSCRIPTION ||
  2035.                 $productOffer->getAllowRecurrency() == ProductEnum::YES
  2036.             )? true : false;
  2038.             $item = (object)[
  2039.                 "id" => $cart->getId(),
  2040.                 "title" => $cart->getProduct()->getTitle(),
  2041.                 "photo" => $photo,
  2042.                 "onErrorPhoto" => $onErrorPhoto,
  2043.                 "able" => ($cart->getAble() == CartEnum::YES),
  2044.                 "priceOrigin" => (float)$cart->getPrice(),
  2045.                 "membershipFeeOrigin" => (float)$productOffer->getMembershipFee(),
  2046.                 "membershipFeeReal" => (float)$cart->getMembershipFee(),
  2047.                 "priceReal" => $priceReal,
  2048.                 "price" => (float)$price,
  2049.                 "priceReal" => $priceReal,
  2050.                 "priceDisplay" => (float)$priceDisplay,
  2051.                 "priceDiscount" => (float)$priceDiscount,
  2052.                 "couponKey" => (
  2053.                     $cart->getProductCoupon() ? $cart->getProductCoupon()->getKey() : null
  2054.                 ),
  2055.                 "couponMembershipFee" => (int)(
  2056.                     $cart->getProductCoupon() ?
  2057.                     $cart->getProductCoupon()->getApplyMembershipFee() : 
  2058.                     ProductEnum::NO
  2059.                 ),
  2060.                 "billDateExpire" => $billDateExpire,
  2061.                 "pixDateExpire" => $pixDateExpire,
  2062.                 "interestFee" => $paymentConfig->installmentInterest,
  2063.                 "currencySymbol" => $productOffer->getCurrencySymbol(),
  2064.                 "paymentCycle" => $productOffer->getPlanCycle(),
  2065.                 "recurrency" => $recurrency,
  2066.             ];
  2068.             $data[] = $item;
  2069.         }
  2071.         return $this->eadResponse($data);
  2072.     }
  2074.     /**
  2075.      * @Route(
  2076.      *      path          = "/admin/cart/change/status",
  2077.      *      name          = "cartChangeStatus",
  2078.      *      methods       = {"PUT"}
  2079.      * )
  2080.      */
  2081.     public function updateCartStatus(Request $request){
  2082.         if (!$this->user) {
  2083.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  2084.         }
  2086.         $this->requestUtil->setRequest($request)->setData();
  2088.         $cartId = $this->requestUtil->getField('cart');
  2089.         $able = $this->requestUtil->getField('able');
  2091.         $cartRepository = $this->em->getRepository(Cart::class);
  2092.         $userId = $this->user->getId();
  2094.         $cart = $cartRepository->findOneBy([
  2095.             "id" => $cartId,
  2096.             "user" => $userId,
  2097.             "deleted" => CartEnum::ITEM_NO_DELETED,
  2098.         ]);
  2100.         if(!$cart){
  2101.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  2102.         }
  2104.         $cart->setAble($able);
  2106.         $this->em->flush();
  2108.         return $this->eadResponse([ "success" => 1 ]);
  2109.     }
  2112.     /**
  2113.      * @Route(
  2114.      *      path          = "/cart/checkout/paypal",
  2115.      *      name          = "cartCheckoutPaypal",
  2116.      *      methods       = {"GET"}
  2117.      * )
  2118.      */
  2119.     public function checkoutPayPal(Request $request){
  2120.         $this->checkUserSession($request);
  2122.         $receiverSchool = $this->configuration->getReceiverSchool(ReceiverEnum::PAYPAL);
  2123.         if(!$receiverSchool){
  2124.             return $this->redirectToRoute('notFound');
  2125.         }
  2127.         $this->requestUtil->setRequest($request)->setData();
  2129.         $cartRepository = $this->em->getRepository(Cart::class);
  2131.         $hasOnlyCourseInCart = $cartRepository->hasOnlyCourseInCart($this->user->getId());
  2132.         if(!$hasOnlyCourseInCart){
  2133.             return $this->redirectToRoute('notFound');
  2134.         }
  2136.         $currencyCode = $this->configuration->get('currency_code');
  2137.         $userCheckoutInfoId = $this->requestUtil->getField('userCheckoutInfoId');
  2139.         $transactionData = [
  2140.             "cmd" => "_cart",
  2141.             "business" => $receiverSchool->getEmail(),
  2142.             "upload" => 1,
  2143.             "currency_code" => ( $currencyCode ? $currencyCode : "BRL" ),
  2144.             "charset" => "UTF-8",
  2145.         ];
  2147.         $dataCustom = [];
  2149.         $carts = $cartRepository->getUserValidCarts($this->user->getId());
  2150.         if(empty($carts)){
  2151.             return $this->redirectToRoute('notFound');
  2152.         }
  2154.         foreach ($carts as $key => $cart) {
  2155.             $index = $key + 1;
  2157.             $product = $cart->getProduct();
  2158.             $productOffer = $cart->getProductOffer();
  2160.             $title = $this->stringUtil->shortTextClean($product->getTitle(), 30);
  2161.             $title = $this->stringUtil->cleanString2($title);
  2163.             $transactionData["item_number_{$index}"] = $product->getId();
  2164.             $transactionData["item_name_{$index}"] = $title;
  2165.             $transactionData["amount_{$index}"] = $cart->getPrice();
  2166.             $transactionData["quantity_{$index}"] = 1;
  2168.             $dataCustom["cart_{$index}"] = $cart->getId();
  2169.             $dataCustom["amount_{$index}"] = $cart->getPrice();
  2170.             $dataCustom["offer_{$index}"] = $productOffer->getId();
  2171.             
  2172.             $productCoupon = $cart->getProductCoupon();
  2173.             if($productCoupon){
  2174.                 $dataCustom["coupon_{$index}"] = $productCoupon->getId();
  2175.             }
  2176.         }
  2178.         $dataCustom["new"] = CartEnum::YES;
  2179.         $dataCustom["userId"] = $this->user->getId();
  2180.         $dataCustom["numberItens"] = count($carts);
  2181.         $dataCustom["userCheckoutInfoId"] = $userCheckoutInfoId;
  2183.         $transactionData["custom"] = json_encode($dataCustom);
  2184.         $transactionData["return"] = "https://{$this->eadDomain}/resume/";
  2185.         $transactionData["notify_url"] = "https://{$this->eadDomain}/paypal/";
  2187.         $transactionData = http_build_query($transactionData);
  2189.         $payPal = $this->generalService->getService('PayPal\\PayPal');
  2190.         $url = "{$payPal->getPayPalAddress()}?{$transactionData}";
  2192.         return $this->redirect($url, 301);
  2193.     }
  2195.     /**
  2196.      * @Route(
  2197.      *      path          = "/cart/checkout/pagseguro",
  2198.      *      name          = "cartCheckoutPagseguro",
  2199.      *      methods       = {"GET"}
  2200.      * )
  2201.      */
  2202.     public function checkoutPagSeguro(Request $request){
  2203.         $this->checkUserSession($request);
  2205.         $receiverSchool = $this->configuration->getReceiverSchool(ReceiverEnum::PAGSEGURO);
  2206.         if(!$receiverSchool){
  2207.             return $this->redirectToRoute('notFound');
  2208.         }
  2210.         $this->requestUtil->setRequest($request)->setData();
  2212.         $cartRepository = $this->em->getRepository(Cart::class);
  2214.         $hasOnlyCourseInCart = $cartRepository->hasOnlyCourseInCart($this->user->getId());
  2215.         if(!$hasOnlyCourseInCart){
  2216.             return $this->redirectToRoute('notFound');
  2217.         }
  2219.         $userCheckoutInfoId = $this->requestUtil->getField('userCheckoutInfoId');
  2221.         $transactionData = [
  2222.             "cmd" => "_cart",
  2223.             "business" => $receiverSchool->getEmail(),
  2224.             //"upload" => 1,
  2225.             "currency" => "BRL",
  2226.             "charset" => "ISO-8859-1",
  2227.         ];
  2229.         $dataCustom = [];
  2231.         $carts = $cartRepository->getUserValidCarts($this->user->getId());
  2232.         if(empty($carts)){
  2233.             return $this->redirectToRoute('notFound');
  2234.         }
  2236.         foreach ($carts as $key => $cart) {
  2237.             $index = $key + 1;
  2239.             $product = $cart->getProduct();
  2240.             $productOffer = $cart->getProductOffer();
  2242.             $title = $this->stringUtil->shortTextClean($product->getTitle(), 30);
  2243.             $title = $this->stringUtil->cleanString2($title);
  2245.             $transactionData["itemId{$index}"] = $productOffer->getId();
  2246.             $transactionData["itemDescription{$index}"] = $title;
  2247.             $transactionData["itemAmount{$index}"] = $cart->getPrice();
  2248.             $transactionData["itemQuantity{$index}"] = 1;
  2250.             $dataCustom["cart_{$index}"] = $cart->getId();
  2251.             $dataCustom["amount_{$index}"] = $cart->getPrice();
  2252.             $dataCustom["offer_{$index}"] = $productOffer->getId();
  2253.             
  2254.             $productCoupon = $cart->getProductCoupon();
  2255.             if($productCoupon){
  2256.                 $dataCustom["coupon_{$index}"] = $productCoupon->getId();
  2257.             }
  2258.         }
  2260.         $dataCustom["userId"] = $this->user->getId();
  2261.         $dataCustom["numberItens"] = count($carts);
  2262.         $dataCustom["userCheckoutInfoId"] = $userCheckoutInfoId;
  2264.         $transactionData["reference"] = $this->user->getId();
  2265.         $transactionData["custom"] = json_encode($dataCustom);
  2266.         $transactionData["redirectURL"] = "https://{$this->eadDomain}/resume/";
  2267.         $transactionData["notificationURL"] = "https://{$this->eadDomain}/pagseguro/";
  2269.         $pagSeguro = $this->generalService->getService('PagSeguro\\PagSeguro');
  2270.         $url = $pagSeguro->getCheckoutPagseguro($transactionData);
  2272.         return $this->redirect($url, 301);
  2273.     }
  2275.     /**
  2276.      * @Route(
  2277.      *      path          = "/cart/checkout/mercadopago",
  2278.      *      name          = "cartCheckoutMercadopago",
  2279.      *      methods       = {"GET"}
  2280.      * )
  2281.      */
  2282.     public function checkoutMercadopago(Request $request) {
  2283.         $this->checkUserSession($request);
  2285.         $receiverSchool = $this->configuration->getReceiverSchool(
  2286.             ReceiverEnum::MERCADO_PAGO
  2287.         );
  2289.         if(!$receiverSchool){
  2290.             return $this->redirectToRoute('notFound');
  2291.         }
  2293.         $this->requestUtil->setRequest($request)->setData();
  2295.         $cartRepository = $this->em->getRepository(Cart::class);
  2297.         $hasOnlyCourseInCart = $cartRepository->hasOnlyCourseInCart($this->user->getId());
  2298.         if(!$hasOnlyCourseInCart){
  2299.             return $this->redirectToRoute('notFound');
  2300.         }
  2302.         $carts = $cartRepository->getUserValidCarts($this->user->getId());
  2303.         if(empty($carts)){
  2304.             return $this->redirectToRoute('notFound');
  2305.         }
  2307.         foreach ($carts as $key => $cart) {
  2308.             $product = $cart->getProduct();
  2309.             $productOffer = $cart->getProductOffer();
  2311.             $title = $this->stringUtil->shortTextClean($product->getTitle(), 30);
  2312.             $title = $this->stringUtil->cleanString2($title);
  2314.             $description = $this->stringUtil->shortTextClean($product->getDescription(), 30);
  2315.             $description = $this->stringUtil->cleanString2($description);
  2317.             $items[] = [
  2318.                 "id" => $productOffer->getId(),
  2319.                 "title" => $title,
  2320.                 "description" => $description,
  2321.                 "quantity" => 1,
  2322.                 "unit_price" => $cart->getPrice()
  2323.             ];
  2324.         }
  2326.         $transactionData["items"] = $items;
  2327.         $transactionData["back_urls"] = [
  2328.             "success" => "https://{$this->eadDomain}/resume/",
  2329.             "failure" => "https://{$this->eadDomain}/cart#mercadopago/", 
  2330.             "pending" => "https://{$this->eadDomain}/cart#mercadopago/"
  2331.         ];
  2332.         $transactionData["external_reference"] = $this->user->getId();
  2334.         $transactionData["notification_url"] = "https://{$this->eadDomain}/mercadopago?debug=1";
  2336.         $data = json_encode($transactionData);
  2338.         $mercadoPago = $this->generalService->getService('MercadoPago\\MercadoPago');
  2339.         $url = $mercadoPago->getCheckoutMercadoPago($data);
  2341.         return $this->redirect($url, 301);
  2342.     }
  2344.     /**
  2345.      * @Route(
  2346.      *      path          = "/admin/cart/checkout/charge",
  2347.      *      name          = "cartCheckoutCharge",
  2348.      *      methods       = {"POST"}
  2349.      * )
  2350.      */
  2351.     public function checkoutCharge(Request $request){
  2352.         $receiverSchool = $this->configuration->getReceiverSchool(
  2353.             ReceiverEnum::EAD_CHECKOUT
  2354.         );
  2355.         if(!$receiverSchool){
  2356.             return $this->eadResponse(
  2357.                 [ "message" => "Receiver not found "],
  2358.                 ErrorEnum::ACTION_INVALID
  2359.             );
  2360.         }
  2362.         $transactionService = $this->generalService->getService(
  2363.             'Transaction\\TransactionService'
  2364.         );
  2365.         $pagarMeTransaction = $this->generalService->getService(
  2366.             'PagarMe\\PagarMeTransaction'
  2367.         );
  2369.         $this->requestUtil->setRequest($request)->setData();
  2371.         $productChargeId = (int)$this->requestUtil->getField('productChargeId');
  2372.         $userCheckoutInfoId = (int)$this->requestUtil->getField('userCheckoutInfoId');
  2373.         $paymentMethod = (int)$this->requestUtil->getField('paymentMethod');
  2374.         $installments = (int)$this->requestUtil->getField('installments');
  2375.         $debug = (int)$request->get('debug');
  2377.         $productCharge = $this->em->getRepository(ProductCharge::class)->findOneBy([
  2378.             "id" => $productChargeId,
  2379.             "deleted" => ProductChargeEnum::ITEM_NO_DELETED
  2380.         ]);
  2381.         
  2382.         if (!$productCharge) {
  2383.             return $this->eadResponse(
  2384.                 [ "message" => "Charge not found "], 
  2385.                 ErrorEnum::ACTION_INVALID
  2386.             );
  2387.         }
  2389.         if ($productCharge->getPublish() == ProductChargeEnum::NO) {
  2390.             return $this->eadResponse(
  2391.                 [ "message" => "Charge is not publish "], 
  2392.                 ErrorEnum::ACTION_INVALID
  2393.             );
  2394.         }
  2396.         $userCardRepository = $this->em->getRepository(UserCard::class);
  2397.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  2399.         $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  2400.             "id" => $userCheckoutInfoId,
  2401.             "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED,
  2402.         ]);
  2404.         if(!$userCheckoutInfo){
  2405.             return $this->eadResponse([ 
  2406.                 "message" => "UserCheckoutInfo is empty"
  2407.             ], ErrorEnum::ACTION_INVALID);
  2408.         }
  2410.         $paymentConfig = $this->configuration->getPaymentConfig();
  2412.         $product = $productCharge->getProduct();
  2413.         $productOffer = $productCharge->getProductOffer();
  2415.         $items = [
  2416.             (object)[
  2417.                 "courseId" => null,
  2418.                 "productOfferId" => $productOffer->getId(),
  2419.                 "productId" => $product->getId(),
  2420.                 "amount" => $productCharge->getAmount(),
  2421.                 "cartId" => null,
  2422.                 "productCouponId" => null,
  2423.             ]
  2424.         ];
  2426.         $userCard = null;
  2427.         $amount = $productCharge->getAmount(true);
  2428.         $dateExpire = $productCharge->getDateExpire();
  2430.         if(empty($paymentMethod)){
  2431.             return $this->eadResponse([ 'paymentMethod' ], ErrorEnum::FIELD_EMPTY);
  2432.         }
  2434.         if($paymentMethod == CartEnum::PAYMENT_CARD){ // get user card
  2435.             if(empty($installments)){
  2436.                 return $this->eadResponse([ 'installments' ], ErrorEnum::FIELD_EMPTY);
  2437.             }
  2439.             $userCardId = $this->requestUtil->getField('userCardId');
  2440.             if(empty($userCardId)){
  2441.                 return $this->eadResponse([ 'userCardId' ], ErrorEnum::FIELD_EMPTY);
  2442.             }
  2444.             if($userCardId > 0){
  2445.                 $userCard = $userCardRepository->findOneBy([
  2446.                     "id" => $userCardId,
  2447.                     "user" => $this->user->getId(),
  2448.                     "deleted" => CartEnum::ITEM_NO_DELETED
  2449.                 ]);
  2450.             }
  2451.         }
  2453.         if($paymentMethod == CartEnum::PAYMENT_CARD && !$userCard){
  2454.             return $this->eadResponse(
  2455.                 [ "message" => "Card not found "], 
  2456.                 ErrorEnum::ACTION_INVALID
  2457.             );
  2458.         }
  2460.         $freeInstallments = $productCharge->getInstallmentNumberInterest();
  2461.         if($paymentMethod == CartEnum::PAYMENT_CARD){
  2462.             $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  2463.                 'amount' => $amount,
  2464.                 'free_installments' => $freeInstallments,
  2465.                 'max_installments' => $installments,
  2466.                 'interest_rate' => $paymentConfig->installmentInterest
  2467.             ]);
  2469.             $amount = $installmentsOptions->{$installments}->amount;
  2470.         }
  2472.         if($amount < $this->configuration->getMinValueProduct()){
  2473.             return $this->eadResponse([ "message" => "Amount invalid "], ErrorEnum::ACTION_INVALID);
  2474.         }
  2476.         if($this->user && $this->user->getId() == CartEnum::YES){
  2477.             $transactionService->setDebug(true);
  2478.         }
  2480.         if($debug == CartEnum::YES){
  2481.             $transactionService->setDebug(true);
  2482.         }
  2484.         $transactionOrigin = TransactionEnum::ORIGIN_CHARGE;
  2486.         $data = $transactionService->createTransactionEAD(
  2487.             $productCharge->getUser(),
  2488.             $userCheckoutInfo,
  2489.             $amount,
  2490.             $paymentMethod,
  2491.             $installments,
  2492.             $items,
  2493.             $userCard,
  2494.             $dateExpire,
  2495.             null,
  2496.             $productChargeId,
  2497.             (!empty($freeInstallments) ? (int)$freeInstallments : null),
  2498.             $transactionOrigin
  2499.         );
  2501.         if(!empty($data['errorMessage'])){
  2503.             $productCharge->setErrorMessage($data['errorMessage']);
  2504.             $this->em->flush();
  2506.             return $this->eadResponse([ 
  2507.                 "message" => $data['errorMessage']
  2508.             ], ErrorEnum::ACTION_INVALID);
  2509.         }
  2511.         return $this->eadResponse($data);
  2512.     }
  2514.     /**
  2515.      * @Route(
  2516.      *      path          = "/cart/checkout/clean",
  2517.      *      name          = "checkoutClean",
  2518.      *      methods       = {"POST"}
  2519.      * )
  2520.      */
  2521.     public function checkoutClean(Request $request){
  2523.         $pixelService = $this->generalService->getService('Marketing\\PixelService');
  2524.         $pixelService->sendConversion('InitiateCheckout');
  2526.         $receiverSchool = $this->configuration->getReceiverSchool(
  2527.             ReceiverEnum::EAD_CHECKOUT
  2528.         );
  2529.         if(!$receiverSchool){
  2530.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  2531.         }
  2533.         $transactionService = $this->generalService->getService(
  2534.             'Transaction\\TransactionService'
  2535.         );
  2536.         $pagarMeTransaction = $this->generalService->getService(
  2537.             'PagarMe\\PagarMeTransaction'
  2538.         );
  2540.         $this->requestUtil->setRequest($request)->setData();
  2542.         $data = $this->requestUtil->getData();
  2544.         $dataUtml = [
  2545.             "utm_source" => $request->get('utm_source'),
  2546.             "utm_medium" => $request->get('utm_medium'),
  2547.             "utm_campaign" => $request->get('utm_campaign'),
  2548.             "utm_term" => $request->get('utm_term'),
  2549.             "utm_content" => $request->get('utm_content'),
  2550.         ];
  2552.         $utmsUrl = json_encode($dataUtml);
  2554.         $cartRepository = $this->em->getRepository(Cart::class);
  2555.         $courseRepository = $this->em->getRepository(Course::class);
  2556.         $userCardRepository = $this->em->getRepository(UserCard::class);
  2557.         $userRepository = $this->em->getRepository(User::class);
  2558.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  2559.         $poRepository = $this->em->getRepository(ProductOffer::class);
  2560.         $pcRepository = $this->em->getRepository(ProductCoupon::class);
  2562.         //user
  2563.         $name = $this->requestUtil->getField('name');
  2564.         $email = $this->requestUtil->getField('email');
  2565.         $document = $this->requestUtil->getField('document');
  2566.         $phone = $this->requestUtil->getField('phone');
  2567.         $zipCode = $this->requestUtil->getField('zipCode');
  2568.         $stateId = (int)$this->requestUtil->getField('state');
  2569.         $cityId = (int)$this->requestUtil->getField('city');
  2570.         $address = $this->requestUtil->getField('address');
  2571.         $addressNeighborhood = $this->requestUtil->getField('addressNeighborhood');
  2572.         $addressNumber = $this->requestUtil->getField('addressNumber');
  2573.         $addressComplement = $this->requestUtil->getField('addressComplement');
  2574.         $foreigner = (int)$this->requestUtil->getField('foreigner');
  2576.         //userCheckoutInfo
  2577.         $checkoutName = $this->requestUtil->getField('checkout-name');
  2578.         $checkoutEmail = $this->requestUtil->getField('checkout-email');
  2579.         $checkoutDocument = $this->requestUtil->getField('checkout-document');
  2580.         $checkoutPhone = $this->requestUtil->getField('checkout-phone');
  2581.         $checkoutZipCode = $this->requestUtil->getField('checkout-zipCode');
  2582.         $checkoutStateId = (int)$this->requestUtil->getField('checkout-state');
  2583.         $checkoutCityId = (int)$this->requestUtil->getField('checkout-city');
  2584.         $checkoutAddress = $this->requestUtil->getField('checkout-address');
  2585.         $checkoutAddressNeighborhood = $this->requestUtil->getField(
  2586.             'checkout-addressNeighborhood'
  2587.         );
  2588.         $checkoutAddressNumber = $this->requestUtil->getField('checkout-addressNumber');
  2589.         $checkoutAddressComplement = $this->requestUtil->getField(
  2590.             'checkout-addressComplement'
  2591.         );
  2592.         $checkoutNotify = (int)$this->requestUtil->getField('checkout-notify');
  2593.         $checkoutForeigner = (int)$this->requestUtil->getField('checkout-foreigner');
  2594.         
  2595.         $checkoutNew = (int)$this->requestUtil->getField('checkout-new');
  2596.         $cardNew = (int)$this->requestUtil->getField('card-new');
  2597.         $userNew = (int)$this->requestUtil->getField('user-new');
  2598.         $installments = (int)$this->requestUtil->getField('installments');
  2599.         $paymentMethod = (int)$this->requestUtil->getField('payment-method');
  2600.         $cardId = (int)$this->requestUtil->getField('card-id');
  2601.         $cardHash = $this->requestUtil->getField('card-hash');
  2603.         $userId = (int)$this->requestUtil->getField('user-id');
  2604.         $userCheckoutInfoId = (int)$this->requestUtil->getField('checkout-id');
  2606.         $offerDefaultId = (int)$this->requestUtil->getField('offer-default');
  2607.         $offers = $this->requestUtil->getField('added-ids');
  2608.         $offers = explode(",", $offers);
  2610.         if(empty($offers)){
  2611.             return $this->eadResponse([ 'added-ids' ], ErrorEnum::FIELD_EMPTY);
  2612.         }
  2614.         if(empty($paymentMethod)){
  2615.             return $this->eadResponse([ 'paymentMethod' ], ErrorEnum::FIELD_EMPTY);
  2616.         }
  2618.         $couponKey = $this->requestUtil->getField('couponKey');
  2620.         $user = null;
  2621.         $userCheckoutInfo = null;
  2622.         $userCard = null;
  2623.         
  2624.         if(!empty($userId)){
  2625.             $user = $userRepository->findOneBy([
  2626.                 "id" => $userId,
  2627.             ]);
  2629.             //update user data ???
  2631.             
  2632.         }else if($userNew == UserEnum::YES){
  2634.             $pixelService = $this->generalService->getService('Marketing\\PixelService');
  2635.             $pixelService->sendConversion('Lead');
  2637.             //check user exist
  2638.             $user = $userRepository->findOneBy([
  2639.                 "email" => $email,
  2640.             ], [ "id" => "DESC" ]);
  2642.             if(!$user || ($user && $user->isDeleted())){
  2644.                 $dataUser = [
  2645.                     "name" => $name,
  2646.                     "email" => $email,
  2647.                     "password" => null,
  2648.                     "phone" => $phone,
  2649.                     "notify" => UserEnum::YES,
  2650.                     "invited" => UserEnum::YES
  2651.                 ];
  2653.                 $userDTO = new UserDTO($dataUser);
  2654.                 $data = $userRepository->newUser($userDTO, UserEnum::YES);
  2656.                 if($data->errors){
  2657.                     return $this->eadResponse($data->errors, ErrorEnum::FIELD_EMPTY);
  2658.                 }
  2660.                 $user = $data->user;
  2661.             }
  2663.             $user->setDocument($document);
  2664.             $user->setPhone($phone);
  2665.             $user->setZipCode($zipCode);
  2667.             if($foreigner == UserCheckoutInfoEnum::NO){
  2669.                 $country = $this->em->getRepository(Country::class)->findOneBy([ 
  2670.                     "deleted" => GeoDataEnum::ITEM_NO_DELETED ,
  2671.                     "id" => GeoDataEnum::YES,
  2672.                 ]);
  2674.                 if($country){
  2675.                     $user->setCountry($country);
  2676.                 }
  2677.             }
  2679.             if(!empty($stateId)){
  2680.                 $state = $this->em->getRepository(State::class)->findOneBy([
  2681.                     "id" => $stateId,
  2682.                     "deleted" => UserEnum::ITEM_NO_DELETED
  2683.                 ]);
  2685.                 if($state){
  2686.                     $user->setState($state);
  2687.                 }
  2688.             }
  2690.             if(!empty($cityId)){
  2691.                 $city = $this->em->getRepository(City::class)->findOneBy([
  2692.                     "id" => $cityId,
  2693.                     "deleted" => UserEnum::ITEM_NO_DELETED
  2694.                 ]);
  2696.                 if($city){
  2697.                     $user->setCity($city);
  2698.                 }
  2699.             }
  2701.             $user->setAddress($address);
  2702.             $user->setAddressNeighborhood($addressNeighborhood);
  2703.             $user->setAddressNumber($addressNumber);
  2704.             $user->setAddressComplement($addressComplement);
  2706.             $user->restore();
  2707.         }
  2709.         if(!$user){
  2710.             return $this->eadResponse([ 'user' ], ErrorEnum::FIELD_EMPTY);
  2711.         }
  2713.         if($checkoutNew == CartEnum::NO && empty($userCheckoutInfoId)){
  2714.             $userCheckoutInfo = new UserCheckoutInfo();
  2716.             $userCheckoutInfo->setName($user->getName());
  2717.             $userCheckoutInfo->setEmail($user->getEmail());
  2718.             $userCheckoutInfo->setDocument($user->getDocument());
  2719.             $userCheckoutInfo->setPhone($user->getPhone());
  2720.             $userCheckoutInfo->setZipCode($user->getZipCode());
  2721.             $userCheckoutInfo->setAddress($user->getAddress());
  2722.             $userCheckoutInfo->setAddressNumber($user->getAddressNumber());
  2723.             $userCheckoutInfo->setAddressComplement($user->getAddressComplement());
  2724.             $userCheckoutInfo->setAddressNeighborhood($user->getAddressNeighborhood());
  2725.             $userCheckoutInfo->setCity($user->getCity());
  2726.             $userCheckoutInfo->setState($user->getState());
  2727.             $userCheckoutInfo->setCountry($user->getCountry());
  2728.             $userCheckoutInfo->setUser($user);
  2729.             $userCheckoutInfo->setReceiveEmail(UserCheckoutInfoEnum::NO);
  2730.             $userCheckoutInfo->setDefault(UserCheckoutInfoEnum::YES);
  2732.             $this->em->persist($userCheckoutInfo);
  2733.         }else if($checkoutNew == CartEnum::NO && !empty($userCheckoutInfoId)){
  2734.             $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  2735.                 "id" => $userCheckoutInfoId,
  2736.                 "user" => $user->getId(),
  2737.                 "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED,
  2738.             ]);
  2739.         }else if($checkoutNew == CartEnum::YES){
  2741.             $userCheckoutInfo = new UserCheckoutInfo();
  2743.             $userCheckoutInfo->setName($checkoutName);
  2744.             $userCheckoutInfo->setEmail($checkoutEmail);
  2745.             $userCheckoutInfo->setDocument($checkoutDocument);
  2746.             $userCheckoutInfo->setPhone($checkoutPhone);
  2747.             $userCheckoutInfo->setZipCode($checkoutZipCode);
  2748.             $userCheckoutInfo->setAddress($checkoutAddress);
  2749.             $userCheckoutInfo->setAddressNumber($checkoutAddressNumber);
  2750.             $userCheckoutInfo->setAddressComplement($checkoutAddressComplement);
  2751.             $userCheckoutInfo->setAddressNeighborhood($checkoutAddressNeighborhood);
  2753.             if($checkoutForeigner == UserCheckoutInfoEnum::NO){
  2755.                 $country = $this->em->getRepository(Country::class)->findOneBy([ 
  2756.                     "deleted" => GeoDataEnum::ITEM_NO_DELETED ,
  2757.                     "id" => GeoDataEnum::YES,
  2758.                 ]);
  2760.                 if($country){
  2761.                     $userCheckoutInfo->setCountry($country);
  2762.                 }
  2763.             }
  2765.             if(!empty($checkoutStateId)){
  2766.                 $state = $this->em->getRepository(State::class)->findOneBy([
  2767.                     "id" => $checkoutStateId,
  2768.                     "deleted" => UserEnum::ITEM_NO_DELETED
  2769.                 ]);
  2771.                 if($state){
  2772.                     $userCheckoutInfo->setState($state);
  2773.                 }
  2774.             }
  2776.             if(!empty($checkoutCityId)){
  2777.                 $city = $this->em->getRepository(City::class)->findOneBy([
  2778.                     "id" => $checkoutCityId,
  2779.                     "deleted" => UserEnum::ITEM_NO_DELETED
  2780.                 ]);
  2782.                 if($city){
  2783.                     $userCheckoutInfo->setCity($city);
  2784.                 }
  2785.             }
  2787.             $userCheckoutInfo->setUser($user);
  2788.             $userCheckoutInfo->setReceiveEmail($checkoutNotify);
  2789.             $userCheckoutInfo->setDefault(UserCheckoutInfoEnum::YES);
  2791.             $this->em->persist($userCheckoutInfo);
  2792.         }
  2794.         if(!$userCheckoutInfo){
  2795.             return $this->eadResponse([ 'userCheckoutInfo' ], ErrorEnum::FIELD_EMPTY);
  2796.         }
  2798.         if($paymentMethod == CartEnum::PAYMENT_CARD){
  2799.             if($cardNew == CartEnum::NO && !empty($cardId)){
  2800.                 $userCard = $userCardRepository->findOneBy([
  2801.                     "id" => $cardId,
  2802.                     "user" => $user->getId(),
  2803.                     "deleted" => CartEnum::ITEM_NO_DELETED
  2804.                 ]);
  2805.             }else if($cardNew == CartEnum::YES){
  2806.                 if(empty($cardHash)){
  2807.                     return $this->eadResponse([ 'cardHash' ], ErrorEnum::FIELD_EMPTY);
  2808.                 }
  2810.                 $userCard = $userCardRepository->createByHash($cardHash, $user);
  2811.             }
  2813.             if(!$userCard){
  2814.                 return $this->eadResponse([ 'userCard' ], ErrorEnum::FIELD_EMPTY);
  2815.             }
  2817.             if(empty($installments)){
  2818.                 return $this->eadResponse([ 'installments' ], ErrorEnum::FIELD_EMPTY);
  2819.             }
  2820.         }
  2822.         $productOfferDefault = null;
  2823.         $amount = null;
  2824.         $items = [];
  2825.         $courses = null;
  2826.         $coursesAux = [];
  2828.         foreach ($offers as $key => $offerId) {
  2829.             $productOffer = $poRepository->findOneBy([
  2830.                 "id" => $offerId,
  2831.             ]);
  2832.             if($productOffer){
  2833.                 $product = $productOffer->getProduct();
  2835.                 if($offerId == $offerDefaultId){
  2836.                     $productOfferDefault = $productOffer;
  2838.                     if(
  2839.                         $product->getType() == ProductEnum::COURSE || 
  2840.                         $product->getType() == ProductEnum::COMBO
  2841.                     ){
  2842.                         $courses = $courseRepository->getCoursesByProduct(
  2843.                             $product->getId()
  2844.                         );
  2846.                         foreach ($courses as $key => $course) {
  2847.                             $coursesAux[] = $course->getId();
  2848.                         }
  2849.                     }
  2850.                 }
  2852.                 if(!empty($couponKey)){
  2853.                     $productCoupon = $pcRepository->findValidProductCouponByProductOffer(
  2854.                         $couponKey, 
  2855.                         $productOffer
  2856.                     );
  2857.                 }
  2859.                 $cart = $cartRepository->addCartByProductOffer(
  2860.                     $productOffer,
  2861.                     $user,
  2862.                     null,
  2863.                     $productCoupon,
  2864.                     $utmsUrl,
  2865.                     ($productOffer->getProduct()->isTypeResource() ? $courses : null)
  2866.                 );
  2868.                 if($cart){
  2869.                     $items[] = (object)[
  2870.                         "courses" => $coursesAux,
  2871.                         "productOfferId" => $productOffer->getId(),
  2872.                         "productId" => $product->getId(),
  2873.                         "amount" => $cart->getPrice() + $cart->getMembershipFee(),
  2874.                         "cartId" => $cart->getId(),
  2875.                         "productCouponId" => (
  2876.                             $productCoupon ? $productCoupon->getId() : null
  2877.                         ),
  2878.                     ];
  2880.                     $amount = $amount + $cart->getPrice(true) + $cart->getMembershipFee(true);
  2881.                 }
  2882.             }
  2883.         }
  2885.         if(count($items) != count($offers)){
  2886.             return $this->eadResponse([ "added-ids" ], ErrorEnum::FIELD_EMPTY);
  2887.         }
  2889.         if(!$productOfferDefault){
  2890.             return $this->eadResponse([ "offer-default" ], ErrorEnum::FIELD_EMPTY);
  2891.         }
  2893.         $this->em->flush();
  2895.         $paymentConfig = $this->configuration->getPaymentConfig();
  2896.         $dateExpire = null;
  2898.         if($paymentMethod == CartEnum::PAYMENT_CARD){
  2900.             $freeInstallments = $poRepository->getFreeInstallment($productOfferDefault);
  2902.             $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  2903.                 'amount' => $amount,
  2904.                 'free_installments' => $freeInstallments,
  2905.                 'max_installments' => $installments,
  2906.                 'interest_rate' => $paymentConfig->installmentInterest
  2907.             ]);
  2909.             $amount = $installmentsOptions->{$installments}->amount;
  2910.         }else if($paymentMethod == CartEnum::PAYMENT_BILL){
  2911.             $dateExpire = $poRepository->getDateExpireBill($productOffer);
  2912.         }else if($paymentMethod == CartEnum::PAYMENT_PIX){
  2913.             $dateExpire = $poRepository->getDateExpirePix($productOffer);
  2914.         }
  2916.         if($amount < $this->configuration->getMinValueProduct()){
  2917.             return $this->eadResponse([ 
  2918.                 "message" => "Min Value" 
  2919.             ], ErrorEnum::ACTION_INVALID);
  2920.         }
  2922.         if($user && $user->getId() == CartEnum::YES){
  2923.             $transactionService->setDebug(true);
  2924.         }
  2926.         $transactionOrigin = TransactionEnum::ORIGIN_CHECKOUT_PAGE;
  2928.         $data = $transactionService->createTransactionEAD(
  2929.             $user,
  2930.             $userCheckoutInfo,
  2931.             $amount,
  2932.             $paymentMethod,
  2933.             $installments,
  2934.             $items,
  2935.             $userCard,
  2936.             $dateExpire,
  2937.             null,
  2938.             null,
  2939.             null,
  2940.             $transactionOrigin
  2941.         );
  2943.         if(!empty($data['errorMessage'])){
  2945.             foreach ($offers as $key => $offerId) {
  2946.                 $productOffer = $poRepository->findOneBy([
  2947.                     "id" => $offerId,
  2948.                 ]);
  2949.                 if($productOffer){
  2950.                     if($cart){
  2951.                         $cart->setErrorMessage($data['errorMessage']);
  2952.                     }
  2953.                 }
  2954.             }
  2955.             $this->em->flush();
  2957.             return $this->eadResponse([ 
  2958.                 "message" => $data['errorMessage']
  2959.             ], ErrorEnum::ACTION_INVALID);
  2960.         }
  2961.         
  2962.         return $this->eadResponse($data);
  2963.     }
  2965.     /**
  2966.      * @Route(
  2967.      *      path          = "/admin/cart/checkout/default",
  2968.      *      name          = "cartCheckoutDefault",
  2969.      *      methods       = {"POST"}
  2970.      * )
  2971.      */
  2972.     public function checkoutDefault(Request $request){
  2973.         if(!$this->user){
  2974.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  2975.         }
  2976.         
  2977.         $receiverSchool = $this->configuration->getReceiverSchool(
  2978.             ReceiverEnum::EAD_CHECKOUT
  2979.         );
  2980.         if(!$receiverSchool){
  2981.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  2982.         }
  2984.         $transactionService = $this->generalService->getService(
  2985.             'Transaction\\TransactionService'
  2986.         );
  2987.         $pagarMeTransaction = $this->generalService->getService(
  2988.             'PagarMe\\PagarMeTransaction'
  2989.         );
  2991.         $this->requestUtil->setRequest($request)->setData();
  2993.         $userCheckoutInfoId = $this->requestUtil->getField('userCheckoutInfoId');
  2994.         $paymentMethod = $this->requestUtil->getField('paymentMethod');
  2995.         $installments = $this->requestUtil->getField('installments');
  2997.         $cartRepository = $this->em->getRepository(Cart::class);
  2998.         $productRepository = $this->em->getRepository(Product::class);
  2999.         $userCardRepository = $this->em->getRepository(UserCard::class);
  3000.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  3001.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  3003.         $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  3004.             "id" => $userCheckoutInfoId,
  3005.             "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED,
  3006.         ]);
  3008.         if(!$userCheckoutInfo){
  3009.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3010.         }
  3012.         $paymentConfig = $this->configuration->getPaymentConfig();
  3014.         $items = [];
  3015.         $amount = 0;
  3016.         $userCard = null;
  3017.         $dateExpire = null;
  3019.         if(empty($paymentMethod)){
  3020.             return $this->eadResponse([ 'paymentMethod' ], ErrorEnum::FIELD_EMPTY);
  3021.         }
  3023.         if($paymentMethod == CartEnum::PAYMENT_CARD){ // get user card
  3024.             if(empty($installments)){
  3025.                 return $this->eadResponse([ 'installments' ], ErrorEnum::FIELD_EMPTY);
  3026.             }
  3028.             $userCardId = $this->requestUtil->getField('userCardId');
  3029.             if(empty($userCardId)){
  3030.                 return $this->eadResponse([ 'userCardId' ], ErrorEnum::FIELD_EMPTY);
  3031.             }
  3033.             if($userCardId > 0){
  3034.                 $userCard = $userCardRepository->findOneBy([
  3035.                     "id" => $userCardId,
  3036.                     "user" => $this->user->getId(),
  3037.                     "deleted" => CartEnum::ITEM_NO_DELETED
  3038.                 ]);
  3039.             }
  3040.         }
  3042.         if($paymentMethod == CartEnum::PAYMENT_CARD && !$userCard){
  3043.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3044.         }
  3046.         $carts = $cartRepository->getUserValidCarts($this->user->getId());
  3047.         if(empty($carts)){
  3048.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3049.         }
  3051.         $freeInstallments = $paymentConfig->installmentNumberInterest;
  3052.         if($paymentConfig->assumeInstallmentInterest == CartEnum::YES){
  3053.             $freeInstallments = 12;
  3054.         }
  3056.         $billDateExpire = null;
  3057.         $pixDateExpire = null;
  3059.         $hasOneItem = (count($carts) == CartEnum::YES);
  3060.         
  3061.         foreach ($carts as $key => $cart) {
  3062.             $productOffer = $cart->getProductOffer();
  3063.             $product = $cart->getProduct();
  3065.             if($hasOneItem){
  3066.                 $billDateExpire = $productOfferRepository->getDateExpireBill($productOffer);
  3067.                 $pixDateExpire = $productOfferRepository->getDateExpirePix($productOffer);
  3068.                 $freeInstallments = $productOfferRepository->getFreeInstallment(
  3069.                     $productOffer
  3070.                 );
  3071.             }
  3073.             $productCoupon = $cart->getProductCoupon();
  3075.             $items[] = (object)[
  3076.                 "courses" => $cart->getCourse(),
  3077.                 "productOfferId" => $productOffer->getId(),
  3078.                 "productId" => $product->getId(),
  3079.                 "amount" => $cart->getPrice() + $cart->getMembershipFee(),
  3080.                 "cartId" => $cart->getId(),
  3081.                 "productCouponId" => ($productCoupon ? $productCoupon->getId() : null),
  3082.             ];
  3084.             $amount = $amount + $cart->getPrice(true) + $cart->getMembershipFee(true);
  3085.         }
  3087.         if($paymentMethod == CartEnum::PAYMENT_BILL){
  3088.             $dateExpire = $billDateExpire;
  3089.             if(empty($dateExpire)){
  3090.                 $period = (int)$this->configuration->get('bill_period_expire') + 1;
  3091.                 if($period == 1){
  3092.                     $period = 8;
  3093.                 }
  3095.                 $dateExpire = date("Y-m-d", strtotime("+ {$period} day"));
  3096.             }
  3097.         }else if($paymentMethod == CartEnum::PAYMENT_PIX){
  3098.             $dateExpire = $pixDateExpire;
  3099.             if(empty($dateExpire)){
  3100.                 $period = (int)$this->configuration->get('pix_period_expire') + 1;
  3101.                 if($period == 1){
  3102.                     $period = 8;
  3103.                 }
  3105.                 $dateExpire = date("Y-m-d", strtotime("+ {$period} day"));
  3106.             }
  3107.         }else if($paymentMethod == CartEnum::PAYMENT_CARD){
  3108.             $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  3109.                 'amount' => $amount,
  3110.                 'free_installments' => $freeInstallments,
  3111.                 'max_installments' => $installments,
  3112.                 'interest_rate' => $paymentConfig->installmentInterest
  3113.             ]);
  3115.             $amount = $installmentsOptions->{$installments}->amount;
  3116.         }
  3118.         if($amount < $this->configuration->getMinValueProduct()){
  3119.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3120.         }
  3122.         if($this->user && $this->user->getId() == CartEnum::YES){
  3123.             $transactionService->setDebug(true);
  3124.         }
  3126.         $transactionOrigin = TransactionEnum::ORIGIN_CHECKOUT_DEFAULT;
  3128.         $data = $transactionService->createTransactionEAD(
  3129.             $this->user,
  3130.             $userCheckoutInfo,
  3131.             $amount,
  3132.             $paymentMethod,
  3133.             $installments,
  3134.             $items,
  3135.             $userCard,
  3136.             $dateExpire,
  3137.             null,
  3138.             null,
  3139.             (!empty($freeInstallments) ? (int)$freeInstallments : null),
  3140.             $transactionOrigin
  3141.         );
  3143.         if(!empty($data['errorMessage'])){
  3145.             foreach ($carts as $key => $cart) {
  3146.                 $cart->setErrorMessage($data['errorMessage']);
  3147.             }
  3148.             $this->em->flush();
  3150.             return $this->eadResponse([ 
  3151.                 "message" => $data['errorMessage']
  3152.             ], ErrorEnum::ACTION_INVALID);
  3153.         }
  3155.         return $this->eadResponse($data);
  3156.     }
  3158.     /**
  3159.      * @Route(
  3160.      *      path          = "/admin/cart/checkout/custom",
  3161.      *      name          = "cartCheckoutCustom",
  3162.      *      methods       = {"POST"}
  3163.      * )
  3164.      */
  3165.     public function cartCheckoutCustom(Request $request){
  3167.         if(!$this->user){
  3168.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3169.         }
  3171.         $receiverSchool = $this->configuration->getReceiverSchool(
  3172.             ReceiverEnum::EAD_CHECKOUT
  3173.         );
  3174.         if(!$receiverSchool){
  3175.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3176.         }
  3178.         $transactionService = $this->generalService->getService(
  3179.             'Transaction\\TransactionService'
  3180.         );
  3181.         $pagarMeTransaction = $this->generalService->getService(
  3182.             'PagarMe\\PagarMeTransaction'
  3183.         );
  3185.         $this->requestUtil->setRequest($request)->setData();
  3187.         $items = json_decode($this->requestUtil->getField('items'));
  3188.         $userCardId = $this->requestUtil->getField('userCardId');
  3189.         $userCheckoutInfoId = $this->requestUtil->getField('userCheckoutInfoId');
  3191.         if(count($items) == CartEnum::NO){
  3192.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3193.         }
  3195.         $cartRepository = $this->em->getRepository(Cart::class);
  3196.         $productRepository = $this->em->getRepository(Product::class);
  3197.         $userCardRepository = $this->em->getRepository(UserCard::class);
  3198.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  3199.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  3201.         $carts = $cartRepository->getUserValidCarts($this->user->getId());
  3202.         if(empty($carts)){
  3203.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3204.         }
  3206.         $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  3207.             "id" => $userCheckoutInfoId,
  3208.             "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED,
  3209.         ]);
  3211.         if(!$userCheckoutInfo){
  3212.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3213.         }
  3215.         $groupedItems = [];
  3216.         $ref = null;
  3217.         $group = [];
  3219.         foreach ($items as $key => $item) {
  3220.             
  3221.             if(empty($ref)){
  3222.                 $ref = $item->parentRef;
  3223.             }
  3225.             if($ref != $item->parentRef){
  3226.                 if(!empty($group)){
  3227.                     $groupedItems[] = $group;
  3228.                 }
  3230.                 $ref = $item->parentRef;
  3231.                 $group = [];
  3232.             }
  3233.             
  3234.             $group[] = $item;
  3236.             if(($key + 1) == count($items)){
  3237.                 if(!empty($group)){
  3238.                     $groupedItems[] = $group;
  3239.                 }
  3240.             }
  3241.         }
  3243.         $userCard = null;
  3244.         if($userCardId > 0){
  3245.             $userCard = $userCardRepository->findOneBy([
  3246.                 "id" => $userCardId,
  3247.                 "user" => $this->user->getId(),
  3248.                 "deleted" => CartEnum::ITEM_NO_DELETED
  3249.             ]);
  3250.         }
  3252.         $hashReference = md5(
  3253.             date('Y-m-d H:i:s') . $this->user->getId() . $this->client->getClientId()
  3254.         );
  3256.         $paymentConfig = $this->configuration->getPaymentConfig();
  3258.         foreach ($groupedItems as $key => $group) {
  3260.             $items = [];
  3261.             $paymentMethod = null;
  3262.             $installments = 1;
  3263.             $dateExpire = null;
  3264.             $amount = 0;
  3266.             foreach ($group as $key => $itemReq) {
  3267.                 $itemReq = (object)$itemReq;
  3269.                 if($itemReq->able){
  3270.                     $cart = $cartRepository->findOneBy([
  3271.                         "id" => $itemReq->id,
  3272.                         "deleted" => CartEnum::ITEM_NO_DELETED
  3273.                     ]);
  3275.                     $productOffer = $cart->getProductOffer();
  3276.                     $product = $cart->getProduct();
  3277.                     $productCoupon = $cart->getProductCoupon();
  3279.                     $items[] = (object)[
  3280.                         "courses" => $cart->getCourse(),
  3281.                         "productOfferId" => $productOffer->getId(),
  3282.                         "productId" => $product->getId(),
  3283.                         "amount" => $cart->getPrice() + $productOffer->getMembershipFee(),
  3284.                         "cartId" => $cart->getId(),
  3285.                         "productCouponId" => (
  3286.                             $productCoupon ? $productCoupon->getId() : null
  3287.                         ),
  3288.                     ];
  3290.                     $paymentMethod = $itemReq->paymentMethod;
  3291.                     $installments = $itemReq->installment;
  3293.                     if($paymentMethod == CartEnum::PAYMENT_BILL){
  3294.                         $dateExpire = $itemReq->billDateExpire;
  3295.                     }else if($paymentMethod == CartEnum::PAYMENT_PIX){
  3296.                         $dateExpire = $itemReq->pixDateExpire;
  3297.                     }
  3299.                     $amountItem = $cart->getPrice(true) + $productOffer->getMembershipFee(
  3300.                         true
  3301.                     );
  3303.                     if($paymentMethod == CartEnum::PAYMENT_CARD){
  3305.                         $freeInstallments = $productOfferRepository->getFreeInstallment(
  3306.                             $productOffer
  3307.                         );
  3309.                         $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  3310.                             'amount' => $amountItem,
  3311.                             'free_installments' => $freeInstallments,
  3312.                             'max_installments' => $installments,
  3313.                             'interest_rate' => $paymentConfig->installmentInterest
  3314.                         ]);
  3316.                         $amountItem = $installmentsOptions->{$installments}->amount;
  3317.                     }
  3319.                     $amount = $amount + $amountItem;
  3320.                 }
  3321.             }
  3323.             if($amount < $this->configuration->getMinValueProduct()){
  3324.                 return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3325.             }
  3327.             if($this->user && $this->user->getId() == CartEnum::YES){
  3328.                 $transactionService->setDebug(true);
  3329.             }
  3331.             $transactionOrigin = TransactionEnum::ORIGIN_CHECKOUT_CUSTOM;
  3334.             $data = $transactionService->createTransactionEAD(
  3335.                 $this->user,
  3336.                 $userCheckoutInfo,
  3337.                 $amount, 
  3338.                 $paymentMethod,
  3339.                 $installments,
  3340.                 $items,
  3341.                 $userCard,
  3342.                 $dateExpire,
  3343.                 $hashReference,
  3344.                 null,
  3345.                 null,
  3346.                 $transactionOrigin
  3347.             );
  3349.             if(!empty($data['errorMessage'])){
  3351.                 foreach ($group as $key => $itemReq) {
  3352.                     if($itemReq->able){
  3353.                         $cart = $cartRepository->findOneBy([
  3354.                             "id" => $itemReq->id,
  3355.                             "deleted" => CartEnum::ITEM_NO_DELETED
  3356.                         ]);
  3357.                         $cart->setErrorMessage($data['errorMessage']);
  3358.                     }
  3359.                 }
  3360.                 $this->em->flush();
  3361.     
  3362.                 return $this->eadResponse([ 
  3363.                     "message" => $data['errorMessage']
  3364.                 ], ErrorEnum::ACTION_INVALID);
  3365.             }
  3366.         }
  3368.         $dataFinal = [
  3369.             "hashReference" => $hashReference,
  3370.         ];
  3372.         return $this->eadResponse($dataFinal);
  3373.     }
  3375.     /**
  3376.      * @Route(
  3377.      *      path          = "/cart/buy/one/click/{productOfferId}/{courseId}",
  3378.      *      name          = "cartOneClickBuy",
  3379.      *      methods       = {"GET"},
  3380.      *      defaults      = { "courseId" = 0 }
  3381.      * )
  3382.      */
  3383.     public function cartOneClickBuy(Request $request){
  3384.         $this->requestUtil->setRequest($request)->setData();
  3386.         $productOfferId = $request->get('productOfferId');
  3387.         $courseId = (int)$request->get('courseId');
  3389.         $dataUtml = [
  3390.             "utm_source" => $request->get('utm_source'),
  3391.             "utm_medium" => $request->get('utm_medium'),
  3392.             "utm_campaign" => $request->get('utm_campaign'),
  3393.             "utm_term" => $request->get('utm_term'),
  3394.             "utm_content" => $request->get('utm_content'),
  3395.         ];
  3397.         $utmsUrl = json_encode($dataUtml);
  3399.         $params = [
  3400.             "poID" => $productOfferId,
  3401.             "courseId" => $courseId,
  3402.         ];
  3404.         $params = array_merge($params, $dataUtml);
  3406.         $cartRepository = $this->em->getRepository(Cart::class);
  3408.         $productOffer = $this->em->getRepository(ProductOffer::class)->findOneBy([ 
  3409.             "id" => $productOfferId, 
  3410.             "status" => ProductOfferEnum::PUBLISHED,
  3411.             "deleted" => ProductOfferEnum::ITEM_NO_DELETED
  3412.         ]);
  3414.         if(!$productOffer){
  3415.             return $this->redirectToRoute('notFound');
  3416.         }
  3418.         $product = $productOffer->getProduct();
  3420.         if($product->isTypeResource() && empty($courseId)){
  3421.             return $this->redirectToRoute('notFound');
  3422.         }
  3424.         if(
  3425.             $product->getType() == ProductEnum::SUBSCRIPTION ||
  3426.             (
  3427.                 $product->getType() != ProductEnum::SUBSCRIPTION && 
  3428.                 $productOffer->getAllowRecurrency() == ProductOfferEnum::YES
  3429.             )
  3430.         ){
  3431.             if($productOffer->getAllowTrial() == ProductOfferEnum::YES){
  3433.                 $params = [
  3434.                     "poHash" => $productOffer->getOfferLink(),
  3435.                     "pcKey" => null,
  3436.                 ];
  3438.                 $params = array_merge($params, $dataUtml);
  3440.                 return $this->redirectToRoute('cartIndividual', $params);
  3441.             }
  3442.         }
  3444.         if(!$this->user){
  3445.             return $this->redirectToRoute('cartAdd', $params);
  3446.         }
  3447.         
  3448.         $receiverSchool = $this->configuration->getReceiverSchool(
  3449.             ReceiverEnum::EAD_CHECKOUT
  3450.         );
  3451.         if(!$receiverSchool){
  3452.             return $this->redirectToRoute('cartAdd', $params);
  3453.         }
  3455.         if($this->user->getAllowOneClickBuy() == UserEnum::NO){
  3456.             return $this->redirectToRoute('cartAdd', $params);
  3457.         }
  3459.         $userCardRepository = $this->em->getRepository(UserCard::class);
  3460.         $userCardDefault = $userCardRepository->getDefaultValidUserCard();
  3461.         if(!$userCardDefault){
  3462.             return $this->redirectToRoute('cartAdd', $params);
  3463.         }
  3465.         if($productOffer->getSaleChannel() == ProductOfferEnum::EXTERNAL){
  3466.             $externalCheckoutLink = $productOffer->getExternalCheckoutLink();
  3467.             return $this->redirect($externalCheckoutLink, 301);
  3468.         }
  3470.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  3471.         $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  3472.             "user" => $this->user->getId(),
  3473.             "default" => UserCheckoutInfoEnum::YES,
  3474.             "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED,
  3475.         ]);
  3477.         if(!$userCheckoutInfo){
  3478.             return $this->redirectToRoute('cartAdd', $params);
  3479.         }
  3481.         $productSuggestion = null;
  3483.         if(!empty($productSuggestionId)){
  3484.             $productSuggestion = $psRepository->findOneBy([ 
  3485.                 "id" => $productSuggestionId, 
  3486.                 "status" => ProductSuggestionEnum::PUBLISHED,
  3487.                 "deleted" => ProductSuggestionEnum::ITEM_NO_DELETED
  3488.             ]);
  3489.         }
  3491.         $course = null;
  3492.         $courseRepository = $this->em->getRepository(Course::class);
  3493.         if(!empty($courseId)){
  3494.             $course = $courseRepository->findOneBy([
  3495.                 "id" => $courseId,
  3496.                 "deleted" => CourseEnum::ITEM_NO_DELETED,
  3497.             ]);
  3498.         }
  3500.         $cart = $cartRepository->addCartByProductOffer(
  3501.             $productOffer, 
  3502.             $this->user, 
  3503.             $productSuggestion,
  3504.             null,
  3505.             $utmsUrl,
  3506.             ($course ? [ $course ] : null)
  3507.         );
  3508.         
  3509.         if(!$cart){
  3510.             return $this->redirectToRoute('cartAdd', $params);
  3511.         }
  3513.         $productCoupon = $cart->getProductCoupon();
  3515.         $items = [
  3516.             (object)[
  3517.                 "courseId" => ($course ? $course->getId() : null),
  3518.                 "productOfferId" => $productOffer->getId(),
  3519.                 "productId" => $productOffer->getProduct()->getId(),
  3520.                 "amount" => $cart->getPrice() + $cart->getMembershipFee(),
  3521.                 "cartId" => $cart->getId(),
  3522.                 "productCouponId" => ($productCoupon ? $productCoupon->getId() : null),
  3523.             ]
  3524.         ];
  3526.         $transactionService = $this->generalService->getService(
  3527.             'Transaction\\TransactionService'
  3528.         );
  3530.         if($this->user && $this->user->getId() == CartEnum::YES){
  3531.             $transactionService->setDebug(true);
  3532.         }
  3534.         $transactionOrigin = TransactionEnum::ORIGIN_ONE_CLICK;
  3536.         $data = (object)$transactionService->createTransactionEAD(
  3537.             $this->user,
  3538.             $userCheckoutInfo,
  3539.             $cart->getPrice(true) + $cart->getMembershipFee(true),
  3540.             CartEnum::PAYMENT_CARD,
  3541.             1,
  3542.             $items,
  3543.             $userCardDefault,
  3544.             null,
  3545.             null,
  3546.             null,
  3547.             null,
  3548.             $transactionOrigin
  3549.         );
  3551.         if(!empty($data->errorMessage)){
  3553.             $cart->setErrorMessage($data->errorMessage);
  3554.             $this->em->flush();
  3556.             //return $this->eadResponse([ 
  3557.             //    "message" => $data->errorMessage
  3558.             //], ErrorEnum::ACTION_INVALID);
  3560.             return $this->redirectToRoute('cart'); 
  3561.         }
  3563.         $paramsConclusion = [
  3564.             "hashReference" => $data->hashReference,
  3565.         ];
  3567.         return $this->redirectToRoute('cartConclusion', $paramsConclusion);
  3568.     }
  3570.     /**
  3571.      * @Route(
  3572.      *      path          = "/admin/cart/checkout/plan/trial/{poID}/{pcID}",
  3573.      *      name          = "cartCheckoutPlanTrial",
  3574.      *      methods       = {"POST"},
  3575.      *      defaults      = { "pcID" = 0 }
  3576.      * )
  3577.      */
  3578.     public function cartCheckoutPlanTrial(Request $request){
  3579.         if(!$this->user){
  3580.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3581.         }
  3582.         
  3583.         $receiverSchool = $this->configuration->getReceiverSchool(
  3584.             ReceiverEnum::EAD_CHECKOUT
  3585.         );
  3586.         if(!$receiverSchool){
  3587.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3588.         }
  3590.         $productOfferId = (int)$request->get('poID');
  3591.         $productCouponId = (int)$request->get('pcID');
  3592.         $this->requestUtil->setRequest($request)->setData();
  3594.         $userCheckoutInfoId = $this->requestUtil->getField('userCheckoutInfoId');
  3595.         $paymentMethod = $this->requestUtil->getField('paymentMethod');
  3596.         $installments = $this->requestUtil->getField('installments');
  3598.         $userCardRepository = $this->em->getRepository(UserCard::class);
  3599.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  3600.         $productCouponRepository = $this->em->getRepository(ProductCoupon::class);
  3601.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  3603.         $productOffer = $productOfferRepository->findOneBy([ 
  3604.             "id" => $productOfferId, 
  3605.             "status" => ProductOfferEnum::PUBLISHED,
  3606.             "deleted" => ProductOfferEnum::ITEM_NO_DELETED
  3607.         ]);
  3609.         if(!$productOffer){
  3610.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  3611.         }
  3613.         if($productOffer->getAllowTrial() == ProductOfferEnum::NO){
  3614.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3615.         }
  3616.         
  3617.         $product = $productOffer->getProduct();
  3618.         $pagarMeTransaction = $this->generalService->getService(
  3619.             'PagarMe\\PagarMeTransaction'
  3620.         );
  3622.         $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  3623.             "id" => $userCheckoutInfoId,
  3624.             "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED,
  3625.         ]);
  3627.         if(!$userCheckoutInfo){
  3628.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3629.         }
  3631.         $paymentConfig = $this->configuration->getPaymentConfig();
  3633.         $userCard = null;
  3634.         if(empty($paymentMethod)){
  3635.             return $this->eadResponse([ 'paymentMethod' ], ErrorEnum::FIELD_EMPTY);
  3636.         }
  3638.         if($paymentMethod == CartEnum::PAYMENT_CARD){ // get user card
  3639.             if(empty($installments)){
  3640.                 return $this->eadResponse([ 'installments' ], ErrorEnum::FIELD_EMPTY);
  3641.             }
  3643.             $userCardId = $this->requestUtil->getField('userCardId');
  3644.             if(empty($userCardId)){
  3645.                 return $this->eadResponse([ 'userCardId' ], ErrorEnum::FIELD_EMPTY);
  3646.             }
  3648.             if($userCardId > 0){
  3649.                 $userCard = $userCardRepository->findOneBy([
  3650.                     "id" => $userCardId,
  3651.                     "user" => $this->user->getId(),
  3652.                     "deleted" => CartEnum::ITEM_NO_DELETED
  3653.                 ]);
  3654.             }
  3655.         }
  3657.         if($paymentMethod == CartEnum::PAYMENT_CARD && !$userCard){
  3658.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3659.         }
  3661.         $productCoupon = null;
  3662.         $amount = $productOffer->getPriceReal();
  3663.         if(!empty($productCouponId)){
  3664.             $productCoupon = $productCouponRepository->findOneBy([
  3665.                 "deleted" => ProductCouponEnum::ITEM_NO_DELETED,
  3666.                 "status" => ProductCouponEnum::PUBLISHED,
  3667.                 "id" => $productCouponId,
  3668.             ]);
  3670.             if($productCoupon){
  3671.                 if($productCouponRepository->checkApplyCoupon($productCoupon, $productOffer)){
  3672.                     $amount = $productCouponRepository->applyDiscount(
  3673.                         $productCoupon, 
  3674.                         $amount
  3675.                     );
  3676.                 }
  3677.             }
  3678.         }
  3680.         if($amount < $this->configuration->getMinValueProduct()){
  3681.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3682.         }
  3684.         $userSubscriptionRepository = $this->em->getRepository(UserSubscription::class);
  3685.         $userSubscription = $userSubscriptionRepository->findOneBy([
  3686.             "user" => $this->user->getId(),
  3687.             "product" => $product->getId()
  3688.         ]);
  3690.         if($userSubscription && $userSubscription->isLive()){
  3691.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3692.         }
  3694.         if(!$userSubscription){
  3695.             $userSubscription = new UserSubscription();
  3696.         }else{
  3697.             $userSubscriptionRepository->restore($userSubscription, TrashEnum::USER_SUBSCRIPTION);
  3698.         }
  3700.         $userSubscription->setStatus(UserSubscriptionEnum::STATUS_TRIAL);
  3701.         $userSubscription->setDateStart(date('Y-m-d H:i:s'));
  3702.         $userSubscription->setAutomaticRenewal($productOffer->getPlanRenew());
  3703.         $userSubscription->setLifetime($productOffer->getPlanLifetime());
  3704.         $userSubscription->setPrice($productOffer->getPriceReal());
  3705.         $userSubscription->setCycle($productOffer->getPlanCycle());
  3706.         $userSubscription->setChargeNumberMax($productOffer->getPlanChargeNumberMax());
  3707.         $userSubscription->setMembershipFee($productOffer->getMembershipFee());
  3708.         $userSubscription->setProduct($product);
  3709.         $userSubscription->setProductOffer($productOffer);
  3710.         $userSubscription->setUser($this->user);
  3711.         $userSubscription->setUsedTrial(UserSubscriptionEnum::YES);
  3713.         if($productCoupon){
  3714.             $userSubscription->setProductCoupon($productCoupon);
  3715.             $userSubscription->setCouponKey($productCoupon->getKey());
  3716.             $userSubscription->setCouponType($productCoupon->getDiscountType());
  3717.             $userSubscription->setCouponApplyMembershipFee(
  3718.                 $productCoupon->getApplyMembershipFee()
  3719.             );
  3720.             $userSubscription->setCouponLifetime($productCoupon->getPlanLifetime());
  3721.             $userSubscription->setCouponNumberCharges($productCoupon->getPlanCharges());
  3722.             $userSubscription->setCouponDiscount($productCoupon->getDiscount());
  3723.         }
  3725.         $userSubscription->setPaymentMethod($paymentMethod);
  3727.         $monthCycles = [
  3728.             UserSubscriptionEnum::CYCLE_MONTHLY,
  3729.             UserSubscriptionEnum::CYCLE_WEEKLY,
  3730.             UserSubscriptionEnum::CYCLE_BIWEEKLY,
  3731.         ];
  3733.         if(!in_array($userSubscription->getCycle(), $monthCycles)){
  3734.             $freeInstallmentNumber = $productOfferRepository->getFreeInstallment(
  3735.                 $productOffer
  3736.             );
  3738.             $userSubscription->setInstallments($installments);
  3739.             $userSubscription->setInstallmentsFree($freeInstallmentNumber);
  3740.         }
  3741.         
  3742.         //define date renew
  3743.         if(
  3744.             $userSubscription->getLifetime() == UserSubscriptionEnum::NO && 
  3745.             $userSubscription->getAutomaticRenewal() == UserSubscriptionEnum::YES
  3746.         ){
  3747.             $periodRenew = $userSubscriptionRepository->getPlanCycle(
  3748.                 $userSubscription->getCycle(),
  3749.                 $userSubscription->getChargeNumberMax()
  3750.             );
  3752.             $userSubscription->setDateRenew(date('Y-m-d', strtotime($periodRenew)));
  3753.         }
  3755.         $days = $productOffer->getTrialPeriod();
  3756.         $dateNextPayment = date('Y-m-d', strtotime("+ {$days} day"));
  3757.         $dateAccess = date('Y-m-d H:i:s', strtotime("+ {$days} day"));
  3758.         $userSubscription->setDateNextPayment($dateNextPayment);
  3759.         $userSubscription->setDateExpiration($dateNextPayment);
  3760.         $userSubscription->setUserCard($userCard);
  3761.         $userSubscription->setUserCard($userCard);
  3762.         $userSubscription->setTrialDateEnd($dateAccess);
  3764.         $this->em->persist($userSubscription);
  3766.         $this->userLogService->logInsert(
  3767.             "user_subscription", 
  3768.             $userSubscription->getId(), 
  3769.             $userSubscription->toReturn()
  3770.         );
  3772.         $enrollmentService = $this->generalService->getService('EnrollmentService');
  3773.         $enrollmentService->setNotification(true);
  3774.         $enrollmentService->setEmail(false);
  3775.         $enrollmentService->setOrigin(EnrollmentEnum::ORIGIN_SUBSCRIPTION);
  3777.         if($userSubscription->getPaymentMethod() == UserSubscriptionEnum::PAYMENT_BILL){
  3778.             $dateAccess = date('Y-m-d H:i:s', strtotime("{$dateAccess} + 3 days"));
  3779.         }
  3781.         $enrollmentService->setAccessDate($dateAccess);
  3782.         $enrollmentService->setSupportDate($dateAccess);
  3784.         $enrollmentService->setUserSubscription($userSubscription);
  3785.         $enrollmentService->enrollUserByProduct(
  3786.             $userSubscription->getUser(), 
  3787.             $userSubscription->getProduct()
  3788.         );
  3790.         $marketingService = $this->generalService->getService('Marketing\MarketingService');
  3791.         $marketingService->setTag(TagsMarketingEnum::TAG_START_SUBSCRIPTION);
  3792.         $marketingService->setTextComplement($product->getTitle());
  3793.         $marketingService->setUser($this->user);
  3794.         $marketingService->send();
  3796.         $pixelService = $this->generalService->getService('Marketing\\PixelService');
  3797.         $pixelService->sendConversion('StartTrial', (object)[
  3798.             "value" => $userSubscription->getPrice(),
  3799.             "currency" => $productOffer->getCurrencyCode(),
  3800.             "contents" => [
  3801.                 (object)[
  3802.                     "id" => $product->getId(),
  3803.                     "quantity" => 1,
  3804.                     "item_price" => $userSubscription->getPrice(),
  3805.                     //"name" => $product->getTitle(),
  3806.                     //"type" => $product->getType()
  3807.                 ]
  3808.             ],
  3809.             "num_items" => 1,
  3810.             "content_type" => "product",
  3811.             "transaction_id" => $userSubscription->getId(),
  3812.         ]);
  3814.         $this->em->flush();
  3816.         if($userSubscription->getUser() && $userSubscription->getProduct()->getUser()){
  3818.             sleep(1);
  3819.             
  3820.             if($userSubscription->getId()){
  3821.                 $notificationService = $this->generalService->getService('NotificationService');
  3822.                 $notificationService->create(
  3823.                     $userSubscription->getUser(), 
  3824.                     $userSubscription->getProduct()->getUser(),
  3825.                     NotificationEnum::ORIGIN_USER_SUBSCRIPTION_NEW,
  3826.                     $userSubscription->getId()
  3827.                 );
  3829.                 $notificationService->create(
  3830.                     $userSubscription->getProduct()->getUser(),
  3831.                     $userSubscription->getUser(),
  3832.                     NotificationEnum::ORIGIN_USER_SUBSCRIPTION_NEW,
  3833.                     $userSubscription->getId()
  3834.                 );
  3835.             }
  3836.         }
  3838.         $userWebhook = $this->em->getRepository(User::class)->getToWebhook(
  3839.             $userSubscription->getUser()
  3840.         );
  3841.         
  3842.         //webhook
  3843.         $dataObj = (object)[
  3844.             "user" => $userWebhook,
  3845.             "subscription" => $userSubscription->toWebhook(),
  3846.             "product" => (object)[
  3847.                 "id" => (string)$userSubscription->getProduct()->getId(),
  3848.                 "name" => $userSubscription->getProduct()->getTitle(),
  3849.                 "offer" => (object)[
  3850.                     "id" => (string)$userSubscription->getProductOffer()->getId(),
  3851.                     "name" => $userSubscription->getProductOffer()->getTitle(),
  3852.                     "price" => (string)$userSubscription->getProductOffer()->getPriceReal(),
  3853.                     "membership"=> (string)$userSubscription->getMembershipFee(),
  3854.                 ],
  3855.             ],
  3856.         ];
  3857.         $webhookService = $this->generalService->getService('WebhookService');
  3858.         $webhookService->addItemList(WebhookEnum::SUBSCRIPTION, $dataObj);
  3860.         return $this->eadResponse([
  3861.             "billLink" => null,
  3862.             "pixCode" => null,
  3863.             "userId" => $this->user->getId(),
  3864.             "transactionHash" => "success",
  3865.             "hashReference" => "success",
  3866.         ]);
  3867.     }
  3869.     /**
  3870.      * @Route(
  3871.      *      path          = "/cart/checkout/new/try/{transactionHash}",
  3872.      *      name          = "cartCheckoutNewTry",
  3873.      *      methods       = {"GET"}
  3874.      * )
  3875.      */
  3876.     public function cartCheckoutNewTry(Request $request){
  3878.         $this->checkUserSession($request);
  3880.         $transactionHash = $request->get('transactionHash');
  3882.         $cartRepository = $this->em->getRepository(Cart::class);
  3883.         $transactionRepository = $this->em->getRepository(Transaction::class);
  3884.         $transactionItemRepository = $this->em->getRepository(TransactionItem::class);
  3886.         $transaction = $transactionRepository->findOneBy([
  3887.             "hash" => $transactionHash,
  3888.             "status" => TransactionEnum::CANCELED,
  3889.             "deleted" => TransactionEnum::ITEM_NO_DELETED
  3890.         ]);
  3892.         if(!$transaction){
  3893.             return $this->redirectToRoute('notFound');
  3894.         }
  3896.         $transactionItems = $transactionItemRepository->findBy([
  3897.             "transaction" => $transaction->getId(),
  3898.             "deleted" => TransactionItemEnum::ITEM_NO_DELETED
  3899.         ]);
  3901.         if(empty($transactionItems)){
  3902.             return $this->redirectToRoute('notFound');
  3903.         }
  3905.         foreach ($transactionItems as $key => $transactionItem) {
  3907.             $courses = [];
  3909.             foreach ($transactionItem->getCourse() as $keyC => $course) {
  3910.                 $courses[] = $course;
  3911.             }
  3913.             $cartRepository->addCartByProductOffer(
  3914.                 $transactionItem->getProductOffer(),
  3915.                 $transaction->getUser(),
  3916.                 null,
  3917.                 $transactionItem->getProductCoupon(),
  3918.                 $transactionItem->getUtmsUrl(),
  3919.                 $courses
  3920.             );
  3922.         }
  3925.         $this->em->flush();
  3927.         return $this->redirectToRoute('cart');
  3928.     }
  3930.     /**
  3931.      * @Route(
  3932.      *      path          = "/cart/conclusion/{hashReference}",
  3933.      *      name          = "cartConclusion",
  3934.      *      methods       = {"GET"},
  3935.      *      defaults      = { "hashReference" = null }
  3936.      * )
  3937.      * @Route(
  3938.      *      path          = "/cart/conclusao/{hashReference}",
  3939.      *      name          = "cartConclusionOld",
  3940.      *      methods       = {"GET"},
  3941.      *      defaults      = { "hashReference" = null }
  3942.      * )
  3943.      */
  3944.     public function cartConclusionPage(Request $request) {
  3945.         $cartRepository = $this->em->getRepository(Cart::class);
  3946.         $productRepository = $this->em->getRepository(Product::class);
  3947.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  3948.         $transactionRepository = $this->em->getRepository(Transaction::class);
  3949.         $ti = $this->em->getRepository(TransactionItem::class);
  3950.         $psRepository = $this->em->getRepository(ProductSuggestion::class);
  3952.         $hashReference = $request->get('hashReference');
  3954.         $this->data['hashReference'] = $hashReference;
  3955.         $this->data['transactionsCard'] = null;
  3956.         $this->data['transactionsPix'] = null;
  3957.         $this->data['transactionsBill'] = null;
  3958.         $this->data['productOfferSuggestions'] = null;
  3959.         
  3960.         $this->data['hasWaiting'] = true;
  3961.         $this->data['hasApproved'] = false;
  3962.         $this->data['hasCanceled'] = false;
  3963.         $this->data['showInfoStep'] = true;
  3964.         $this->data['hasContracts'] = true;
  3965.         $this->data['sOffers'] = [];
  3966.         
  3967.         $this->data['showSteps'] = true;
  3969.         if(!empty($hashReference)){
  3971.             $isCheckoutPage = $transactionRepository->existByReferenceAndOrigin(
  3972.                 $hashReference, 
  3973.                 TransactionEnum::ORIGIN_CHECKOUT_PAGE
  3974.             );
  3976.             if($isCheckoutPage){
  3977.                 $this->data['showSteps'] = false;
  3978.             }
  3980.             $hasWaiting = $transactionRepository->existByReferenceAndStatus(
  3981.                 $hashReference, 
  3982.                 TransactionEnum::WAITING
  3983.             );
  3985.             $hasApproved = $transactionRepository->existByReferenceAndStatus(
  3986.                 $hashReference, 
  3987.                 TransactionEnum::APPROVED
  3988.             );
  3990.             $hasCanceled = $transactionRepository->existByReferenceAndStatus(
  3991.                 $hashReference, 
  3992.                 TransactionEnum::CANCELED
  3993.             );
  3995.             $hasWaitingCard = $transactionRepository->existByReferenceAndStatus(
  3996.                 $hashReference, 
  3997.                 TransactionEnum::WAITING,
  3998.                 TransactionEnum::PAYMENT_CARD
  3999.             );
  4001.             $hasApprovedCard = $transactionRepository->existByReferenceAndStatus(
  4002.                 $hashReference, 
  4003.                 TransactionEnum::APPROVED,
  4004.                 TransactionEnum::PAYMENT_CARD
  4005.             );
  4007.             $hasCanceledCard = $transactionRepository->existByReferenceAndStatus(
  4008.                 $hashReference, 
  4009.                 TransactionEnum::CANCELED,
  4010.                 TransactionEnum::PAYMENT_CARD
  4011.             );
  4013.             $hasWaitingBill = $transactionRepository->existByReferenceAndStatus(
  4014.                 $hashReference, 
  4015.                 TransactionEnum::WAITING,
  4016.                 TransactionEnum::PAYMENT_BILL
  4017.             );
  4019.             $hasApprovedBill = $transactionRepository->existByReferenceAndStatus(
  4020.                 $hashReference, 
  4021.                 TransactionEnum::APPROVED,
  4022.                 TransactionEnum::PAYMENT_BILL
  4023.             );
  4025.             $hasCanceledBill = $transactionRepository->existByReferenceAndStatus(
  4026.                 $hashReference, 
  4027.                 TransactionEnum::CANCELED,
  4028.                 TransactionEnum::PAYMENT_BILL
  4029.             );
  4031.             $hasWaitingPix = $transactionRepository->existByReferenceAndStatus(
  4032.                 $hashReference,
  4033.                 TransactionEnum::WAITING,
  4034.                 TransactionEnum::PAYMENT_PIX
  4035.             );
  4037.             $hasApprovedPix = $transactionRepository->existByReferenceAndStatus(
  4038.                 $hashReference,
  4039.                 TransactionEnum::APPROVED,
  4040.                 TransactionEnum::PAYMENT_PIX
  4041.             );
  4043.             $hasCanceledPix = $transactionRepository->existByReferenceAndStatus(
  4044.                 $hashReference, 
  4045.                 TransactionEnum::CANCELED,
  4046.                 TransactionEnum::PAYMENT_PIX
  4047.             );
  4049.             $transactionsCard = $transactionRepository->getToCartConclusion(
  4050.                 $hashReference, 
  4051.                 TransactionEnum::PAYMENT_CARD
  4052.             );
  4054.             $transactionsPix = $transactionRepository->getToCartConclusion(
  4055.                 $hashReference, 
  4056.                 TransactionEnum::PAYMENT_PIX
  4057.             );
  4059.             $transactionsBill = $transactionRepository->getToCartConclusion(
  4060.                 $hashReference, 
  4061.                 TransactionEnum::PAYMENT_BILL
  4062.             );
  4064.             $transactionOffers = $productOfferRepository->getByTransactionHashReference(
  4065.                 $hashReference
  4066.             );
  4068.             if(count($transactionOffers) == TransactionEnum::YES){
  4069.                 $offer = $transactionOffers[0];
  4070.                 $productPage = $offer->getProductPage();
  4071.                 $externalPageLink = $productPage->getExternalConclusionLink();
  4073.                 if(
  4074.                     $productPage->getAllowExternalConclusion() &&
  4075.                     !empty($externalPageLink) &&
  4076.                     $hasApproved
  4077.                 ){
  4078.                     return $this->redirect($externalPageLink, 301);
  4079.                 }
  4080.             }
  4082.             $sOffers = [];
  4084.             foreach ($transactionOffers as $keyOffer => $offer) {
  4085.                 $productOfferSuggestions = $psRepository->getByOfferOriginSimply(
  4086.                     $offer,
  4087.                     ProductSuggestionEnum::EXECUTE_IN_CONCLUSION_PAGE
  4088.                 );
  4090.                 foreach ($productOfferSuggestions as $key => $productSuggestion) {
  4092.                     $productOffer = $productSuggestion->getProductOffer();
  4093.                     $product = $productOffer->getProduct();
  4095.                     if($this->user && !$productRepository->userHasProduct($this->user, $product)){
  4096.                         $productOffer->productSuggestionId = $productSuggestion->getId();
  4097.                         $productOffer->productSuggestionItem = $productSuggestion;
  4098.                         
  4099.                         if($productOffer->getAllowSaleLimit() == ProductOfferEnum::YES){
  4100.                             $saleNumber = $ti->countSalesApprovedByProductOffer(
  4101.                                 $productOffer
  4102.                             );
  4104.                             if($productOffer->getSaleNumberLimit() > $saleNumber){
  4105.                                 $sOffers[$productOffer->getId()] = $productOffer;
  4106.                             }
  4108.                         }else{
  4109.                             $sOffers[$productOffer->getId()] = $productOffer;
  4110.                         }
  4111.                     }
  4112.                 }
  4114.                 $cartRepository->sendConclusionConversion($hashReference);
  4115.             }
  4117.             try{
  4118.             
  4119.                 $transactions = array_merge(
  4120.                     $transactionsCard,
  4121.                     $transactionsPix,
  4122.                     $transactionsBill
  4123.                 );
  4125.                 $pagarMeTransaction = $this->generalService->getService(
  4126.                     'PagarMe\\PagarMeTransaction'
  4127.                 );
  4129.                 foreach ($transactions as $key => $tr) {
  4130.                     if($tr->getGateway() == TransactionEnum::EAD_CHECKOUT){
  4131.                         if($tr->getPaymentMethod() == TransactionEnum::PAYMENT_BILL){
  4132.                             $transactionPagarme = $pagarMeTransaction->get($tr->getHash());
  4133.                             $dateExpire = date(
  4134.                                 'Y-m-d', 
  4135.                                 strtotime($transactionPagarme->boleto_expiration_date)
  4136.                             );
  4138.                             $tr->setBillCode($transactionPagarme->boleto_barcode);
  4139.                             $tr->setBillLink($transactionPagarme->boleto_url);
  4140.                             $tr->setDateExpire($dateExpire);
  4141.                         }else if($tr->getPaymentMethod() == TransactionEnum::PAYMENT_PIX){
  4142.                             $transactionPagarme = $pagarMeTransaction->get($tr->getHash());
  4143.                             $dateExpire = date(
  4144.                                 'Y-m-d', 
  4145.                                 strtotime($transactionPagarme->pix_expiration_date)
  4146.                             );
  4148.                             $tr->setPixCode($transactionPagarme->pix_qr_code);
  4149.                             $tr->setDateExpire($dateExpire);
  4150.                         }
  4151.                     }
  4152.                 }
  4154.                 $this->em->flush();
  4155.             }catch(Exception $e){
  4157.             }
  4159.             $this->data['hasWaiting'] = $hasWaiting;
  4160.             $this->data['hasApproved'] = $hasApproved;
  4161.             $this->data['hasCanceled'] = $hasCanceled;
  4162.             $this->data['hasWaitingCard'] = $hasWaitingCard;
  4163.             $this->data['hasApprovedCard'] = $hasApprovedCard;
  4164.             $this->data['hasCanceledCard'] = $hasCanceledCard;
  4165.             $this->data['hasWaitingBill'] = $hasWaitingBill;
  4166.             $this->data['hasApprovedBill'] = $hasApprovedBill;
  4167.             $this->data['hasCanceledBill'] = $hasCanceledBill;
  4168.             $this->data['hasWaitingPix'] = $hasWaitingPix;
  4169.             $this->data['hasApprovedPix'] = $hasApprovedPix;
  4170.             $this->data['hasCanceledPix'] = $hasCanceledPix;
  4171.             $this->data['transactionsCard'] = $transactionsCard;
  4172.             $this->data['transactionsPix'] = $transactionsPix;
  4173.             $this->data['transactionsBill'] = $transactionsBill;
  4174.             $this->data['productOfferSuggestions'] = $sOffers;
  4175.         }
  4177.         $this->data['customCart'] = true;
  4178.         $this->data['cartConclusion'] = true;
  4180.         return $this->renderEAD('cart/cart-conclusion.html.twig');
  4181.     }
  4183.     /**
  4184.      * @Route(
  4185.      *      path          = "/cart/conclusion/status/{hashReference}/{charge}",
  4186.      *      name          = "cartConclusionCheckStatus",
  4187.      *      methods       = {"GET"},
  4188.      *      defaults      = { "hashReference" = null, "charge" = 0 }
  4189.      * )
  4190.      */
  4191.     public function cartConclusionCheckStatus(Request $request) {
  4192.         $cartRepository = $this->em->getRepository(Cart::class);
  4193.         $transactionRepository = $this->em->getRepository(Transaction::class);
  4194.         $transactionItemRepository = $this->em->getRepository(TransactionItem::class);
  4195.         $pagarMeTransaction = $this->generalService->getService(
  4196.             'PagarMe\\PagarMeTransaction'
  4197.         );
  4199.         $processEad = $this->generalService->getService('Transaction\\ProcessEad');
  4201.         $charge = $request->get('charge');
  4202.         $hashReference = $request->get('hashReference');
  4203.         if(empty($hashReference)){
  4204.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  4205.         }
  4207.         $transactions = $transactionRepository->findBy([
  4208.             "hashReference" => $hashReference,
  4209.             "deleted" => TransactionEnum::ITEM_NO_DELETED
  4210.         ]);
  4212.         $refresh = [];
  4213.         foreach ($transactions as $key => $transaction) {
  4214.             $transactionPagarme = $pagarMeTransaction->get($transaction->getHash());
  4215.             $newStatus = $pagarMeTransaction->getTransactionStatus(
  4216.                 $transactionPagarme->status
  4217.             );
  4219.             if(
  4220.                 $newStatus == TransactionEnum::APPROVED || 
  4221.                 $charge == TransactionEnum::YES && (
  4222.                     !empty($transactionPagarme->boleto_barcode) ||
  4223.                     !empty($transactionPagarme->pix_expiration_date)
  4224.                 )
  4225.             ){
  4226.                 $refresh[] = true;
  4227.             }
  4228.         }
  4230.         $this->em->flush();
  4232.         $data = [
  4233.             "refresh" => (count($refresh) == count($transactions))
  4234.         ];
  4236.         return $this->eadResponse($data, ErrorEnum::SUCCESS);
  4237.     }
  4239.     /**
  4240.      * @Route(
  4241.      *      path          = "/cart/remove/coupon/{id}",
  4242.      *      name          = "cartCouponRemove",
  4243.      *      methods       = {"GET"},
  4244.      *      requirements  = { "id" = "\d+"}
  4245.      * )
  4246.      */
  4247.     public function removeCouponProduct(Request $request) {
  4248.         $cartId = $request->get('id');
  4249.         $cartRepository = $this->em->getRepository(Cart::class);
  4251.         $cart = $cartRepository->findOneBy([
  4252.             "id" => $cartId,
  4253.             "deleted" => CartEnum::ITEM_NO_DELETED
  4254.         ]);
  4255.         
  4256.         if(!$cart){
  4257.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  4258.         }
  4260.         if($this->user){
  4261.             if($this->user->getId() != $cart->getUser()->getId()){
  4262.                 return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  4263.             }   
  4264.         }
  4266.         if($cart->getProductCoupon()){
  4267.             $product = $cart->getProduct();
  4268.             $productOffer = $cart->getProductOffer();
  4270.             $cart->setPrice($productOffer->getPriceReal());
  4271.             $cart->setMembershipFee(ProductEnum::NO);
  4273.             if(
  4274.                 $product->getType() == ProductEnum::SUBSCRIPTION ||
  4275.                 $productOffer->getAllowRecurrency() == ProductEnum::YES
  4276.             ){
  4277.                 $cart->setMembershipFee($productOffer->getMembershipFee());
  4278.             }
  4280.             $cart->setProductCoupon(null);
  4281.         }
  4283.         $this->em->flush();
  4285.         // return $this->eadResponse($cart->toReturn(), ErrorEnum::SUCCESS);
  4286.         return $this->redirectToRoute('cart');
  4287.     }
  4289.     /**
  4290.      * @Route(
  4291.      *      path          = "/delete/{id}/{isAjaxRequest}",
  4292.      *      name          = "cartDelete",
  4293.      *      methods       = {"GET"},
  4294.      *      requirements  = { "id" = "\d+" },
  4295.      *      defaults      = { "isAjaxRequest" = 0 }
  4296.      * )
  4297.      */
  4298.     public function deleteCart(Request $request) {
  4300.         $isAjaxRequest = (int)$request->get('isAjaxRequest');
  4302.         $cartId = $request->get('id');
  4303.         $cartRepository = $this->em->getRepository(Cart::class);
  4305.         $cart = $cartRepository->findOneBy([
  4306.             "id" => $cartId,
  4307.             "deleted" => CartEnum::ITEM_NO_DELETED
  4308.         ]);
  4309.         
  4310.         if(!$cart){
  4311.             if($isAjaxRequest == CartEnum::YES){
  4312.                 return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  4313.             }
  4314.             return $this->redirectToRoute('notFound');
  4315.         }
  4317.         if($this->user){
  4318.             if($this->user->getId() != $cart->getUser()->getId()){
  4319.                 if($isAjaxRequest == CartEnum::YES){
  4320.                     return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  4321.                 }
  4322.                 return $this->redirectToRoute('notFound');
  4323.             }
  4324.         }else{
  4325.             $cookieName = 'hashcartoff';
  4326.             $hashId = $this->generalService->getCookie($cookieName);
  4328.             if(empty($hashId) || $hashId != $cart->getHashIdentify()){
  4329.                 if($isAjaxRequest == CartEnum::YES){
  4330.                     return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  4331.                 }
  4332.                 return $this->redirectToRoute('notFound');
  4333.             }
  4334.         }
  4336.         $cartRepository->updateCartProductSuggestion($cart);
  4338.         if($this->user){
  4339.             $whishlistIsActive = $this->em->getRepository(Whishlist::class)->findOneBy([
  4340.                 "product" => $cart->getProduct()->getId(), 
  4341.                 "user" => $cart->getUser()->getId(),
  4342.                 "deleted" => WhishlistEnum::ITEM_NO_DELETED
  4343.             ]);
  4344.     
  4345.             $crmService = $this->generalService->getService('CRM\\CrmService');
  4346.             $dealId = $cart->getPipedriveDeal();
  4347.             $crmService->deleteDeal($dealId);
  4348.     
  4349.             if($whishlistIsActive){
  4350.                 $backWhishlist = $crmService->saveDeal(
  4351.                     $dealId,
  4352.                     $cart->getUser(),
  4353.                     $cart->getProduct(),
  4354.                     'open',
  4355.                     $this->configuration->get("pipedrive_wishlist"),
  4356.                     $cart->getPrice(),
  4357.                     $cart->getProductOffer()->getCurrencyCode()
  4358.                 );
  4359.             }    
  4360.         }
  4362.         $cart->setUtmsUrl(null);
  4363.         $cart->setProductCoupon(null);
  4364.         $cart->delete();
  4365.         $this->em->flush();
  4367.         $mkgService = $this->generalService->getService('Marketing\\MarketingService');
  4368.         $mkgService->setTag(TagsMarketingEnum::TAG_REMOVE_CART);
  4369.         $mkgService->setTextComplement($cart->getProduct()->getTitle());
  4370.         $mkgService->setUser($this->user);
  4371.         $mkgService->send();
  4373.         // AJAX
  4374.         // if($isAjaxRequest == CartEnum::YES){
  4375.             // return $this->redirectToRoute('cart');
  4376.         // }
  4378.         // NAVBAR
  4379.         return $this->redirectToRoute('cart');
  4380.     }
  4381. }