src/Controller/Website/CartController.php line 4202

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($return);
  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.             $return = $cartRepository->applyCouponUserCart(
  1175.                 $couponKey, 
  1176.                 $this->user, 
  1177.                 $hashId
  1178.             );
  1179.             $this->data['couponKeyValid'] = $return['apply'];
  1180.         }
  1182.         $this->data['formName'] = "formRegisterUserCart";
  1183.         $this->data['carts'] = null;
  1184.         $this->data['cartSubtotal'] = 0;
  1185.         $this->data['cartDisplaySubtotal'] = 0;
  1186.         $this->data['couponKey'] = $couponKey;
  1187.         $this->data['showInfoStep'] = true;
  1189.         $cartRepository = $this->em->getRepository(Cart::class);
  1190.         $customCart = false;
  1191.         $displayTotal = 0;
  1192.         $cartSubtotal = 0;
  1193.         $paymentConfig = $this->configuration->getPaymentConfig();
  1194.         if($this->user){
  1196.             $userCheckoutInfoRepository = $this->em->getRepository(
  1197.                 UserCheckoutInfo::class
  1198.             );
  1199.             $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  1200.                 "user" => $this->user->getId(),
  1201.                 "default" => UserCheckoutInfoEnum::YES,
  1202.                 "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED
  1203.             ]);
  1205.             if($userCheckoutInfo){
  1206.                 $this->data['showInfoStep'] = false;
  1207.             }
  1209.             $userId = $this->user->getId();
  1211.             $carts = $cartRepository->getUserValidCarts($userId);
  1213.             $userCards = $this->em->getRepository(UserCard::class)->getValidUserCard();
  1215.             $customCart = (
  1216.                 $cartRepository->countCustomCheckout($userId) > 0 ? true : false
  1217.             );
  1219.             $hasOnlyCourseInCart = $cartRepository->hasOnlyCourseInCart($userId);
  1221.             $cartSubtotal = $cartRepository->getUserSubTotal($userId);
  1223.             $pagarMeTransaction = $this->generalService->getService(
  1224.                 'PagarMe\\PagarMeTransaction'
  1225.             );
  1226.             $numberUtil = $this->generalService->getUtil('NumberUtil');
  1228.             $methods = [
  1229.                 ProductOfferEnum::CARD,
  1230.                 ProductOfferEnum::BILL,
  1231.                 ProductOfferEnum::PIX,
  1232.             ];
  1234.             $cardOptions = [
  1235.                 ProductOfferEnum::ALL_METHODS,
  1236.                 ProductOfferEnum::CARD,
  1237.                 ProductOfferEnum::CARD_PIX,
  1238.                 ProductOfferEnum::CARD_BILL,
  1239.             ];
  1241.             $pixOptions = [
  1242.                 ProductOfferEnum::ALL_METHODS,
  1243.                 ProductOfferEnum::PIX,
  1244.                 ProductOfferEnum::CARD_PIX,
  1245.                 ProductOfferEnum::BILL_PIX,
  1246.             ];
  1248.             $billOptions = [
  1249.                 ProductOfferEnum::ALL_METHODS,
  1250.                 ProductOfferEnum::BILL,
  1251.                 ProductOfferEnum::CARD_BILL,
  1252.                 ProductOfferEnum::BILL_PIX,
  1253.             ];
  1255.             $getPaymentOption = function(ProductOffer $productOffer) use (
  1256.                 $productOfferRepository, 
  1257.                 $cardOptions, 
  1258.                 $pixOptions, 
  1259.                 $billOptions
  1260.             ){
  1262.                 $billTypeExpire = ProductOfferEnum::BILL_PERIOD;
  1263.                 $billPeriodExpire = 7;
  1264.                 $billDateExpire = null;
  1265.                 $pixTypeExpire = ProductOfferEnum::PIX_PERIOD;
  1266.                 $pixPeriodExpire = 7;
  1267.                 $pixDateExpire = null;
  1268.                 $installmentNumberMax = 12;
  1269.                 $installmentNumberInterest = 1;
  1270.                 $freeInstallments = 1;
  1272.                 $paymentMethodOption = $productOffer->getPaymentMethod();
  1274.                 if(in_array($paymentMethodOption, $cardOptions)){
  1275.                     $installmentNumberMax = $productOffer->getInstallmentNumberMax();
  1276.                     $installmentNumberInterest = $productOffer->getInstallmentNumberInterest();
  1277.                     $freeInstallments = $productOfferRepository->getFreeInstallment(
  1278.                         $productOffer
  1279.                     );
  1280.                 }else if(in_array($paymentMethodOption, $pixOptions)){
  1281.                     $pixTypeExpire = $productOffer->getPixTypeExpire();
  1282.                     $pixPeriodExpire = $productOffer->getPixPeriodExpire();
  1283.                     $pixDateExpire = $productOffer->getPixDateExpire();
  1284.                 }else if(in_array($paymentMethodOption, $billOptions)){
  1285.                     $billTypeExpire = $productOffer->getBillTypeExpire();
  1286.                     $billPeriodExpire = $productOffer->getBillPeriodExpire();
  1287.                     $billDateExpire = $productOffer->getBillDateExpire();
  1288.                 }
  1290.                 return (object)[
  1291.                     "typeCheckout" => $productOffer->getTypeCheckout(),
  1292.                     "saleOption" => $productOffer->getSaleOption(),
  1293.                     "paymentMethod" => $paymentMethodOption,
  1294.                     "billTypeExpire" => $billTypeExpire,
  1295.                     "billPeriodExpire" => $billPeriodExpire,
  1296.                     "billDateExpire" => $billDateExpire,
  1297.                     "pixTypeExpire" => $pixTypeExpire,
  1298.                     "pixPeriodExpire" => $pixPeriodExpire,
  1299.                     "pixDateExpire" => $pixDateExpire,
  1300.                     "installmentNumberMax" => $installmentNumberMax,
  1301.                     "installmentNumberInterest" => $installmentNumberInterest,
  1302.                     "freeInstallments" => $freeInstallments,
  1303.                     "items" => [],
  1304.                 ];
  1305.             };
  1307.             $offerPaymentOptions = [];
  1309.             $internalOptions = [
  1310.                 ProductOfferEnum::INTERNAL_EAD,
  1311.                 ProductOfferEnum::INTERNAL_PAYPAL,
  1312.                 ProductOfferEnum::INTERNAL_PAGSEGURO,
  1313.                 ProductOfferEnum::INTERNAL_MERCADOPAGO,
  1314.             ];
  1316.             foreach ($carts as $key => $cart) {
  1317.                 $productOffer = $cart->getProductOffer();
  1319.                 $offerInternalOptions = json_decode($productOffer->getSaleOptionInternal());
  1320.                 if(is_array($offerInternalOptions)){
  1321.                     $internalOptions = array_intersect(
  1322.                         $internalOptions, 
  1323.                         $offerInternalOptions
  1324.                     );
  1325.                 }
  1327.                 $productOfferCouponTotal = $pcRepository->countPublicCouponByProductOffer(
  1328.                     $productOffer
  1329.                 );
  1331.                 $cart->offerPaymentOptions = null;
  1332.                 if($customCart){
  1333.                     $cart->offerPaymentOptions = $getPaymentOption($productOffer);
  1334.                     $offerPaymentOptions[] = $cart->offerPaymentOptions;
  1335.                 }
  1337.                 $cart->productOfferCouponTotal = $productOfferCouponTotal;
  1338.                 $carts[$key] = $cart;
  1339.             }
  1341.             $customCartSame = true;
  1342.             $optionCustomDefault = null;
  1343.             if(count($offerPaymentOptions) == count($carts)){
  1344.                 foreach ($offerPaymentOptions as $key => $option) {
  1345.                     if(empty($optionCustomDefault)){
  1346.                         $optionCustomDefault = $option;
  1347.                     }
  1349.                     if($optionCustomDefault != $option){
  1350.                         $customCartSame = false;
  1351.                         break;
  1352.                     }
  1353.                 }
  1354.             }
  1356.             $this->data['use_card'] = $this->configuration->get('use_card');
  1357.             $this->data['use_pix'] = $this->configuration->get('use_pix');
  1358.             $this->data['use_bill'] = $this->configuration->get('use_bill');
  1360.             $this->data['use_paypal'] = CartEnum::NO;
  1361.             $this->data['use_pagseguro'] = CartEnum::NO;
  1362.             $this->data['use_mercadopago'] = CartEnum::NO;
  1363.                 
  1364.             if(is_array($internalOptions)){
  1366.                 $this->data['use_paypal'] = (
  1367.                     in_array(ProductOfferEnum::INTERNAL_PAYPAL, $internalOptions) ? 
  1368.                     CartEnum::YES : 
  1369.                     CartEnum::NO
  1370.                 );
  1372.                 $this->data['use_pagseguro'] = (
  1373.                     in_array(ProductOfferEnum::INTERNAL_PAGSEGURO, $internalOptions) ? 
  1374.                     CartEnum::YES : 
  1375.                     CartEnum::NO
  1376.                 );
  1378.                 $this->data['use_mercadopago'] = (
  1379.                     in_array(ProductOfferEnum::INTERNAL_MERCADOPAGO, $internalOptions) ? 
  1380.                     CartEnum::YES : 
  1381.                     CartEnum::NO
  1382.                 );
  1383.             }
  1385.             $this->data['isOneMethod'] = CartEnum::NO;
  1386.             $this->data['isOneMethodType'] = null;
  1388.             if($customCartSame && $optionCustomDefault){
  1389.                 $customCart = false;
  1391.                 $methodsInUse = [];
  1393.                 $this->data['use_card'] = CartEnum::NO;
  1394.                 $this->data['use_pix'] = CartEnum::NO;
  1395.                 $this->data['use_bill'] = CartEnum::NO;
  1397.                 if(in_array($optionCustomDefault->paymentMethod, $cardOptions)){
  1398.                     $this->data['use_card'] = CartEnum::YES;
  1399.                     $methodsInUse[] = CartEnum::PAYMENT_CARD;
  1400.                 }
  1402.                 if(in_array($optionCustomDefault->paymentMethod, $pixOptions)){
  1403.                     $this->data['use_pix'] = CartEnum::YES;
  1404.                     $methodsInUse[] = CartEnum::PAYMENT_PIX;
  1405.                 }
  1407.                 if(in_array($optionCustomDefault->paymentMethod, $billOptions)){
  1408.                     $this->data['use_bill'] = CartEnum::YES;
  1409.                     $methodsInUse[] = CartEnum::PAYMENT_BILL;
  1410.                 }
  1412.                 if(count($methodsInUse) == CartEnum::YES){
  1413.                     $this->data['isOneMethod'] = CartEnum::YES;
  1414.                     $this->data['isOneMethodType'] = end($methodsInUse);
  1415.                 }
  1417.                 $freeInstallments = $optionCustomDefault->installmentNumberInterest;
  1418.                 /*if($paymentConfig->assumeInstallmentInterest == ProductOfferEnum::YES){
  1419.                     $freeInstallments = 12;
  1420.                 }*/
  1422.                 $parcelInfo = $numberUtil->getNumberMaxParcel(
  1423.                     $cartSubtotal * 100,
  1424.                     $optionCustomDefault->installmentNumberMax, 
  1425.                     $freeInstallments, 
  1426.                     ProductOfferEnum::EAD,
  1427.                     ProductOfferEnum::CHECKOUT_CUSTOM
  1428.                 );
  1430.                 $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  1431.                     'amount' => $numberUtil->numberToCents($cartSubtotal),
  1432.                     'free_installments' => $freeInstallments,
  1433.                     'max_installments' => $parcelInfo->maxInstallments,
  1434.                     'interest_rate' => $paymentConfig->installmentInterest
  1435.                 ]);
  1436.                 $this->data['installmentsOptions'] = (array)$installmentsOptions;
  1438.             }else if($customCart){
  1440.                 $steps = [];
  1442.                 $auxOption = [];
  1443.                 foreach ($offerPaymentOptions as $key => $value) {
  1444.                     if(!in_array($value, $auxOption)){
  1445.                         $auxOption[] = $value;
  1446.                     }
  1447.                 }
  1449.                 $offerPaymentOptions = $auxOption;
  1451.                 $defaultObj = (object)[
  1452.                     "amountStep" => 0,
  1453.                     "amountStepCent" => 0,
  1454.                     "items" => [],
  1455.                     "installmentsOptions" => null,
  1456.                     "freeInstallments" => 1,
  1457.                     "useCard" => $this->configuration->get('use_card'),
  1458.                     "usePix" => $this->configuration->get('use_pix'),
  1459.                     "useBill" => $this->configuration->get('use_bill'),
  1460.                     "installmentNumberMax" => $paymentConfig->installmentNumberMax,
  1461.                     "assumeInstallmentInterest" => $paymentConfig->assumeInstallmentInterest,
  1462.                     "installmentNumberInterest" => $paymentConfig->installmentNumberInterest,
  1463.                     "default" => true,
  1464.                 ];
  1466.                 $defaultSubtotalCent = 0;
  1467.                 $defaultInstallmentsOptions = null;
  1469.                 foreach ($carts as $key => $cart) {
  1471.                     $cart->setAble(CartEnum::YES);
  1473.                     $productOffer = $cart->getProductOffer();
  1474.                     if($productOffer->getTypeCheckout() == ProductOfferEnum::CHECKOUT_DEFAULT){
  1475.                         $price = $cart->getPrice() + $cart->getMembershipFee();
  1476.                         $priceCents = $cart->getPrice(true) + $cart->getMembershipFee(true);
  1478.                         $defaultObj->amountStep = $defaultObj->amountStep + $price;
  1479.                         $defaultObj->amountStepCent = $defaultObj->amountStepCent + $priceCents;
  1480.                         $defaultObj->items[] = $cart;
  1481.                     }else{
  1482.                         $indexOptions = array_search(
  1483.                             $cart->offerPaymentOptions,
  1484.                             $offerPaymentOptions
  1485.                         );
  1487.                         if(isset($offerPaymentOptions[$indexOptions])){
  1488.                             $offerPaymentOptions[$indexOptions]->items[] = $cart;
  1489.                         }
  1490.                     }
  1491.                 }
  1493.                 foreach ($offerPaymentOptions as $key => $option) {
  1494.                     if(count($option->items)){
  1495.                         $option->useCard = in_array($option->paymentMethod, $cardOptions);
  1496.                         $option->usePix = in_array($option->paymentMethod, $pixOptions);
  1497.                         $option->useBill = in_array($option->paymentMethod, $billOptions);
  1499.                         $amountOption = 0;
  1500.                         $amountOptionCents = 0;
  1502.                         foreach ($option->items as $keyItem => $item) {
  1503.                             $productOffer = $item->getProductOffer();
  1504.                             $amountOption = $amountOption + $item->getPrice() + $item->getMembershipFee();
  1505.                             $amountOptionCents = $amountOptionCents + $item->getPrice(true) + $item->getMembershipFee(true);
  1506.                         }
  1507.                         
  1508.                         $installmentsOptions = null;
  1509.                         if($option->useCard){
  1510.                             $parcelInfo = $numberUtil->getNumberMaxParcel(
  1511.                                 $amountOptionCents,
  1512.                                 $option->installmentNumberMax,
  1513.                                 $option->freeInstallments,
  1514.                                 $option->saleOption,
  1515.                                 $option->typeCheckout
  1516.                             );
  1518.                             $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  1519.                                 'amount' => $amountOptionCents,
  1520.                                 'free_installments' => $option->freeInstallments,
  1521.                                 'max_installments' => $parcelInfo->maxInstallments,
  1522.                                 'interest_rate' => $paymentConfig->installmentInterest
  1523.                             ]);
  1525.                             $installmentsOptions = (array)$installmentsOptions;
  1526.                         }
  1528.                         $newStep = (object)[
  1529.                             'amountStep' => $amountOption,
  1530.                             'amountStepCent' => $amountOptionCents,
  1531.                             "items" => $option->items,
  1532.                             "installmentsOptions" => $installmentsOptions,
  1533.                             "freeInstallments" => 1,
  1534.                             "useCard" => $option->useCard,
  1535.                             "usePix" => $option->usePix,
  1536.                             "useBill" => $option->useBill,
  1537.                             "installmentNumberMax" => $option->installmentNumberMax,
  1538.                             "assumeInstallmentInterest" => ProductOfferEnum::NO,
  1539.                             "installmentNumberInterest" => $option->installmentNumberInterest,
  1540.                             "default" => false
  1541.                         ];
  1543.                         if($option->useCard){
  1544.                             $this->data['use_card'] = CartEnum::YES;
  1545.                         }
  1547.                         if($option->usePix){
  1548.                             $this->data['use_pix'] = CartEnum::YES;
  1549.                         }
  1551.                         if($option->useBill){
  1552.                             $this->data['use_bill'] = CartEnum::YES;
  1553.                         }
  1555.                         $steps[] = $newStep;
  1556.                     }
  1557.                 }
  1559.                 if(count($defaultObj->items)){
  1560.                     
  1561.                     $defaultObj->freeInstallments = $paymentConfig->installmentNumberInterest;
  1562.                     if($paymentConfig->assumeInstallmentInterest == ProductOfferEnum::YES){
  1563.                         $defaultObj->freeInstallments = 12;
  1564.                     }
  1566.                     $parcelInfo = $numberUtil->getNumberMaxParcel(
  1567.                         $defaultObj->amountStepCent, 
  1568.                         $paymentConfig->installmentNumberMax, 
  1569.                         $defaultObj->freeInstallments, 
  1570.                         ProductOfferEnum::EAD,
  1571.                         ProductOfferEnum::CHECKOUT_DEFAULT
  1572.                     );
  1574.                     $defaultOptions = (array)$pagarMeTransaction->calculateInstallments([
  1575.                         'amount' => $defaultObj->amountStepCent,
  1576.                         'free_installments' => $defaultObj->freeInstallments,
  1577.                         'max_installments' => $parcelInfo->maxInstallments,
  1578.                         'interest_rate' => $paymentConfig->installmentInterest
  1579.                     ]);
  1581.                     $defaultObj->installmentsOptions = $defaultOptions;
  1582.                     
  1583.                     array_unshift($steps, $defaultObj);
  1584.                 }
  1586.                 $this->data['steps'] = $steps;
  1587.             }else{
  1589.                 $freeInstallments = $paymentConfig->installmentNumberInterest;
  1590.                 if($paymentConfig->assumeInstallmentInterest == ProductOfferEnum::YES){
  1591.                     $freeInstallments = 12;
  1592.                 }
  1594.                 $parcelInfo = $numberUtil->getNumberMaxParcel(
  1595.                     $cartSubtotal * 100,
  1596.                     $paymentConfig->installmentNumberMax, 
  1597.                     $freeInstallments, 
  1598.                     ProductOfferEnum::EAD,
  1599.                     ProductOfferEnum::CHECKOUT_DEFAULT
  1600.                 );
  1602.                 $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  1603.                     'amount' => $numberUtil->numberToCents($cartSubtotal),
  1604.                     'free_installments' => $freeInstallments,
  1605.                     'max_installments' => $parcelInfo->maxInstallments,
  1606.                     'interest_rate' => $paymentConfig->installmentInterest
  1607.                 ]);
  1608.                 $this->data['installmentsOptions'] = (array)$installmentsOptions;
  1609.             }
  1611.             $receiverSchoolEad = $this->configuration->getReceiverSchool(
  1612.                 ReceiverEnum::EAD_CHECKOUT
  1613.             );
  1614.             $receiverSchoolPayPal = $this->configuration->getReceiverSchool(
  1615.                 ReceiverEnum::PAYPAL
  1616.             );
  1617.             $receiverSchoolPagSeguro = $this->configuration->getReceiverSchool(
  1618.                 ReceiverEnum::PAGSEGURO
  1619.             );
  1620.             $receiverSchoolMercadoPago = $this->configuration->getReceiverSchool(
  1621.                 ReceiverEnum::MERCADO_PAGO
  1622.             );
  1624.             $displayTotal = $cartRepository->getUserDisplaySubTotal($userId);
  1626.             $this->data['receiverSchoolEad'] = $receiverSchoolEad;
  1627.             $this->data['receiverSchoolPayPal'] = $receiverSchoolPayPal;
  1628.             $this->data['receiverSchoolPagSeguro'] = $receiverSchoolPagSeguro;
  1629.             $this->data['receiverSchoolMercadoPago'] = $receiverSchoolMercadoPago;
  1630.             $this->data['cartSubtotal'] = $cartSubtotal;
  1631.             $this->data['cartDisplaySubtotal'] = $displayTotal;
  1632.             $this->data['userCards'] = $userCards;
  1633.             $this->data['hasOnlyCourseInCart'] = $hasOnlyCourseInCart;
  1634.             $this->data['carts'] = $carts;
  1636.         }else if(!empty($hashId)){
  1638.             $cartInfo = $cartRepository->getHashValidCartsInfo($hashId);
  1639.             $customCart = ($cartInfo->totalCustom > 0 ? true : false);
  1640.             $carts = $cartInfo->data;
  1642.             foreach ($carts as $key => $cart) {
  1644.                 $cart->setAble(CartEnum::YES);
  1646.                 $productOffer = $cart->getProductOffer();
  1647.                 $productOfferCouponTotal = $pcRepository->countPublicCouponByProductOffer(
  1648.                     $productOffer
  1649.                 );
  1651.                 $cart->productOfferCouponTotal = $productOfferCouponTotal;
  1652.                 $carts[$key] = $cart;
  1653.             }
  1655.             $this->data['carts'] = $carts;
  1656.             $this->data['cartSubtotal'] = $cartInfo->totalPrice;
  1657.             $this->data['cartDisplaySubtotal'] = $cartInfo->totalDisplay;
  1658.         }
  1660.         $this->data['keyCaptcha'] = $this->createCaptchaKey($request);
  1662.         $this->data['customCart'] = $customCart;
  1663.         $this->data['cartSubtotalDiff'] = $displayTotal - $cartSubtotal;
  1664.         $this->data['isCart'] = true;
  1665.         $this->data['urlPost'] = $this->generalService->generateUrl("cartCheckoutDefault");
  1666.         $this->data['urlConclusion'] = $this->generalService->generateUrl("cartConclusion");
  1667.         $this->em->flush();
  1669.         if(empty($this->data['carts'])){
  1670.             $this->data['carts'] = [];
  1671.         }
  1673.         return $this->renderEAD('cart/cart.html.twig');
  1674.     }
  1676.     /**
  1677.      * @Route(
  1678.      *      path          = "/cart/indvidual/{poHash}/{pcKey}",
  1679.      *      name          = "cartIndividual",
  1680.      *      methods       = {"GET"},
  1681.      *      defaults      = { "pcKey" = "" }
  1682.      * )
  1683.      */
  1684.     public function cartPageIndvidual(Request $request) {
  1686.         $cartRepository = $this->em->getRepository(Cart::class);
  1687.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  1688.         $productCouponRepository = $this->em->getRepository(ProductCoupon::class);
  1689.         $productRepository = $this->em->getRepository(Product::class);
  1691.         $offerHash = $request->get('poHash');
  1692.         $productOffer = $productOfferRepository->getProductByOfferLink($offerHash);
  1693.         if(!$productOffer){
  1694.             return $this->redirectToRoute('notFound');
  1695.         }
  1697.         $product = $productOffer->getProduct();
  1698.         if($productOffer->getAllowTrial() == ProductOfferEnum::NO){
  1699.             return $this->redirectToRoute('notFound');
  1700.         }
  1702.         $productPage = $productOffer->getProductPage();
  1703.         if(!$productPage){
  1704.             return $this->redirectToRoute('notFound');
  1705.         }
  1707.         if($productOffer->getSaleChannel() == ProductOfferEnum::EXTERNAL){
  1708.             $externalCheckoutLink = $productOffer->getExternalCheckoutLink();
  1709.             return $this->redirect($externalCheckoutLink, 301);
  1710.         }
  1711.         
  1712.         $externalPage = $productPage->getExternalPage();
  1713.         $externalPageLink = $productPage->getExternalPageLink();
  1714.         if($externalPage == ProductEnum::YES && !empty($externalPageLink)){
  1715.             //return $this->redirect($externalPageLink, 301);
  1716.         }
  1717.         
  1718.         $productCoupon = null;
  1719.         $couponKey = $request->get('pcKey');
  1720.         $couponKeyValid = false;
  1721.         
  1722.         if(!empty($couponKey)){
  1723.             $productCoupon = $productCouponRepository->findValidProductCouponByProductOffer(
  1724.                 $couponKey,
  1725.                 $productOffer
  1726.             );
  1728.             if($productCoupon){
  1729.                 $amount = $productOffer->getPriceReal();
  1731.                 if(
  1732.                     $productCouponRepository->checkApplyCoupon($productCoupon, $productOffer)
  1733.                 ){
  1734.                     $amount = $productCouponRepository->applyDiscount(
  1735.                         $productCoupon,
  1736.                         $amount
  1737.                     );
  1739.                     $couponKeyValid = true;
  1740.                 }
  1742.                 if(!empty($amount)){
  1743.                     $productOffer->setPriceRealCopy($amount);
  1744.                 }
  1745.             }
  1746.         }
  1748.         if(
  1749.             $this->user &&
  1750.             (
  1751.                 $product->getType() == ProductEnum::SUBSCRIPTION || 
  1752.                 $productOffer->getAllowRecurrency() == ProductEnum::YES
  1753.             )
  1754.         ){
  1755.             $userSubscriptionRepository = $this->em->getRepository(UserSubscription::class);
  1756.             $userSubscription = $userSubscriptionRepository->findOneBy([
  1757.                 "user" => $this->user->getId(),
  1758.                 "product" => $product->getId(),
  1759.                 "deleted" => UserSubscriptionEnum::ITEM_NO_DELETED,
  1760.             ]);
  1762.             if($userSubscription){
  1763.                 if(
  1764.                     $userSubscription->getStatus() == UserSubscriptionEnum::STATUS_COMPLETED ||
  1765.                     $userSubscription->getStatus() == UserSubscriptionEnum::STATUS_CANCELED
  1766.                 ){
  1767.                     $params = [
  1768.                         "poID" => $productOffer->getId(),
  1769.                         "pcID" => ( $productCoupon ? $productCoupon->getId() : 0 ),
  1770.                     ];
  1772.                     return $this->redirectToRoute('cartAdd', $params);
  1773.                 }
  1775.                 return $this->redirectToRoute('notFound');
  1776.             }
  1777.         }
  1779.         $this->data['couponKey'] = $couponKey;
  1780.         $this->data['couponKeyValid'] = $couponKeyValid;
  1781.         $this->data['showInfoStep'] = true;
  1783.         $customCart = false;
  1784.         $displayTotal = $productOffer->getPriceDisplay();
  1785.         $cartSubtotal = $productOffer->getPriceRealCopy();
  1786.         $hasOnlyCourseInCart = true;
  1787.         $paymentConfig = $this->configuration->getPaymentConfig();
  1788.         $userCards = [];
  1790.         if($this->user){
  1792.             $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  1793.             $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  1794.                 "user" => $this->user->getId(),
  1795.                 "default" => UserCheckoutInfoEnum::YES,
  1796.                 "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED
  1797.             ]);
  1799.             if($userCheckoutInfo){
  1800.                 $this->data['showInfoStep'] = false;
  1801.             }
  1803.             $userCards = $this->em->getRepository(UserCard::class)->getValidUserCard();
  1804.         }
  1806.         $pagarMeTransaction = $this->generalService->getService('PagarMe\\PagarMeTransaction');
  1807.         $numberUtil = $this->generalService->getUtil('NumberUtil');
  1809.         $useCard = $productOfferRepository->produtOfferAllowCard($productOffer);
  1810.         $useBill = $productOfferRepository->produtOfferAllowBill($productOffer);
  1811.         $usePix = $productOfferRepository->produtOfferAllowPix($productOffer);
  1813.         $internalOptions = json_decode($productOffer->getSaleOptionInternal());
  1814.         
  1815.         $this->data['use_paypal'] = CartEnum::NO;
  1816.         $this->data['use_pagseguro'] = CartEnum::NO;
  1817.         $this->data['use_mercadopago'] = CartEnum::NO;
  1819.         if(is_array($internalOptions)){
  1820.             $this->data['use_paypal'] = (
  1821.                 in_array(ProductOfferEnum::INTERNAL_PAYPAL, $internalOptions) ? 
  1822.                 CartEnum::YES : 
  1823.                 CartEnum::NO
  1824.             );
  1826.             $this->data['use_pagseguro'] = (
  1827.                 in_array(ProductOfferEnum::INTERNAL_PAGSEGURO, $internalOptions) ? 
  1828.                 CartEnum::YES : 
  1829.                 CartEnum::NO
  1830.             );
  1832.             $this->data['use_mercadopago'] = (
  1833.                 in_array(ProductOfferEnum::INTERNAL_MERCADOPAGO, $internalOptions) ? 
  1834.                 CartEnum::YES : 
  1835.                 CartEnum::NO
  1836.             );
  1837.         }
  1839.         $hasTrue = [
  1840.             $useCard == CartEnum::YES && $useBill == CartEnum::NO && $usePix == CartEnum::NO,
  1841.             $useCard == CartEnum::NO && $useBill == CartEnum::YES && $usePix == CartEnum::NO,
  1842.             $useCard == CartEnum::NO && $useBill == CartEnum::NO && $usePix == CartEnum::YES,
  1843.         ];
  1845.         $paymentMethod = [
  1846.             CartEnum::PAYMENT_CARD,
  1847.             CartEnum::PAYMENT_BILL,
  1848.             CartEnum::PAYMENT_PIX,
  1849.         ];
  1851.         $this->data['use_card'] = $useCard;
  1852.         $this->data['use_bill'] = $useBill;
  1853.         $this->data['use_pix'] = $usePix;
  1855.         $key = array_search(true, $hasTrue);
  1857.         $this->data['isOneMethod'] = (!empty($key) ? CartEnum::YES : CartEnum::NO);
  1858.         $this->data['isOneMethodType'] = (!empty($key) ? $paymentMethod[$key] : null);
  1860.         $freeInstallments = $productOfferRepository->getFreeInstallment($productOffer);
  1861.         $maxInstallments = $productOfferRepository->getInstallmentNumberMax($productOffer);
  1863.         $parcelInfo = $numberUtil->getNumberMaxParcel(
  1864.             $cartSubtotal * 100,
  1865.             $maxInstallments, 
  1866.             $freeInstallments, 
  1867.             ProductOfferEnum::EAD,
  1868.             $productOffer->getTypeCheckout()
  1869.         );
  1871.         $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  1872.             'amount' => $numberUtil->numberToCents($cartSubtotal),
  1873.             'free_installments' => $freeInstallments,
  1874.             'max_installments' => $parcelInfo->maxInstallments,
  1875.             'interest_rate' => $paymentConfig->installmentInterest
  1876.         ]);
  1878.         $this->data['installmentsOptions'] = (array)$installmentsOptions;
  1880.         $receiverSchoolEad = $this->configuration->getReceiverSchool(
  1881.             ReceiverEnum::EAD_CHECKOUT
  1882.         );
  1883.         $receiverSchoolPayPal = $this->configuration->getReceiverSchool(
  1884.             ReceiverEnum::PAYPAL
  1885.         );
  1886.         $receiverSchoolPagSeguro = $this->configuration->getReceiverSchool(
  1887.             ReceiverEnum::PAGSEGURO
  1888.         );
  1889.         $receiverSchoolMercadoPago = $this->configuration->getReceiverSchool(
  1890.             ReceiverEnum::MERCADO_PAGO
  1891.         );
  1893.         $this->data['receiverSchoolEad'] = $receiverSchoolEad;
  1894.         $this->data['receiverSchoolPayPal'] = $receiverSchoolPayPal;
  1895.         $this->data['receiverSchoolPagSeguro'] = $receiverSchoolPagSeguro;
  1896.         $this->data['receiverSchoolMercadoPago'] = $receiverSchoolMercadoPago;
  1898.         $this->data['cartSubtotal'] = CartEnum::NO;//$cartSubtotal;
  1899.         $this->data['cartDisplaySubtotal'] = CartEnum::NO;//$displayTotal;
  1900.         $this->data['cartSubtotalDiff'] = CartEnum::NO;//$displayTotal - $cartSubtotal;
  1902.         $this->data['userCards'] = $userCards;
  1903.         $this->data['hasOnlyCourseInCart'] = $hasOnlyCourseInCart;
  1905.         $cart = new Cart();
  1907.         $hashIdentify = $this->generalService->getCookieHashIdentify();
  1908.         
  1909.         $cart->setProductOffer($productOffer);
  1910.         $cart->setProduct($product);
  1912.         if($productCoupon && $couponKeyValid){
  1913.             $cart->setProductCoupon($productCoupon);
  1914.         }
  1916.         if($this->user){
  1917.             $cart->setUser($this->user);
  1918.             $cart->setHashIdentify($this->user->getHashIdentify());
  1919.         }else if(!empty($hashIdentify)){
  1920.             $cart->setHashIdentify($hashIdentify);
  1921.         }
  1923.         $cart->setPrice($productOffer->getPriceRealCopy());
  1925.         if(
  1926.             $product->getType() == ProductEnum::SUBSCRIPTION || 
  1927.             $productOffer->getAllowRecurrency() == ProductEnum::YES
  1928.         ){
  1929.             $cart->setMembershipFee($productOffer->getMembershipFeeCopy());
  1930.         }
  1932.         $cart->setProductType($product->getType());
  1934.         $productOfferCouponTotal = $productCouponRepository->countPublicCouponByProductOffer(
  1935.             $productOffer
  1936.         );
  1938.         $cart->offerPaymentOptions = null;
  1939.         $cart->productOfferCouponTotal = $productOfferCouponTotal;
  1941.         $this->data['carts'] = [
  1942.             $cart
  1943.         ];
  1945.         $this->data['keyCaptcha'] = $this->createCaptchaKey($request);
  1946.         $this->data['customCart'] = $customCart;
  1947.         $this->data['isCart'] = false;
  1948.         $this->data['urlPost'] = $this->generalService->generateUrl(
  1949.             "cartCheckoutPlanTrial", 
  1950.             [
  1951.                 "poID" => $productOffer->getId(),
  1952.                 "pcID" => ($productCoupon ? $productCoupon->getId() : null),
  1953.             ]
  1954.         );
  1956.         $this->data['urlRedirect'] = $this->generalService->generateUrl(
  1957.             "cartIndividual", 
  1958.             [
  1959.                 "poHash" => $offerHash,
  1960.                 "pcKey" => ($couponKey ? $couponKey : null),
  1961.             ]
  1962.         ) . "#cart-step-info";
  1964.         $this->data['urlConclusion'] = $this->generalService->generateUrl("cartConclusion");
  1966.         $this->em->flush();
  1968.         if(empty($this->data['carts'])){
  1969.             $this->data['carts'] = [];
  1970.         }
  1972.         return $this->renderEAD('cart/cart.html.twig');
  1973.     }
  1975.     /**
  1976.      * @Route(
  1977.      *      path    = "/admin/cart/user/valid",
  1978.      *      name    = "getUserValidCarts",
  1979.      *      methods = {"GET"}
  1980.      * )
  1981.      */
  1982.     public function getUserValidCarts(Request $request){
  1983.         if (!$this->user) {
  1984.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  1985.         }
  1987.         $cartRepository = $this->em->getRepository(Cart::class);
  1988.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  1990.         $userId = $this->user->getId();
  1992.         $carts = $cartRepository->getUserValidCarts($userId);
  1994.         $paymentConfig = $this->configuration->getPaymentConfig();
  1996.         $fileService = $this->generalService->getService('FileService');
  1997.         $data = [];
  1999.         foreach ($carts as $key => $cart) {
  2001.             $productOffer = $cart->getProductOffer();
  2002.             $billDateExpire = $productOfferRepository->getDateExpireBill($productOffer);
  2003.             $pixDateExpire = $productOfferRepository->getDateExpirePix($productOffer);
  2005.             $photo = $fileService->getFilePathComplete(
  2006.                 $cart->getProductOffer()->getProductPage()->getPhoto(),
  2007.                 ProductEnum::PATH_PRODUCT_PHOTO,
  2008.                 true,
  2009.                 false,
  2010.                 'product-photo',
  2011.                 true
  2012.             );
  2014.             $onErrorPhoto = $fileService->getFilePathComplete(
  2015.                 $cart->getProductOffer()->getProductPage()->getPhoto(),
  2016.                 ProductEnum::PATH_PRODUCT_PHOTO,
  2017.                 true,
  2018.                 false,
  2019.                 'product-photo',
  2020.                 false
  2021.             );
  2023.             $price = (float)($cart->getPrice() + $cart->getMembershipFee());
  2024.             $membershipFee = (float)$productOffer->getMembershipFee();
  2025.             $priceReal = (float)($productOffer->getPriceReal() + $membershipFee);
  2026.             $priceDiscount = (float)$price - $priceReal;
  2027.             $priceDisplay = (float)$productOffer->getPriceDisplay();
  2028.             
  2029.             if(!empty($priceDisplay)){
  2030.                 $priceDisplay = (float)($priceDisplay + $membershipFee);
  2031.                 $priceDiscount = $price - $priceDisplay;
  2032.             }
  2034.             $recurrency = (
  2035.                 $cart->getProduct()->getType() == ProductEnum::SUBSCRIPTION ||
  2036.                 $productOffer->getAllowRecurrency() == ProductEnum::YES
  2037.             )? true : false;
  2039.             $item = (object)[
  2040.                 "id" => $cart->getId(),
  2041.                 "title" => $cart->getProduct()->getTitle(),
  2042.                 "photo" => $photo,
  2043.                 "onErrorPhoto" => $onErrorPhoto,
  2044.                 "able" => ($cart->getAble() == CartEnum::YES),
  2045.                 "priceOrigin" => (float)$cart->getPrice(),
  2046.                 "membershipFeeOrigin" => (float)$productOffer->getMembershipFee(),
  2047.                 "membershipFeeReal" => (float)$cart->getMembershipFee(),
  2048.                 "priceReal" => $priceReal,
  2049.                 "price" => (float)$price,
  2050.                 "priceReal" => $priceReal,
  2051.                 "priceDisplay" => (float)$priceDisplay,
  2052.                 "priceDiscount" => (float)$priceDiscount,
  2053.                 "couponKey" => (
  2054.                     $cart->getProductCoupon() ? $cart->getProductCoupon()->getKey() : null
  2055.                 ),
  2056.                 "couponMembershipFee" => (int)(
  2057.                     $cart->getProductCoupon() ?
  2058.                     $cart->getProductCoupon()->getApplyMembershipFee() : 
  2059.                     ProductEnum::NO
  2060.                 ),
  2061.                 "billDateExpire" => $billDateExpire,
  2062.                 "pixDateExpire" => $pixDateExpire,
  2063.                 "interestFee" => $paymentConfig->installmentInterest,
  2064.                 "currencySymbol" => $productOffer->getCurrencySymbol(),
  2065.                 "paymentCycle" => $productOffer->getPlanCycle(),
  2066.                 "recurrency" => $recurrency,
  2067.             ];
  2069.             $data[] = $item;
  2070.         }
  2072.         return $this->eadResponse($data);
  2073.     }
  2075.     /**
  2076.      * @Route(
  2077.      *      path          = "/admin/cart/change/status",
  2078.      *      name          = "cartChangeStatus",
  2079.      *      methods       = {"PUT"}
  2080.      * )
  2081.      */
  2082.     public function updateCartStatus(Request $request){
  2083.         if (!$this->user) {
  2084.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  2085.         }
  2087.         $this->requestUtil->setRequest($request)->setData();
  2089.         $cartId = $this->requestUtil->getField('cart');
  2090.         $able = $this->requestUtil->getField('able');
  2092.         $cartRepository = $this->em->getRepository(Cart::class);
  2093.         $userId = $this->user->getId();
  2095.         $cart = $cartRepository->findOneBy([
  2096.             "id" => $cartId,
  2097.             "user" => $userId,
  2098.             "deleted" => CartEnum::ITEM_NO_DELETED,
  2099.         ]);
  2101.         if(!$cart){
  2102.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  2103.         }
  2105.         $cart->setAble($able);
  2107.         $this->em->flush();
  2109.         return $this->eadResponse([ "success" => 1 ]);
  2110.     }
  2113.     /**
  2114.      * @Route(
  2115.      *      path          = "/cart/checkout/paypal",
  2116.      *      name          = "cartCheckoutPaypal",
  2117.      *      methods       = {"GET"}
  2118.      * )
  2119.      */
  2120.     public function checkoutPayPal(Request $request){
  2121.         $this->checkUserSession($request);
  2123.         $receiverSchool = $this->configuration->getReceiverSchool(ReceiverEnum::PAYPAL);
  2124.         if(!$receiverSchool){
  2125.             return $this->redirectToRoute('notFound');
  2126.         }
  2128.         $this->requestUtil->setRequest($request)->setData();
  2130.         $cartRepository = $this->em->getRepository(Cart::class);
  2132.         $hasOnlyCourseInCart = $cartRepository->hasOnlyCourseInCart($this->user->getId());
  2133.         if(!$hasOnlyCourseInCart){
  2134.             return $this->redirectToRoute('notFound');
  2135.         }
  2137.         $currencyCode = $this->configuration->get('currency_code');
  2138.         $userCheckoutInfoId = $this->requestUtil->getField('userCheckoutInfoId');
  2140.         $transactionData = [
  2141.             "cmd" => "_cart",
  2142.             "business" => $receiverSchool->getEmail(),
  2143.             "upload" => 1,
  2144.             "currency_code" => ( $currencyCode ? $currencyCode : "BRL" ),
  2145.             "charset" => "UTF-8",
  2146.         ];
  2148.         $dataCustom = [];
  2150.         $carts = $cartRepository->getUserValidCarts($this->user->getId());
  2151.         if(empty($carts)){
  2152.             return $this->redirectToRoute('notFound');
  2153.         }
  2155.         foreach ($carts as $key => $cart) {
  2156.             $index = $key + 1;
  2158.             $product = $cart->getProduct();
  2159.             $productOffer = $cart->getProductOffer();
  2161.             $title = $this->stringUtil->shortTextClean($product->getTitle(), 30);
  2162.             $title = $this->stringUtil->cleanString2($title);
  2164.             $transactionData["item_number_{$index}"] = $product->getId();
  2165.             $transactionData["item_name_{$index}"] = $title;
  2166.             $transactionData["amount_{$index}"] = $cart->getPrice();
  2167.             $transactionData["quantity_{$index}"] = 1;
  2169.             $dataCustom["cart_{$index}"] = $cart->getId();
  2170.             $dataCustom["amount_{$index}"] = $cart->getPrice();
  2171.             $dataCustom["offer_{$index}"] = $productOffer->getId();
  2172.             
  2173.             $productCoupon = $cart->getProductCoupon();
  2174.             if($productCoupon){
  2175.                 $dataCustom["coupon_{$index}"] = $productCoupon->getId();
  2176.             }
  2177.         }
  2179.         $dataCustom["new"] = CartEnum::YES;
  2180.         $dataCustom["userId"] = $this->user->getId();
  2181.         $dataCustom["numberItens"] = count($carts);
  2182.         $dataCustom["userCheckoutInfoId"] = $userCheckoutInfoId;
  2184.         $transactionData["custom"] = json_encode($dataCustom);
  2185.         $transactionData["return"] = "https://{$this->eadDomain}/resume/";
  2186.         $transactionData["notify_url"] = "https://{$this->eadDomain}/paypal/";
  2188.         $transactionData = http_build_query($transactionData);
  2190.         $payPal = $this->generalService->getService('PayPal\\PayPal');
  2191.         $url = "{$payPal->getPayPalAddress()}?{$transactionData}";
  2193.         return $this->redirect($url, 301);
  2194.     }
  2196.     /**
  2197.      * @Route(
  2198.      *      path          = "/cart/checkout/pagseguro",
  2199.      *      name          = "cartCheckoutPagseguro",
  2200.      *      methods       = {"GET"}
  2201.      * )
  2202.      */
  2203.     public function checkoutPagSeguro(Request $request){
  2204.         $this->checkUserSession($request);
  2206.         $receiverSchool = $this->configuration->getReceiverSchool(ReceiverEnum::PAGSEGURO);
  2207.         if(!$receiverSchool){
  2208.             return $this->redirectToRoute('notFound');
  2209.         }
  2211.         $this->requestUtil->setRequest($request)->setData();
  2213.         $cartRepository = $this->em->getRepository(Cart::class);
  2215.         $hasOnlyCourseInCart = $cartRepository->hasOnlyCourseInCart($this->user->getId());
  2216.         if(!$hasOnlyCourseInCart){
  2217.             return $this->redirectToRoute('notFound');
  2218.         }
  2220.         $userCheckoutInfoId = $this->requestUtil->getField('userCheckoutInfoId');
  2222.         $transactionData = [
  2223.             "cmd" => "_cart",
  2224.             "business" => $receiverSchool->getEmail(),
  2225.             //"upload" => 1,
  2226.             "currency" => "BRL",
  2227.             "charset" => "ISO-8859-1",
  2228.         ];
  2230.         $dataCustom = [];
  2232.         $carts = $cartRepository->getUserValidCarts($this->user->getId());
  2233.         if(empty($carts)){
  2234.             return $this->redirectToRoute('notFound');
  2235.         }
  2237.         foreach ($carts as $key => $cart) {
  2238.             $index = $key + 1;
  2240.             $product = $cart->getProduct();
  2241.             $productOffer = $cart->getProductOffer();
  2243.             $title = $this->stringUtil->shortTextClean($product->getTitle(), 30);
  2244.             $title = $this->stringUtil->cleanString2($title);
  2246.             $transactionData["itemId{$index}"] = $productOffer->getId();
  2247.             $transactionData["itemDescription{$index}"] = $title;
  2248.             $transactionData["itemAmount{$index}"] = $cart->getPrice();
  2249.             $transactionData["itemQuantity{$index}"] = 1;
  2251.             $dataCustom["cart_{$index}"] = $cart->getId();
  2252.             $dataCustom["amount_{$index}"] = $cart->getPrice();
  2253.             $dataCustom["offer_{$index}"] = $productOffer->getId();
  2254.             
  2255.             $productCoupon = $cart->getProductCoupon();
  2256.             if($productCoupon){
  2257.                 $dataCustom["coupon_{$index}"] = $productCoupon->getId();
  2258.             }
  2259.         }
  2261.         $dataCustom["userId"] = $this->user->getId();
  2262.         $dataCustom["numberItens"] = count($carts);
  2263.         $dataCustom["userCheckoutInfoId"] = $userCheckoutInfoId;
  2265.         $transactionData["reference"] = $this->user->getId();
  2266.         $transactionData["custom"] = json_encode($dataCustom);
  2267.         $transactionData["redirectURL"] = "https://{$this->eadDomain}/resume/";
  2268.         $transactionData["notificationURL"] = "https://{$this->eadDomain}/pagseguro/";
  2270.         $pagSeguro = $this->generalService->getService('PagSeguro\\PagSeguro');
  2271.         $url = $pagSeguro->getCheckoutPagseguro($transactionData);
  2273.         return $this->redirect($url, 301);
  2274.     }
  2276.     /**
  2277.      * @Route(
  2278.      *      path          = "/cart/checkout/mercadopago",
  2279.      *      name          = "cartCheckoutMercadopago",
  2280.      *      methods       = {"GET"}
  2281.      * )
  2282.      */
  2283.     public function checkoutMercadopago(Request $request) {
  2284.         $this->checkUserSession($request);
  2286.         $receiverSchool = $this->configuration->getReceiverSchool(
  2287.             ReceiverEnum::MERCADO_PAGO
  2288.         );
  2290.         if(!$receiverSchool){
  2291.             return $this->redirectToRoute('notFound');
  2292.         }
  2294.         $this->requestUtil->setRequest($request)->setData();
  2296.         $cartRepository = $this->em->getRepository(Cart::class);
  2298.         $hasOnlyCourseInCart = $cartRepository->hasOnlyCourseInCart($this->user->getId());
  2299.         if(!$hasOnlyCourseInCart){
  2300.             return $this->redirectToRoute('notFound');
  2301.         }
  2303.         $carts = $cartRepository->getUserValidCarts($this->user->getId());
  2304.         if(empty($carts)){
  2305.             return $this->redirectToRoute('notFound');
  2306.         }
  2308.         foreach ($carts as $key => $cart) {
  2309.             $product = $cart->getProduct();
  2310.             $productOffer = $cart->getProductOffer();
  2312.             $title = $this->stringUtil->shortTextClean($product->getTitle(), 30);
  2313.             $title = $this->stringUtil->cleanString2($title);
  2315.             $description = $this->stringUtil->shortTextClean($product->getDescription(), 30);
  2316.             $description = $this->stringUtil->cleanString2($description);
  2318.             $items[] = [
  2319.                 "id" => $productOffer->getId(),
  2320.                 "title" => $title,
  2321.                 "description" => $description,
  2322.                 "quantity" => 1,
  2323.                 "unit_price" => $cart->getPrice()
  2324.             ];
  2325.         }
  2327.         $transactionData["items"] = $items;
  2328.         $transactionData["back_urls"] = [
  2329.             "success" => "https://{$this->eadDomain}/resume/",
  2330.             "failure" => "https://{$this->eadDomain}/cart#mercadopago/", 
  2331.             "pending" => "https://{$this->eadDomain}/cart#mercadopago/"
  2332.         ];
  2333.         $transactionData["external_reference"] = $this->user->getId();
  2335.         $transactionData["notification_url"] = "https://{$this->eadDomain}/mercadopago?debug=1";
  2337.         $data = json_encode($transactionData);
  2339.         $mercadoPago = $this->generalService->getService('MercadoPago\\MercadoPago');
  2340.         $url = $mercadoPago->getCheckoutMercadoPago($data);
  2342.         return $this->redirect($url, 301);
  2343.     }
  2345.     /**
  2346.      * @Route(
  2347.      *      path          = "/admin/cart/checkout/charge",
  2348.      *      name          = "cartCheckoutCharge",
  2349.      *      methods       = {"POST"}
  2350.      * )
  2351.      */
  2352.     public function checkoutCharge(Request $request){
  2353.         $receiverSchool = $this->configuration->getReceiverSchool(
  2354.             ReceiverEnum::EAD_CHECKOUT
  2355.         );
  2356.         if(!$receiverSchool){
  2357.             return $this->eadResponse(
  2358.                 [ "message" => "Receiver not found "],
  2359.                 ErrorEnum::ACTION_INVALID
  2360.             );
  2361.         }
  2363.         $transactionService = $this->generalService->getService(
  2364.             'Transaction\\TransactionService'
  2365.         );
  2366.         $pagarMeTransaction = $this->generalService->getService(
  2367.             'PagarMe\\PagarMeTransaction'
  2368.         );
  2370.         $this->requestUtil->setRequest($request)->setData();
  2372.         $productChargeId = (int)$this->requestUtil->getField('productChargeId');
  2373.         $userCheckoutInfoId = (int)$this->requestUtil->getField('userCheckoutInfoId');
  2374.         $paymentMethod = (int)$this->requestUtil->getField('paymentMethod');
  2375.         $installments = (int)$this->requestUtil->getField('installments');
  2376.         $debug = (int)$request->get('debug');
  2378.         $productCharge = $this->em->getRepository(ProductCharge::class)->findOneBy([
  2379.             "id" => $productChargeId,
  2380.             "deleted" => ProductChargeEnum::ITEM_NO_DELETED
  2381.         ]);
  2382.         
  2383.         if (!$productCharge) {
  2384.             return $this->eadResponse(
  2385.                 [ "message" => "Charge not found "], 
  2386.                 ErrorEnum::ACTION_INVALID
  2387.             );
  2388.         }
  2390.         if ($productCharge->getPublish() == ProductChargeEnum::NO) {
  2391.             return $this->eadResponse(
  2392.                 [ "message" => "Charge is not publish "], 
  2393.                 ErrorEnum::ACTION_INVALID
  2394.             );
  2395.         }
  2397.         $userCardRepository = $this->em->getRepository(UserCard::class);
  2398.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  2400.         $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  2401.             "id" => $userCheckoutInfoId,
  2402.             "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED,
  2403.         ]);
  2405.         if(!$userCheckoutInfo){
  2406.             return $this->eadResponse([ 
  2407.                 "message" => "UserCheckoutInfo is empty"
  2408.             ], ErrorEnum::ACTION_INVALID);
  2409.         }
  2411.         $paymentConfig = $this->configuration->getPaymentConfig();
  2413.         $product = $productCharge->getProduct();
  2414.         $productOffer = $productCharge->getProductOffer();
  2416.         $items = [
  2417.             (object)[
  2418.                 "courseId" => null,
  2419.                 "productOfferId" => $productOffer->getId(),
  2420.                 "productId" => $product->getId(),
  2421.                 "amount" => $productCharge->getAmount(),
  2422.                 "cartId" => null,
  2423.                 "productCouponId" => null,
  2424.             ]
  2425.         ];
  2427.         $userCard = null;
  2428.         $amount = $productCharge->getAmount(true);
  2429.         $dateExpire = $productCharge->getDateExpire();
  2431.         if(empty($paymentMethod)){
  2432.             return $this->eadResponse([ 'paymentMethod' ], ErrorEnum::FIELD_EMPTY);
  2433.         }
  2435.         if($paymentMethod == CartEnum::PAYMENT_CARD){ // get user card
  2436.             if(empty($installments)){
  2437.                 return $this->eadResponse([ 'installments' ], ErrorEnum::FIELD_EMPTY);
  2438.             }
  2440.             $userCardId = $this->requestUtil->getField('userCardId');
  2441.             if(empty($userCardId)){
  2442.                 return $this->eadResponse([ 'userCardId' ], ErrorEnum::FIELD_EMPTY);
  2443.             }
  2445.             if($userCardId > 0){
  2446.                 $userCard = $userCardRepository->findOneBy([
  2447.                     "id" => $userCardId,
  2448.                     "user" => $this->user->getId(),
  2449.                     "deleted" => CartEnum::ITEM_NO_DELETED
  2450.                 ]);
  2451.             }
  2452.         }
  2454.         if($paymentMethod == CartEnum::PAYMENT_CARD && !$userCard){
  2455.             return $this->eadResponse(
  2456.                 [ "message" => "Card not found "], 
  2457.                 ErrorEnum::ACTION_INVALID
  2458.             );
  2459.         }
  2461.         $freeInstallments = $productCharge->getInstallmentNumberInterest();
  2462.         if($paymentMethod == CartEnum::PAYMENT_CARD){
  2463.             $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  2464.                 'amount' => $amount,
  2465.                 'free_installments' => $freeInstallments,
  2466.                 'max_installments' => $installments,
  2467.                 'interest_rate' => $paymentConfig->installmentInterest
  2468.             ]);
  2470.             $amount = $installmentsOptions->{$installments}->amount;
  2471.         }
  2473.         if($amount < $this->configuration->getMinValueProduct()){
  2474.             return $this->eadResponse([ "message" => "Amount invalid "], ErrorEnum::ACTION_INVALID);
  2475.         }
  2477.         if($this->user && $this->user->getId() == CartEnum::YES){
  2478.             $transactionService->setDebug(true);
  2479.         }
  2481.         if($debug == CartEnum::YES){
  2482.             $transactionService->setDebug(true);
  2483.         }
  2485.         $transactionOrigin = TransactionEnum::ORIGIN_CHARGE;
  2487.         $data = $transactionService->createTransactionEAD(
  2488.             $productCharge->getUser(),
  2489.             $userCheckoutInfo,
  2490.             $amount,
  2491.             $paymentMethod,
  2492.             $installments,
  2493.             $items,
  2494.             $userCard,
  2495.             $dateExpire,
  2496.             null,
  2497.             $productChargeId,
  2498.             (!empty($freeInstallments) ? (int)$freeInstallments : null),
  2499.             $transactionOrigin
  2500.         );
  2502.         if(!empty($data['errorMessage'])){
  2504.             $productCharge->setErrorMessage($data['errorMessage']);
  2505.             $this->em->flush();
  2507.             return $this->eadResponse([ 
  2508.                 "message" => $data['errorMessage']
  2509.             ], ErrorEnum::ACTION_INVALID);
  2510.         }
  2512.         return $this->eadResponse($data);
  2513.     }
  2515.     /**
  2516.      * @Route(
  2517.      *      path          = "/cart/checkout/clean",
  2518.      *      name          = "checkoutClean",
  2519.      *      methods       = {"POST"}
  2520.      * )
  2521.      */
  2522.     public function checkoutClean(Request $request){
  2524.         $pixelService = $this->generalService->getService('Marketing\\PixelService');
  2525.         $pixelService->sendConversion('InitiateCheckout');
  2527.         $receiverSchool = $this->configuration->getReceiverSchool(
  2528.             ReceiverEnum::EAD_CHECKOUT
  2529.         );
  2530.         if(!$receiverSchool){
  2531.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  2532.         }
  2534.         $transactionService = $this->generalService->getService(
  2535.             'Transaction\\TransactionService'
  2536.         );
  2537.         $pagarMeTransaction = $this->generalService->getService(
  2538.             'PagarMe\\PagarMeTransaction'
  2539.         );
  2541.         $this->requestUtil->setRequest($request)->setData();
  2543.         $data = $this->requestUtil->getData();
  2545.         $dataUtml = [
  2546.             "utm_source" => $request->get('utm_source'),
  2547.             "utm_medium" => $request->get('utm_medium'),
  2548.             "utm_campaign" => $request->get('utm_campaign'),
  2549.             "utm_term" => $request->get('utm_term'),
  2550.             "utm_content" => $request->get('utm_content'),
  2551.         ];
  2553.         $utmsUrl = json_encode($dataUtml);
  2555.         $cartRepository = $this->em->getRepository(Cart::class);
  2556.         $courseRepository = $this->em->getRepository(Course::class);
  2557.         $userCardRepository = $this->em->getRepository(UserCard::class);
  2558.         $userRepository = $this->em->getRepository(User::class);
  2559.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  2560.         $poRepository = $this->em->getRepository(ProductOffer::class);
  2561.         $pcRepository = $this->em->getRepository(ProductCoupon::class);
  2563.         //user
  2564.         $name = $this->requestUtil->getField('name');
  2565.         $email = $this->requestUtil->getField('email');
  2566.         $document = $this->requestUtil->getField('document');
  2567.         $phone = $this->requestUtil->getField('phone');
  2568.         $zipCode = $this->requestUtil->getField('zipCode');
  2569.         $stateId = (int)$this->requestUtil->getField('state');
  2570.         $cityId = (int)$this->requestUtil->getField('city');
  2571.         $address = $this->requestUtil->getField('address');
  2572.         $addressNeighborhood = $this->requestUtil->getField('addressNeighborhood');
  2573.         $addressNumber = $this->requestUtil->getField('addressNumber');
  2574.         $addressComplement = $this->requestUtil->getField('addressComplement');
  2575.         $foreigner = (int)$this->requestUtil->getField('foreigner');
  2577.         //userCheckoutInfo
  2578.         $checkoutName = $this->requestUtil->getField('checkout-name');
  2579.         $checkoutEmail = $this->requestUtil->getField('checkout-email');
  2580.         $checkoutDocument = $this->requestUtil->getField('checkout-document');
  2581.         $checkoutPhone = $this->requestUtil->getField('checkout-phone');
  2582.         $checkoutZipCode = $this->requestUtil->getField('checkout-zipCode');
  2583.         $checkoutStateId = (int)$this->requestUtil->getField('checkout-state');
  2584.         $checkoutCityId = (int)$this->requestUtil->getField('checkout-city');
  2585.         $checkoutAddress = $this->requestUtil->getField('checkout-address');
  2586.         $checkoutAddressNeighborhood = $this->requestUtil->getField(
  2587.             'checkout-addressNeighborhood'
  2588.         );
  2589.         $checkoutAddressNumber = $this->requestUtil->getField('checkout-addressNumber');
  2590.         $checkoutAddressComplement = $this->requestUtil->getField(
  2591.             'checkout-addressComplement'
  2592.         );
  2593.         $checkoutNotify = (int)$this->requestUtil->getField('checkout-notify');
  2594.         $checkoutForeigner = (int)$this->requestUtil->getField('checkout-foreigner');
  2595.         
  2596.         $checkoutNew = (int)$this->requestUtil->getField('checkout-new');
  2597.         $cardNew = (int)$this->requestUtil->getField('card-new');
  2598.         $userNew = (int)$this->requestUtil->getField('user-new');
  2599.         $installments = (int)$this->requestUtil->getField('installments');
  2600.         $paymentMethod = (int)$this->requestUtil->getField('payment-method');
  2601.         $cardId = (int)$this->requestUtil->getField('card-id');
  2602.         $cardHash = $this->requestUtil->getField('card-hash');
  2604.         $userId = (int)$this->requestUtil->getField('user-id');
  2605.         $userCheckoutInfoId = (int)$this->requestUtil->getField('checkout-id');
  2607.         $offerDefaultId = (int)$this->requestUtil->getField('offer-default');
  2608.         $offers = $this->requestUtil->getField('added-ids');
  2609.         $offers = explode(",", $offers);
  2611.         if(empty($offers)){
  2612.             return $this->eadResponse([ 'added-ids' ], ErrorEnum::FIELD_EMPTY);
  2613.         }
  2615.         if(empty($paymentMethod)){
  2616.             return $this->eadResponse([ 'paymentMethod' ], ErrorEnum::FIELD_EMPTY);
  2617.         }
  2619.         $couponKey = $this->requestUtil->getField('couponKey');
  2621.         $user = null;
  2622.         $userCheckoutInfo = null;
  2623.         $userCard = null;
  2624.         
  2625.         if(!empty($userId)){
  2626.             $user = $userRepository->findOneBy([
  2627.                 "id" => $userId,
  2628.             ]);
  2630.             //update user data ???
  2632.             
  2633.         }else if($userNew == UserEnum::YES){
  2635.             $pixelService = $this->generalService->getService('Marketing\\PixelService');
  2636.             $pixelService->sendConversion('Lead');
  2638.             //check user exist
  2639.             $user = $userRepository->findOneBy([
  2640.                 "email" => $email,
  2641.             ], [ "id" => "DESC" ]);
  2643.             if(!$user || ($user && $user->isDeleted())){
  2645.                 $dataUser = [
  2646.                     "name" => $name,
  2647.                     "email" => $email,
  2648.                     "password" => null,
  2649.                     "phone" => $phone,
  2650.                     "notify" => UserEnum::YES,
  2651.                     "invited" => UserEnum::YES
  2652.                 ];
  2654.                 $userDTO = new UserDTO($dataUser);
  2655.                 $data = $userRepository->newUser($userDTO, UserEnum::YES);
  2657.                 if($data->errors){
  2658.                     return $this->eadResponse($data->errors, ErrorEnum::FIELD_EMPTY);
  2659.                 }
  2661.                 $user = $data->user;
  2662.             }
  2664.             $user->setDocument($document);
  2665.             $user->setPhone($phone);
  2666.             $user->setZipCode($zipCode);
  2668.             if($foreigner == UserCheckoutInfoEnum::NO){
  2670.                 $country = $this->em->getRepository(Country::class)->findOneBy([ 
  2671.                     "deleted" => GeoDataEnum::ITEM_NO_DELETED ,
  2672.                     "id" => GeoDataEnum::YES,
  2673.                 ]);
  2675.                 if($country){
  2676.                     $user->setCountry($country);
  2677.                 }
  2678.             }
  2680.             if(!empty($stateId)){
  2681.                 $state = $this->em->getRepository(State::class)->findOneBy([
  2682.                     "id" => $stateId,
  2683.                     "deleted" => UserEnum::ITEM_NO_DELETED
  2684.                 ]);
  2686.                 if($state){
  2687.                     $user->setState($state);
  2688.                 }
  2689.             }
  2691.             if(!empty($cityId)){
  2692.                 $city = $this->em->getRepository(City::class)->findOneBy([
  2693.                     "id" => $cityId,
  2694.                     "deleted" => UserEnum::ITEM_NO_DELETED
  2695.                 ]);
  2697.                 if($city){
  2698.                     $user->setCity($city);
  2699.                 }
  2700.             }
  2702.             $user->setAddress($address);
  2703.             $user->setAddressNeighborhood($addressNeighborhood);
  2704.             $user->setAddressNumber($addressNumber);
  2705.             $user->setAddressComplement($addressComplement);
  2707.             $user->restore();
  2708.         }
  2710.         if(!$user){
  2711.             return $this->eadResponse([ 'user' ], ErrorEnum::FIELD_EMPTY);
  2712.         }
  2714.         if($checkoutNew == CartEnum::NO && empty($userCheckoutInfoId)){
  2715.             $userCheckoutInfo = new UserCheckoutInfo();
  2717.             $userCheckoutInfo->setName($user->getName());
  2718.             $userCheckoutInfo->setEmail($user->getEmail());
  2719.             $userCheckoutInfo->setDocument($user->getDocument());
  2720.             $userCheckoutInfo->setPhone($user->getPhone());
  2721.             $userCheckoutInfo->setZipCode($user->getZipCode());
  2722.             $userCheckoutInfo->setAddress($user->getAddress());
  2723.             $userCheckoutInfo->setAddressNumber($user->getAddressNumber());
  2724.             $userCheckoutInfo->setAddressComplement($user->getAddressComplement());
  2725.             $userCheckoutInfo->setAddressNeighborhood($user->getAddressNeighborhood());
  2726.             $userCheckoutInfo->setCity($user->getCity());
  2727.             $userCheckoutInfo->setState($user->getState());
  2728.             $userCheckoutInfo->setCountry($user->getCountry());
  2729.             $userCheckoutInfo->setUser($user);
  2730.             $userCheckoutInfo->setReceiveEmail(UserCheckoutInfoEnum::NO);
  2731.             $userCheckoutInfo->setDefault(UserCheckoutInfoEnum::YES);
  2733.             $this->em->persist($userCheckoutInfo);
  2734.         }else if($checkoutNew == CartEnum::NO && !empty($userCheckoutInfoId)){
  2735.             $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  2736.                 "id" => $userCheckoutInfoId,
  2737.                 "user" => $user->getId(),
  2738.                 "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED,
  2739.             ]);
  2740.         }else if($checkoutNew == CartEnum::YES){
  2742.             $userCheckoutInfo = new UserCheckoutInfo();
  2744.             $userCheckoutInfo->setName($checkoutName);
  2745.             $userCheckoutInfo->setEmail($checkoutEmail);
  2746.             $userCheckoutInfo->setDocument($checkoutDocument);
  2747.             $userCheckoutInfo->setPhone($checkoutPhone);
  2748.             $userCheckoutInfo->setZipCode($checkoutZipCode);
  2749.             $userCheckoutInfo->setAddress($checkoutAddress);
  2750.             $userCheckoutInfo->setAddressNumber($checkoutAddressNumber);
  2751.             $userCheckoutInfo->setAddressComplement($checkoutAddressComplement);
  2752.             $userCheckoutInfo->setAddressNeighborhood($checkoutAddressNeighborhood);
  2754.             if($checkoutForeigner == UserCheckoutInfoEnum::NO){
  2756.                 $country = $this->em->getRepository(Country::class)->findOneBy([ 
  2757.                     "deleted" => GeoDataEnum::ITEM_NO_DELETED ,
  2758.                     "id" => GeoDataEnum::YES,
  2759.                 ]);
  2761.                 if($country){
  2762.                     $userCheckoutInfo->setCountry($country);
  2763.                 }
  2764.             }
  2766.             if(!empty($checkoutStateId)){
  2767.                 $state = $this->em->getRepository(State::class)->findOneBy([
  2768.                     "id" => $checkoutStateId,
  2769.                     "deleted" => UserEnum::ITEM_NO_DELETED
  2770.                 ]);
  2772.                 if($state){
  2773.                     $userCheckoutInfo->setState($state);
  2774.                 }
  2775.             }
  2777.             if(!empty($checkoutCityId)){
  2778.                 $city = $this->em->getRepository(City::class)->findOneBy([
  2779.                     "id" => $checkoutCityId,
  2780.                     "deleted" => UserEnum::ITEM_NO_DELETED
  2781.                 ]);
  2783.                 if($city){
  2784.                     $userCheckoutInfo->setCity($city);
  2785.                 }
  2786.             }
  2788.             $userCheckoutInfo->setUser($user);
  2789.             $userCheckoutInfo->setReceiveEmail($checkoutNotify);
  2790.             $userCheckoutInfo->setDefault(UserCheckoutInfoEnum::YES);
  2792.             $this->em->persist($userCheckoutInfo);
  2793.         }
  2795.         if(!$userCheckoutInfo){
  2796.             return $this->eadResponse([ 'userCheckoutInfo' ], ErrorEnum::FIELD_EMPTY);
  2797.         }
  2799.         if($paymentMethod == CartEnum::PAYMENT_CARD){
  2800.             if($cardNew == CartEnum::NO && !empty($cardId)){
  2801.                 $userCard = $userCardRepository->findOneBy([
  2802.                     "id" => $cardId,
  2803.                     "user" => $user->getId(),
  2804.                     "deleted" => CartEnum::ITEM_NO_DELETED
  2805.                 ]);
  2806.             }else if($cardNew == CartEnum::YES){
  2807.                 if(empty($cardHash)){
  2808.                     return $this->eadResponse([ 'cardHash' ], ErrorEnum::FIELD_EMPTY);
  2809.                 }
  2811.                 $userCard = $userCardRepository->createByHash($cardHash, $user);
  2812.             }
  2814.             if(!$userCard){
  2815.                 return $this->eadResponse([ 'userCard' ], ErrorEnum::FIELD_EMPTY);
  2816.             }
  2818.             if(empty($installments)){
  2819.                 return $this->eadResponse([ 'installments' ], ErrorEnum::FIELD_EMPTY);
  2820.             }
  2821.         }
  2823.         $productOfferDefault = null;
  2824.         $amount = null;
  2825.         $items = [];
  2826.         $courses = null;
  2827.         $coursesAux = [];
  2829.         foreach ($offers as $key => $offerId) {
  2830.             $productOffer = $poRepository->findOneBy([
  2831.                 "id" => $offerId,
  2832.             ]);
  2833.             if($productOffer){
  2834.                 $product = $productOffer->getProduct();
  2836.                 if($offerId == $offerDefaultId){
  2837.                     $productOfferDefault = $productOffer;
  2839.                     if(
  2840.                         $product->getType() == ProductEnum::COURSE || 
  2841.                         $product->getType() == ProductEnum::COMBO
  2842.                     ){
  2843.                         $courses = $courseRepository->getCoursesByProduct(
  2844.                             $product->getId()
  2845.                         );
  2847.                         foreach ($courses as $key => $course) {
  2848.                             $coursesAux[] = $course->getId();
  2849.                         }
  2850.                     }
  2851.                 }
  2853.                 if(!empty($couponKey)){
  2854.                     $productCoupon = $pcRepository->findValidProductCouponByProductOffer(
  2855.                         $couponKey, 
  2856.                         $productOffer
  2857.                     );
  2858.                 }
  2860.                 $cart = $cartRepository->addCartByProductOffer(
  2861.                     $productOffer,
  2862.                     $user,
  2863.                     null,
  2864.                     $productCoupon,
  2865.                     $utmsUrl,
  2866.                     ($productOffer->getProduct()->isTypeResource() ? $courses : null)
  2867.                 );
  2869.                 if($cart){
  2870.                     $items[] = (object)[
  2871.                         "courses" => $coursesAux,
  2872.                         "productOfferId" => $productOffer->getId(),
  2873.                         "productId" => $product->getId(),
  2874.                         "amount" => $cart->getPrice() + $cart->getMembershipFee(),
  2875.                         "cartId" => $cart->getId(),
  2876.                         "productCouponId" => (
  2877.                             $productCoupon ? $productCoupon->getId() : null
  2878.                         ),
  2879.                     ];
  2881.                     $amount = $amount + $cart->getPrice(true) + $cart->getMembershipFee(true);
  2882.                 }
  2883.             }
  2884.         }
  2886.         if(count($items) != count($offers)){
  2887.             return $this->eadResponse([ "added-ids" ], ErrorEnum::FIELD_EMPTY);
  2888.         }
  2890.         if(!$productOfferDefault){
  2891.             return $this->eadResponse([ "offer-default" ], ErrorEnum::FIELD_EMPTY);
  2892.         }
  2894.         $this->em->flush();
  2896.         $paymentConfig = $this->configuration->getPaymentConfig();
  2897.         $dateExpire = null;
  2899.         if($paymentMethod == CartEnum::PAYMENT_CARD){
  2901.             $freeInstallments = $poRepository->getFreeInstallment($productOfferDefault);
  2903.             $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  2904.                 'amount' => $amount,
  2905.                 'free_installments' => $freeInstallments,
  2906.                 'max_installments' => $installments,
  2907.                 'interest_rate' => $paymentConfig->installmentInterest
  2908.             ]);
  2910.             $amount = $installmentsOptions->{$installments}->amount;
  2911.         }else if($paymentMethod == CartEnum::PAYMENT_BILL){
  2912.             $dateExpire = $poRepository->getDateExpireBill($productOffer);
  2913.         }else if($paymentMethod == CartEnum::PAYMENT_PIX){
  2914.             $dateExpire = $poRepository->getDateExpirePix($productOffer);
  2915.         }
  2917.         if($amount < $this->configuration->getMinValueProduct()){
  2918.             return $this->eadResponse([ 
  2919.                 "message" => "Min Value" 
  2920.             ], ErrorEnum::ACTION_INVALID);
  2921.         }
  2923.         if($user && $user->getId() == CartEnum::YES){
  2924.             $transactionService->setDebug(true);
  2925.         }
  2927.         $transactionOrigin = TransactionEnum::ORIGIN_CHECKOUT_PAGE;
  2929.         $data = $transactionService->createTransactionEAD(
  2930.             $user,
  2931.             $userCheckoutInfo,
  2932.             $amount,
  2933.             $paymentMethod,
  2934.             $installments,
  2935.             $items,
  2936.             $userCard,
  2937.             $dateExpire,
  2938.             null,
  2939.             null,
  2940.             null,
  2941.             $transactionOrigin
  2942.         );
  2944.         if(!empty($data['errorMessage'])){
  2946.             foreach ($offers as $key => $offerId) {
  2947.                 $productOffer = $poRepository->findOneBy([
  2948.                     "id" => $offerId,
  2949.                 ]);
  2950.                 if($productOffer){
  2951.                     if($cart){
  2952.                         $cart->setErrorMessage($data['errorMessage']);
  2953.                     }
  2954.                 }
  2955.             }
  2956.             $this->em->flush();
  2958.             return $this->eadResponse([ 
  2959.                 "message" => $data['errorMessage']
  2960.             ], ErrorEnum::ACTION_INVALID);
  2961.         }
  2962.         
  2963.         return $this->eadResponse($data);
  2964.     }
  2966.     /**
  2967.      * @Route(
  2968.      *      path          = "/admin/cart/checkout/default",
  2969.      *      name          = "cartCheckoutDefault",
  2970.      *      methods       = {"POST"}
  2971.      * )
  2972.      */
  2973.     public function checkoutDefault(Request $request){
  2974.         if(!$this->user){
  2975.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  2976.         }
  2977.         
  2978.         $receiverSchool = $this->configuration->getReceiverSchool(
  2979.             ReceiverEnum::EAD_CHECKOUT
  2980.         );
  2981.         if(!$receiverSchool){
  2982.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  2983.         }
  2985.         $transactionService = $this->generalService->getService(
  2986.             'Transaction\\TransactionService'
  2987.         );
  2988.         $pagarMeTransaction = $this->generalService->getService(
  2989.             'PagarMe\\PagarMeTransaction'
  2990.         );
  2992.         $this->requestUtil->setRequest($request)->setData();
  2994.         $userCheckoutInfoId = $this->requestUtil->getField('userCheckoutInfoId');
  2995.         $paymentMethod = $this->requestUtil->getField('paymentMethod');
  2996.         $installments = $this->requestUtil->getField('installments');
  2998.         $cartRepository = $this->em->getRepository(Cart::class);
  2999.         $productRepository = $this->em->getRepository(Product::class);
  3000.         $userCardRepository = $this->em->getRepository(UserCard::class);
  3001.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  3002.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  3004.         $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  3005.             "id" => $userCheckoutInfoId,
  3006.             "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED,
  3007.         ]);
  3009.         if(!$userCheckoutInfo){
  3010.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3011.         }
  3013.         $paymentConfig = $this->configuration->getPaymentConfig();
  3015.         $items = [];
  3016.         $amount = 0;
  3017.         $userCard = null;
  3018.         $dateExpire = null;
  3020.         if(empty($paymentMethod)){
  3021.             return $this->eadResponse([ 'paymentMethod' ], ErrorEnum::FIELD_EMPTY);
  3022.         }
  3024.         if($paymentMethod == CartEnum::PAYMENT_CARD){ // get user card
  3025.             if(empty($installments)){
  3026.                 return $this->eadResponse([ 'installments' ], ErrorEnum::FIELD_EMPTY);
  3027.             }
  3029.             $userCardId = $this->requestUtil->getField('userCardId');
  3030.             if(empty($userCardId)){
  3031.                 return $this->eadResponse([ 'userCardId' ], ErrorEnum::FIELD_EMPTY);
  3032.             }
  3034.             if($userCardId > 0){
  3035.                 $userCard = $userCardRepository->findOneBy([
  3036.                     "id" => $userCardId,
  3037.                     "user" => $this->user->getId(),
  3038.                     "deleted" => CartEnum::ITEM_NO_DELETED
  3039.                 ]);
  3040.             }
  3041.         }
  3043.         if($paymentMethod == CartEnum::PAYMENT_CARD && !$userCard){
  3044.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3045.         }
  3047.         $carts = $cartRepository->getUserValidCarts($this->user->getId());
  3048.         if(empty($carts)){
  3049.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3050.         }
  3052.         $freeInstallments = $paymentConfig->installmentNumberInterest;
  3053.         if($paymentConfig->assumeInstallmentInterest == CartEnum::YES){
  3054.             $freeInstallments = 12;
  3055.         }
  3057.         $billDateExpire = null;
  3058.         $pixDateExpire = null;
  3060.         $hasOneItem = (count($carts) == CartEnum::YES);
  3061.         
  3062.         foreach ($carts as $key => $cart) {
  3063.             $productOffer = $cart->getProductOffer();
  3064.             $product = $cart->getProduct();
  3066.             if($hasOneItem){
  3067.                 $billDateExpire = $productOfferRepository->getDateExpireBill($productOffer);
  3068.                 $pixDateExpire = $productOfferRepository->getDateExpirePix($productOffer);
  3069.                 $freeInstallments = $productOfferRepository->getFreeInstallment(
  3070.                     $productOffer
  3071.                 );
  3072.             }
  3074.             $productCoupon = $cart->getProductCoupon();
  3076.             $coursesAux = [];
  3077.             foreach ($cart->getCourse() as $key => $course) {
  3078.                 $coursesAux[] = $course->getId();
  3079.             }
  3081.             $items[] = (object)[
  3082.                 "courses" => $coursesAux,
  3083.                 "productOfferId" => $productOffer->getId(),
  3084.                 "productId" => $product->getId(),
  3085.                 "amount" => $cart->getPrice() + $cart->getMembershipFee(),
  3086.                 "cartId" => $cart->getId(),
  3087.                 "productCouponId" => ($productCoupon ? $productCoupon->getId() : null),
  3088.             ];
  3090.             $amount = $amount + $cart->getPrice(true) + $cart->getMembershipFee(true);
  3091.         }
  3093.         if($paymentMethod == CartEnum::PAYMENT_BILL){
  3094.             $dateExpire = $billDateExpire;
  3095.             if(empty($dateExpire)){
  3096.                 $period = (int)$this->configuration->get('bill_period_expire') + 1;
  3097.                 if($period == 1){
  3098.                     $period = 8;
  3099.                 }
  3101.                 $dateExpire = date("Y-m-d", strtotime("+ {$period} day"));
  3102.             }
  3103.         }else if($paymentMethod == CartEnum::PAYMENT_PIX){
  3104.             $dateExpire = $pixDateExpire;
  3105.             if(empty($dateExpire)){
  3106.                 $period = (int)$this->configuration->get('pix_period_expire') + 1;
  3107.                 if($period == 1){
  3108.                     $period = 8;
  3109.                 }
  3111.                 $dateExpire = date("Y-m-d", strtotime("+ {$period} day"));
  3112.             }
  3113.         }else if($paymentMethod == CartEnum::PAYMENT_CARD){
  3114.             $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  3115.                 'amount' => $amount,
  3116.                 'free_installments' => $freeInstallments,
  3117.                 'max_installments' => $installments,
  3118.                 'interest_rate' => $paymentConfig->installmentInterest
  3119.             ]);
  3121.             $amount = $installmentsOptions->{$installments}->amount;
  3122.         }
  3124.         if($amount < $this->configuration->getMinValueProduct()){
  3125.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3126.         }
  3128.         if($this->user && $this->user->getId() == CartEnum::YES){
  3129.             $transactionService->setDebug(true);
  3130.         }
  3132.         $transactionOrigin = TransactionEnum::ORIGIN_CHECKOUT_DEFAULT;
  3134.         $data = $transactionService->createTransactionEAD(
  3135.             $this->user,
  3136.             $userCheckoutInfo,
  3137.             $amount,
  3138.             $paymentMethod,
  3139.             $installments,
  3140.             $items,
  3141.             $userCard,
  3142.             $dateExpire,
  3143.             null,
  3144.             null,
  3145.             (!empty($freeInstallments) ? (int)$freeInstallments : null),
  3146.             $transactionOrigin
  3147.         );
  3149.         if(!empty($data['errorMessage'])){
  3151.             foreach ($carts as $key => $cart) {
  3152.                 $cart->setErrorMessage($data['errorMessage']);
  3153.             }
  3154.             $this->em->flush();
  3156.             return $this->eadResponse([ 
  3157.                 "message" => $data['errorMessage']
  3158.             ], ErrorEnum::ACTION_INVALID);
  3159.         }
  3161.         return $this->eadResponse($data);
  3162.     }
  3164.     /**
  3165.      * @Route(
  3166.      *      path          = "/admin/cart/checkout/custom",
  3167.      *      name          = "cartCheckoutCustom",
  3168.      *      methods       = {"POST"}
  3169.      * )
  3170.      */
  3171.     public function cartCheckoutCustom(Request $request){
  3173.         if(!$this->user){
  3174.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3175.         }
  3177.         $receiverSchool = $this->configuration->getReceiverSchool(
  3178.             ReceiverEnum::EAD_CHECKOUT
  3179.         );
  3180.         if(!$receiverSchool){
  3181.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3182.         }
  3184.         $transactionService = $this->generalService->getService(
  3185.             'Transaction\\TransactionService'
  3186.         );
  3187.         $pagarMeTransaction = $this->generalService->getService(
  3188.             'PagarMe\\PagarMeTransaction'
  3189.         );
  3191.         $this->requestUtil->setRequest($request)->setData();
  3193.         $items = json_decode($this->requestUtil->getField('items'));
  3194.         $userCardId = $this->requestUtil->getField('userCardId');
  3195.         $userCheckoutInfoId = $this->requestUtil->getField('userCheckoutInfoId');
  3197.         if(count($items) == CartEnum::NO){
  3198.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3199.         }
  3201.         $cartRepository = $this->em->getRepository(Cart::class);
  3202.         $productRepository = $this->em->getRepository(Product::class);
  3203.         $userCardRepository = $this->em->getRepository(UserCard::class);
  3204.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  3205.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  3207.         $carts = $cartRepository->getUserValidCarts($this->user->getId());
  3208.         if(empty($carts)){
  3209.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3210.         }
  3212.         $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  3213.             "id" => $userCheckoutInfoId,
  3214.             "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED,
  3215.         ]);
  3217.         if(!$userCheckoutInfo){
  3218.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3219.         }
  3221.         $groupedItems = [];
  3222.         $ref = null;
  3223.         $group = [];
  3225.         foreach ($items as $key => $item) {
  3226.             
  3227.             /*if(empty($ref)){
  3228.                 $ref = $item->parentRef;
  3229.             }
  3231.             if($ref != $item->parentRef){
  3232.                 if(!empty($group)){
  3233.                     $groupedItems[] = $group;
  3234.                 }
  3236.                 $ref = $item->parentRef;
  3237.                 $group = [];
  3238.             }*/
  3239.             
  3240.             $group[] = $item;
  3242.             if(($key + 1) == count($items)){
  3243.                 if(!empty($group)){
  3244.                     $groupedItems[] = $group;
  3245.                 }
  3246.             }
  3247.         }
  3249.         $userCard = null;
  3250.         if($userCardId > 0){
  3251.             $userCard = $userCardRepository->findOneBy([
  3252.                 "id" => $userCardId,
  3253.                 "user" => $this->user->getId(),
  3254.                 "deleted" => CartEnum::ITEM_NO_DELETED
  3255.             ]);
  3256.         }
  3258.         $hashReference = md5(
  3259.             date('Y-m-d H:i:s') . $this->user->getId() . $this->client->getClientId()
  3260.         );
  3262.         $paymentConfig = $this->configuration->getPaymentConfig();
  3264.         foreach ($groupedItems as $key => $group) {
  3266.             $items = [];
  3267.             $paymentMethod = null;
  3268.             $installments = 1;
  3269.             $dateExpire = null;
  3270.             $amount = 0;
  3272.             foreach ($group as $key => $itemReq) {
  3273.                 $itemReq = (object)$itemReq;
  3275.                 if($itemReq->able){
  3276.                     $cart = $cartRepository->findOneBy([
  3277.                         "id" => $itemReq->id,
  3278.                         "deleted" => CartEnum::ITEM_NO_DELETED
  3279.                     ]);
  3281.                     $productOffer = $cart->getProductOffer();
  3282.                     $product = $cart->getProduct();
  3283.                     $productCoupon = $cart->getProductCoupon();
  3285.                     $coursesAux = [];
  3286.                     foreach ($cart->getCourse() as $key => $course) {
  3287.                         $coursesAux[] = $course->getId();
  3288.                     }
  3290.                     $items[] = (object)[
  3291.                         "courses" => $coursesAux,
  3292.                         "productOfferId" => $productOffer->getId(),
  3293.                         "productId" => $product->getId(),
  3294.                         "amount" => $cart->getPrice() + $productOffer->getMembershipFee(),
  3295.                         "cartId" => $cart->getId(),
  3296.                         "productCouponId" => (
  3297.                             $productCoupon ? $productCoupon->getId() : null
  3298.                         ),
  3299.                     ];
  3301.                     $paymentMethod = $itemReq->paymentMethod;
  3302.                     $installments = $itemReq->installment;
  3304.                     if($paymentMethod == CartEnum::PAYMENT_BILL){
  3305.                         $dateExpire = $itemReq->billDateExpire;
  3306.                     }else if($paymentMethod == CartEnum::PAYMENT_PIX){
  3307.                         $dateExpire = $itemReq->pixDateExpire;
  3308.                     }
  3310.                     $amountItem = $cart->getPrice(true) + $productOffer->getMembershipFee(
  3311.                         true
  3312.                     );
  3314.                     if($paymentMethod == CartEnum::PAYMENT_CARD){
  3316.                         $freeInstallments = $productOfferRepository->getFreeInstallment(
  3317.                             $productOffer
  3318.                         );
  3320.                         $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  3321.                             'amount' => $amountItem,
  3322.                             'free_installments' => $freeInstallments,
  3323.                             'max_installments' => $installments,
  3324.                             'interest_rate' => $paymentConfig->installmentInterest
  3325.                         ]);
  3327.                         $amountItem = $installmentsOptions->{$installments}->amount;
  3328.                     }
  3330.                     $amount = $amount + $amountItem;
  3331.                 }
  3332.             }
  3334.             if($amount < $this->configuration->getMinValueProduct()){
  3335.                 return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3336.             }
  3338.             if($this->user && $this->user->getId() == CartEnum::YES){
  3339.                 $transactionService->setDebug(true);
  3340.             }
  3342.             $transactionOrigin = TransactionEnum::ORIGIN_CHECKOUT_CUSTOM;
  3345.             $data = $transactionService->createTransactionEAD(
  3346.                 $this->user,
  3347.                 $userCheckoutInfo,
  3348.                 $amount, 
  3349.                 $paymentMethod,
  3350.                 $installments,
  3351.                 $items,
  3352.                 $userCard,
  3353.                 $dateExpire,
  3354.                 $hashReference,
  3355.                 null,
  3356.                 null,
  3357.                 $transactionOrigin
  3358.             );
  3360.             if(!empty($data['errorMessage'])){
  3362.                 foreach ($group as $key => $itemReq) {
  3363.                     if($itemReq->able){
  3364.                         $cart = $cartRepository->findOneBy([
  3365.                             "id" => $itemReq->id,
  3366.                             "deleted" => CartEnum::ITEM_NO_DELETED
  3367.                         ]);
  3368.                         $cart->setErrorMessage($data['errorMessage']);
  3369.                     }
  3370.                 }
  3371.                 $this->em->flush();
  3372.     
  3373.                 return $this->eadResponse([ 
  3374.                     "message" => $data['errorMessage']
  3375.                 ], ErrorEnum::ACTION_INVALID);
  3376.             }
  3377.         }
  3379.         $dataFinal = [
  3380.             "hashReference" => $hashReference,
  3381.         ];
  3383.         return $this->eadResponse($dataFinal);
  3384.     }
  3386.     /**
  3387.      * @Route(
  3388.      *      path          = "/cart/buy/one/click/{productOfferId}/{courseId}",
  3389.      *      name          = "cartOneClickBuy",
  3390.      *      methods       = {"GET"},
  3391.      *      defaults      = { "courseId" = 0 }
  3392.      * )
  3393.      */
  3394.     public function cartOneClickBuy(Request $request){
  3395.         $this->requestUtil->setRequest($request)->setData();
  3397.         $productOfferId = $request->get('productOfferId');
  3398.         $courseId = (int)$request->get('courseId');
  3400.         $dataUtml = [
  3401.             "utm_source" => $request->get('utm_source'),
  3402.             "utm_medium" => $request->get('utm_medium'),
  3403.             "utm_campaign" => $request->get('utm_campaign'),
  3404.             "utm_term" => $request->get('utm_term'),
  3405.             "utm_content" => $request->get('utm_content'),
  3406.         ];
  3408.         $utmsUrl = json_encode($dataUtml);
  3410.         $params = [
  3411.             "poID" => $productOfferId,
  3412.             "courseId" => $courseId,
  3413.         ];
  3415.         $params = array_merge($params, $dataUtml);
  3417.         $cartRepository = $this->em->getRepository(Cart::class);
  3419.         $productOffer = $this->em->getRepository(ProductOffer::class)->findOneBy([ 
  3420.             "id" => $productOfferId, 
  3421.             "status" => ProductOfferEnum::PUBLISHED,
  3422.             "deleted" => ProductOfferEnum::ITEM_NO_DELETED
  3423.         ]);
  3425.         if(!$productOffer){
  3426.             return $this->redirectToRoute('notFound');
  3427.         }
  3429.         $product = $productOffer->getProduct();
  3431.         if($product->isTypeResource() && empty($courseId)){
  3432.             return $this->redirectToRoute('notFound');
  3433.         }
  3435.         if(
  3436.             $product->getType() == ProductEnum::SUBSCRIPTION ||
  3437.             (
  3438.                 $product->getType() != ProductEnum::SUBSCRIPTION && 
  3439.                 $productOffer->getAllowRecurrency() == ProductOfferEnum::YES
  3440.             )
  3441.         ){
  3442.             if($productOffer->getAllowTrial() == ProductOfferEnum::YES){
  3444.                 $params = [
  3445.                     "poHash" => $productOffer->getOfferLink(),
  3446.                     "pcKey" => null,
  3447.                 ];
  3449.                 $params = array_merge($params, $dataUtml);
  3451.                 return $this->redirectToRoute('cartIndividual', $params);
  3452.             }
  3453.         }
  3455.         if(!$this->user){
  3456.             return $this->redirectToRoute('cartAdd', $params);
  3457.         }
  3458.         
  3459.         $receiverSchool = $this->configuration->getReceiverSchool(
  3460.             ReceiverEnum::EAD_CHECKOUT
  3461.         );
  3462.         if(!$receiverSchool){
  3463.             return $this->redirectToRoute('cartAdd', $params);
  3464.         }
  3466.         if($this->user->getAllowOneClickBuy() == UserEnum::NO){
  3467.             return $this->redirectToRoute('cartAdd', $params);
  3468.         }
  3470.         $userCardRepository = $this->em->getRepository(UserCard::class);
  3471.         $userCardDefault = $userCardRepository->getDefaultValidUserCard();
  3472.         if(!$userCardDefault){
  3473.             return $this->redirectToRoute('cartAdd', $params);
  3474.         }
  3476.         if($productOffer->getSaleChannel() == ProductOfferEnum::EXTERNAL){
  3477.             $externalCheckoutLink = $productOffer->getExternalCheckoutLink();
  3478.             return $this->redirect($externalCheckoutLink, 301);
  3479.         }
  3481.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  3482.         $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  3483.             "user" => $this->user->getId(),
  3484.             "default" => UserCheckoutInfoEnum::YES,
  3485.             "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED,
  3486.         ]);
  3488.         if(!$userCheckoutInfo){
  3489.             return $this->redirectToRoute('cartAdd', $params);
  3490.         }
  3492.         $productSuggestion = null;
  3494.         if(!empty($productSuggestionId)){
  3495.             $productSuggestion = $psRepository->findOneBy([ 
  3496.                 "id" => $productSuggestionId, 
  3497.                 "status" => ProductSuggestionEnum::PUBLISHED,
  3498.                 "deleted" => ProductSuggestionEnum::ITEM_NO_DELETED
  3499.             ]);
  3500.         }
  3502.         $course = null;
  3503.         $courseRepository = $this->em->getRepository(Course::class);
  3504.         if(!empty($courseId)){
  3505.             $course = $courseRepository->findOneBy([
  3506.                 "id" => $courseId,
  3507.                 "deleted" => CourseEnum::ITEM_NO_DELETED,
  3508.             ]);
  3509.         }
  3511.         $cart = $cartRepository->addCartByProductOffer(
  3512.             $productOffer, 
  3513.             $this->user, 
  3514.             $productSuggestion,
  3515.             null,
  3516.             $utmsUrl,
  3517.             ($course ? [ $course ] : null)
  3518.         );
  3519.         
  3520.         if(!$cart){
  3521.             return $this->redirectToRoute('cartAdd', $params);
  3522.         }
  3524.         $productCoupon = $cart->getProductCoupon();
  3526.         $items = [
  3527.             (object)[
  3528.                 "courseId" => ($course ? $course->getId() : null),
  3529.                 "productOfferId" => $productOffer->getId(),
  3530.                 "productId" => $productOffer->getProduct()->getId(),
  3531.                 "amount" => $cart->getPrice() + $cart->getMembershipFee(),
  3532.                 "cartId" => $cart->getId(),
  3533.                 "productCouponId" => ($productCoupon ? $productCoupon->getId() : null),
  3534.             ]
  3535.         ];
  3537.         $transactionService = $this->generalService->getService(
  3538.             'Transaction\\TransactionService'
  3539.         );
  3541.         if($this->user && $this->user->getId() == CartEnum::YES){
  3542.             $transactionService->setDebug(true);
  3543.         }
  3545.         $transactionOrigin = TransactionEnum::ORIGIN_ONE_CLICK;
  3547.         $data = (object)$transactionService->createTransactionEAD(
  3548.             $this->user,
  3549.             $userCheckoutInfo,
  3550.             $cart->getPrice(true) + $cart->getMembershipFee(true),
  3551.             CartEnum::PAYMENT_CARD,
  3552.             1,
  3553.             $items,
  3554.             $userCardDefault,
  3555.             null,
  3556.             null,
  3557.             null,
  3558.             null,
  3559.             $transactionOrigin
  3560.         );
  3562.         if(!empty($data->errorMessage)){
  3564.             $cart->setErrorMessage($data->errorMessage);
  3565.             $this->em->flush();
  3567.             //return $this->eadResponse([ 
  3568.             //    "message" => $data->errorMessage
  3569.             //], ErrorEnum::ACTION_INVALID);
  3571.             return $this->redirectToRoute('cart'); 
  3572.         }
  3574.         $paramsConclusion = [
  3575.             "hashReference" => $data->hashReference,
  3576.         ];
  3578.         return $this->redirectToRoute('cartConclusion', $paramsConclusion);
  3579.     }
  3581.     /**
  3582.      * @Route(
  3583.      *      path          = "/admin/cart/checkout/plan/trial/{poID}/{pcID}",
  3584.      *      name          = "cartCheckoutPlanTrial",
  3585.      *      methods       = {"POST"},
  3586.      *      defaults      = { "pcID" = 0 }
  3587.      * )
  3588.      */
  3589.     public function cartCheckoutPlanTrial(Request $request){
  3590.         if(!$this->user){
  3591.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3592.         }
  3593.         
  3594.         $receiverSchool = $this->configuration->getReceiverSchool(
  3595.             ReceiverEnum::EAD_CHECKOUT
  3596.         );
  3597.         if(!$receiverSchool){
  3598.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3599.         }
  3601.         $productOfferId = (int)$request->get('poID');
  3602.         $productCouponId = (int)$request->get('pcID');
  3603.         $this->requestUtil->setRequest($request)->setData();
  3605.         $userCheckoutInfoId = $this->requestUtil->getField('userCheckoutInfoId');
  3606.         $paymentMethod = $this->requestUtil->getField('paymentMethod');
  3607.         $installments = $this->requestUtil->getField('installments');
  3609.         $userCardRepository = $this->em->getRepository(UserCard::class);
  3610.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  3611.         $productCouponRepository = $this->em->getRepository(ProductCoupon::class);
  3612.         $userCheckoutInfoRepository = $this->em->getRepository(UserCheckoutInfo::class);
  3614.         $productOffer = $productOfferRepository->findOneBy([ 
  3615.             "id" => $productOfferId, 
  3616.             "status" => ProductOfferEnum::PUBLISHED,
  3617.             "deleted" => ProductOfferEnum::ITEM_NO_DELETED
  3618.         ]);
  3620.         if(!$productOffer){
  3621.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  3622.         }
  3624.         if($productOffer->getAllowTrial() == ProductOfferEnum::NO){
  3625.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3626.         }
  3627.         
  3628.         $product = $productOffer->getProduct();
  3629.         $pagarMeTransaction = $this->generalService->getService(
  3630.             'PagarMe\\PagarMeTransaction'
  3631.         );
  3633.         $userCheckoutInfo = $userCheckoutInfoRepository->findOneBy([
  3634.             "id" => $userCheckoutInfoId,
  3635.             "deleted" => UserCheckoutInfoEnum::ITEM_NO_DELETED,
  3636.         ]);
  3638.         if(!$userCheckoutInfo){
  3639.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3640.         }
  3642.         $paymentConfig = $this->configuration->getPaymentConfig();
  3644.         $userCard = null;
  3645.         if(empty($paymentMethod)){
  3646.             return $this->eadResponse([ 'paymentMethod' ], ErrorEnum::FIELD_EMPTY);
  3647.         }
  3649.         if($paymentMethod == CartEnum::PAYMENT_CARD){ // get user card
  3650.             if(empty($installments)){
  3651.                 return $this->eadResponse([ 'installments' ], ErrorEnum::FIELD_EMPTY);
  3652.             }
  3654.             $userCardId = $this->requestUtil->getField('userCardId');
  3655.             if(empty($userCardId)){
  3656.                 return $this->eadResponse([ 'userCardId' ], ErrorEnum::FIELD_EMPTY);
  3657.             }
  3659.             if($userCardId > 0){
  3660.                 $userCard = $userCardRepository->findOneBy([
  3661.                     "id" => $userCardId,
  3662.                     "user" => $this->user->getId(),
  3663.                     "deleted" => CartEnum::ITEM_NO_DELETED
  3664.                 ]);
  3665.             }
  3666.         }
  3668.         if($paymentMethod == CartEnum::PAYMENT_CARD && !$userCard){
  3669.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3670.         }
  3672.         $productCoupon = null;
  3673.         $amount = $productOffer->getPriceReal();
  3674.         if(!empty($productCouponId)){
  3675.             $productCoupon = $productCouponRepository->findOneBy([
  3676.                 "deleted" => ProductCouponEnum::ITEM_NO_DELETED,
  3677.                 "status" => ProductCouponEnum::PUBLISHED,
  3678.                 "id" => $productCouponId,
  3679.             ]);
  3681.             if($productCoupon){
  3682.                 if($productCouponRepository->checkApplyCoupon($productCoupon, $productOffer)){
  3683.                     $amount = $productCouponRepository->applyDiscount(
  3684.                         $productCoupon, 
  3685.                         $amount
  3686.                     );
  3687.                 }
  3688.             }
  3689.         }
  3691.         if($amount < $this->configuration->getMinValueProduct()){
  3692.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3693.         }
  3695.         $userSubscriptionRepository = $this->em->getRepository(UserSubscription::class);
  3696.         $userSubscription = $userSubscriptionRepository->findOneBy([
  3697.             "user" => $this->user->getId(),
  3698.             "product" => $product->getId()
  3699.         ]);
  3701.         if($userSubscription && $userSubscription->isLive()){
  3702.             return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  3703.         }
  3705.         if(!$userSubscription){
  3706.             $userSubscription = new UserSubscription();
  3707.         }else{
  3708.             $userSubscriptionRepository->restore($userSubscription, TrashEnum::USER_SUBSCRIPTION);
  3709.         }
  3711.         $userSubscription->setStatus(UserSubscriptionEnum::STATUS_TRIAL);
  3712.         $userSubscription->setDateStart(date('Y-m-d H:i:s'));
  3713.         $userSubscription->setAutomaticRenewal($productOffer->getPlanRenew());
  3714.         $userSubscription->setLifetime($productOffer->getPlanLifetime());
  3715.         $userSubscription->setPrice($productOffer->getPriceReal());
  3716.         $userSubscription->setCycle($productOffer->getPlanCycle());
  3717.         $userSubscription->setChargeNumberMax($productOffer->getPlanChargeNumberMax());
  3718.         $userSubscription->setMembershipFee($productOffer->getMembershipFee());
  3719.         $userSubscription->setProduct($product);
  3720.         $userSubscription->setProductOffer($productOffer);
  3721.         $userSubscription->setUser($this->user);
  3722.         $userSubscription->setUsedTrial(UserSubscriptionEnum::YES);
  3724.         if($productCoupon){
  3725.             $userSubscription->setProductCoupon($productCoupon);
  3726.             $userSubscription->setCouponKey($productCoupon->getKey());
  3727.             $userSubscription->setCouponType($productCoupon->getDiscountType());
  3728.             $userSubscription->setCouponApplyMembershipFee(
  3729.                 $productCoupon->getApplyMembershipFee()
  3730.             );
  3731.             $userSubscription->setCouponLifetime($productCoupon->getPlanLifetime());
  3732.             $userSubscription->setCouponNumberCharges($productCoupon->getPlanCharges());
  3733.             $userSubscription->setCouponDiscount($productCoupon->getDiscount());
  3734.         }
  3736.         $userSubscription->setPaymentMethod($paymentMethod);
  3738.         $monthCycles = [
  3739.             UserSubscriptionEnum::CYCLE_MONTHLY,
  3740.             UserSubscriptionEnum::CYCLE_WEEKLY,
  3741.             UserSubscriptionEnum::CYCLE_BIWEEKLY,
  3742.         ];
  3744.         if(!in_array($userSubscription->getCycle(), $monthCycles)){
  3745.             $freeInstallmentNumber = $productOfferRepository->getFreeInstallment(
  3746.                 $productOffer
  3747.             );
  3749.             $userSubscription->setInstallments($installments);
  3750.             $userSubscription->setInstallmentsFree($freeInstallmentNumber);
  3751.         }
  3752.         
  3753.         //define date renew
  3754.         if(
  3755.             $userSubscription->getLifetime() == UserSubscriptionEnum::NO && 
  3756.             $userSubscription->getAutomaticRenewal() == UserSubscriptionEnum::YES
  3757.         ){
  3758.             $periodRenew = $userSubscriptionRepository->getPlanCycle(
  3759.                 $userSubscription->getCycle(),
  3760.                 $userSubscription->getChargeNumberMax()
  3761.             );
  3763.             $userSubscription->setDateRenew(date('Y-m-d', strtotime($periodRenew)));
  3764.         }
  3766.         $days = $productOffer->getTrialPeriod();
  3767.         $dateNextPayment = date('Y-m-d', strtotime("+ {$days} day"));
  3768.         $dateAccess = date('Y-m-d H:i:s', strtotime("+ {$days} day"));
  3769.         $userSubscription->setDateNextPayment($dateNextPayment);
  3770.         $userSubscription->setDateExpiration($dateNextPayment);
  3771.         $userSubscription->setUserCard($userCard);
  3772.         $userSubscription->setUserCard($userCard);
  3773.         $userSubscription->setTrialDateEnd($dateAccess);
  3775.         $this->em->persist($userSubscription);
  3777.         $this->userLogService->logInsert(
  3778.             "user_subscription", 
  3779.             $userSubscription->getId(), 
  3780.             $userSubscription->toReturn()
  3781.         );
  3783.         $enrollmentService = $this->generalService->getService('EnrollmentService');
  3784.         $enrollmentService->setNotification(true);
  3785.         $enrollmentService->setEmail(false);
  3786.         $enrollmentService->setOrigin(EnrollmentEnum::ORIGIN_SUBSCRIPTION);
  3788.         if($userSubscription->getPaymentMethod() == UserSubscriptionEnum::PAYMENT_BILL){
  3789.             $dateAccess = date('Y-m-d H:i:s', strtotime("{$dateAccess} + 3 days"));
  3790.         }
  3792.         $enrollmentService->setAccessDate($dateAccess);
  3793.         $enrollmentService->setSupportDate($dateAccess);
  3795.         $enrollmentService->setUserSubscription($userSubscription);
  3796.         $enrollmentService->enrollUserByProduct(
  3797.             $userSubscription->getUser(), 
  3798.             $userSubscription->getProduct()
  3799.         );
  3801.         $marketingService = $this->generalService->getService('Marketing\MarketingService');
  3802.         $marketingService->setTag(TagsMarketingEnum::TAG_START_SUBSCRIPTION);
  3803.         $marketingService->setTextComplement($product->getTitle());
  3804.         $marketingService->setUser($this->user);
  3805.         $marketingService->send();
  3807.         $pixelService = $this->generalService->getService('Marketing\\PixelService');
  3808.         $pixelService->sendConversion('StartTrial', (object)[
  3809.             "value" => $userSubscription->getPrice(),
  3810.             "currency" => $productOffer->getCurrencyCode(),
  3811.             "contents" => [
  3812.                 (object)[
  3813.                     "id" => $product->getId(),
  3814.                     "quantity" => 1,
  3815.                     "item_price" => $userSubscription->getPrice(),
  3816.                     //"name" => $product->getTitle(),
  3817.                     //"type" => $product->getType()
  3818.                 ]
  3819.             ],
  3820.             "num_items" => 1,
  3821.             "content_type" => "product",
  3822.             "transaction_id" => $userSubscription->getId(),
  3823.         ]);
  3825.         $this->em->flush();
  3827.         if($userSubscription->getUser() && $userSubscription->getProduct()->getUser()){
  3829.             sleep(1);
  3830.             
  3831.             if($userSubscription->getId()){
  3832.                 $notificationService = $this->generalService->getService('NotificationService');
  3833.                 $notificationService->create(
  3834.                     $userSubscription->getUser(), 
  3835.                     $userSubscription->getProduct()->getUser(),
  3836.                     NotificationEnum::ORIGIN_USER_SUBSCRIPTION_NEW,
  3837.                     $userSubscription->getId()
  3838.                 );
  3840.                 $notificationService->create(
  3841.                     $userSubscription->getProduct()->getUser(),
  3842.                     $userSubscription->getUser(),
  3843.                     NotificationEnum::ORIGIN_USER_SUBSCRIPTION_NEW,
  3844.                     $userSubscription->getId()
  3845.                 );
  3846.             }
  3847.         }
  3849.         $userWebhook = $this->em->getRepository(User::class)->getToWebhook(
  3850.             $userSubscription->getUser()
  3851.         );
  3852.         
  3853.         //webhook
  3854.         $dataObj = (object)[
  3855.             "user" => $userWebhook,
  3856.             "subscription" => $userSubscription->toWebhook(),
  3857.             "product" => (object)[
  3858.                 "id" => (string)$userSubscription->getProduct()->getId(),
  3859.                 "name" => $userSubscription->getProduct()->getTitle(),
  3860.                 "offer" => (object)[
  3861.                     "id" => (string)$userSubscription->getProductOffer()->getId(),
  3862.                     "name" => $userSubscription->getProductOffer()->getTitle(),
  3863.                     "price" => (string)$userSubscription->getProductOffer()->getPriceReal(),
  3864.                     "membership"=> (string)$userSubscription->getMembershipFee(),
  3865.                 ],
  3866.             ],
  3867.         ];
  3868.         $webhookService = $this->generalService->getService('WebhookService');
  3869.         $webhookService->addItemList(WebhookEnum::SUBSCRIPTION, $dataObj);
  3871.         return $this->eadResponse([
  3872.             "billLink" => null,
  3873.             "pixCode" => null,
  3874.             "userId" => $this->user->getId(),
  3875.             "transactionHash" => "success",
  3876.             "hashReference" => "success",
  3877.         ]);
  3878.     }
  3880.     /**
  3881.      * @Route(
  3882.      *      path          = "/cart/checkout/new/try/{transactionHash}",
  3883.      *      name          = "cartCheckoutNewTry",
  3884.      *      methods       = {"GET"}
  3885.      * )
  3886.      */
  3887.     public function cartCheckoutNewTry(Request $request){
  3889.         $this->checkUserSession($request);
  3891.         $transactionHash = $request->get('transactionHash');
  3893.         $cartRepository = $this->em->getRepository(Cart::class);
  3894.         $transactionRepository = $this->em->getRepository(Transaction::class);
  3895.         $transactionItemRepository = $this->em->getRepository(TransactionItem::class);
  3897.         $transaction = $transactionRepository->findOneBy([
  3898.             "hash" => $transactionHash,
  3899.             "status" => TransactionEnum::CANCELED,
  3900.             "deleted" => TransactionEnum::ITEM_NO_DELETED
  3901.         ]);
  3903.         if(!$transaction){
  3904.             return $this->redirectToRoute('notFound');
  3905.         }
  3907.         $transactionItems = $transactionItemRepository->findBy([
  3908.             "transaction" => $transaction->getId(),
  3909.             "deleted" => TransactionItemEnum::ITEM_NO_DELETED
  3910.         ]);
  3912.         if(empty($transactionItems)){
  3913.             return $this->redirectToRoute('notFound');
  3914.         }
  3916.         foreach ($transactionItems as $key => $transactionItem) {
  3918.             $courses = [];
  3920.             foreach ($transactionItem->getCourse() as $keyC => $course) {
  3921.                 $courses[] = $course;
  3922.             }
  3924.             $cartRepository->addCartByProductOffer(
  3925.                 $transactionItem->getProductOffer(),
  3926.                 $transaction->getUser(),
  3927.                 null,
  3928.                 $transactionItem->getProductCoupon(),
  3929.                 $transactionItem->getUtmsUrl(),
  3930.                 $courses
  3931.             );
  3933.         }
  3936.         $this->em->flush();
  3938.         return $this->redirectToRoute('cart');
  3939.     }
  3941.     /**
  3942.      * @Route(
  3943.      *      path          = "/cart/conclusion/{hashReference}",
  3944.      *      name          = "cartConclusion",
  3945.      *      methods       = {"GET"},
  3946.      *      defaults      = { "hashReference" = null }
  3947.      * )
  3948.      * @Route(
  3949.      *      path          = "/cart/conclusao/{hashReference}",
  3950.      *      name          = "cartConclusionOld",
  3951.      *      methods       = {"GET"},
  3952.      *      defaults      = { "hashReference" = null }
  3953.      * )
  3954.      */
  3955.     public function cartConclusionPage(Request $request) {
  3956.         $cartRepository = $this->em->getRepository(Cart::class);
  3957.         $productRepository = $this->em->getRepository(Product::class);
  3958.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  3959.         $transactionRepository = $this->em->getRepository(Transaction::class);
  3960.         $ti = $this->em->getRepository(TransactionItem::class);
  3961.         $psRepository = $this->em->getRepository(ProductSuggestion::class);
  3963.         $hashReference = $request->get('hashReference');
  3965.         $this->data['hashReference'] = $hashReference;
  3966.         $this->data['transactionsCard'] = null;
  3967.         $this->data['transactionsPix'] = null;
  3968.         $this->data['transactionsBill'] = null;
  3969.         $this->data['productOfferSuggestions'] = null;
  3970.         
  3971.         $this->data['hasWaiting'] = true;
  3972.         $this->data['hasApproved'] = false;
  3973.         $this->data['hasCanceled'] = false;
  3974.         $this->data['showInfoStep'] = true;
  3975.         $this->data['hasContracts'] = true;
  3976.         $this->data['sOffers'] = [];
  3977.         
  3978.         $this->data['showSteps'] = true;
  3980.         if(!empty($hashReference)){
  3982.             $isCheckoutPage = $transactionRepository->existByReferenceAndOrigin(
  3983.                 $hashReference, 
  3984.                 TransactionEnum::ORIGIN_CHECKOUT_PAGE
  3985.             );
  3987.             if($isCheckoutPage){
  3988.                 $this->data['showSteps'] = false;
  3989.             }
  3991.             $hasWaiting = $transactionRepository->existByReferenceAndStatus(
  3992.                 $hashReference, 
  3993.                 TransactionEnum::WAITING
  3994.             );
  3996.             $hasApproved = $transactionRepository->existByReferenceAndStatus(
  3997.                 $hashReference, 
  3998.                 TransactionEnum::APPROVED
  3999.             );
  4001.             $hasCanceled = $transactionRepository->existByReferenceAndStatus(
  4002.                 $hashReference, 
  4003.                 TransactionEnum::CANCELED
  4004.             );
  4006.             $hasWaitingCard = $transactionRepository->existByReferenceAndStatus(
  4007.                 $hashReference, 
  4008.                 TransactionEnum::WAITING,
  4009.                 TransactionEnum::PAYMENT_CARD
  4010.             );
  4012.             $hasApprovedCard = $transactionRepository->existByReferenceAndStatus(
  4013.                 $hashReference, 
  4014.                 TransactionEnum::APPROVED,
  4015.                 TransactionEnum::PAYMENT_CARD
  4016.             );
  4018.             $hasCanceledCard = $transactionRepository->existByReferenceAndStatus(
  4019.                 $hashReference, 
  4020.                 TransactionEnum::CANCELED,
  4021.                 TransactionEnum::PAYMENT_CARD
  4022.             );
  4024.             $hasWaitingBill = $transactionRepository->existByReferenceAndStatus(
  4025.                 $hashReference, 
  4026.                 TransactionEnum::WAITING,
  4027.                 TransactionEnum::PAYMENT_BILL
  4028.             );
  4030.             $hasApprovedBill = $transactionRepository->existByReferenceAndStatus(
  4031.                 $hashReference, 
  4032.                 TransactionEnum::APPROVED,
  4033.                 TransactionEnum::PAYMENT_BILL
  4034.             );
  4036.             $hasCanceledBill = $transactionRepository->existByReferenceAndStatus(
  4037.                 $hashReference, 
  4038.                 TransactionEnum::CANCELED,
  4039.                 TransactionEnum::PAYMENT_BILL
  4040.             );
  4042.             $hasWaitingPix = $transactionRepository->existByReferenceAndStatus(
  4043.                 $hashReference,
  4044.                 TransactionEnum::WAITING,
  4045.                 TransactionEnum::PAYMENT_PIX
  4046.             );
  4048.             $hasApprovedPix = $transactionRepository->existByReferenceAndStatus(
  4049.                 $hashReference,
  4050.                 TransactionEnum::APPROVED,
  4051.                 TransactionEnum::PAYMENT_PIX
  4052.             );
  4054.             $hasCanceledPix = $transactionRepository->existByReferenceAndStatus(
  4055.                 $hashReference, 
  4056.                 TransactionEnum::CANCELED,
  4057.                 TransactionEnum::PAYMENT_PIX
  4058.             );
  4060.             $transactionsCard = $transactionRepository->getToCartConclusion(
  4061.                 $hashReference, 
  4062.                 TransactionEnum::PAYMENT_CARD
  4063.             );
  4065.             $transactionsPix = $transactionRepository->getToCartConclusion(
  4066.                 $hashReference, 
  4067.                 TransactionEnum::PAYMENT_PIX
  4068.             );
  4070.             $transactionsBill = $transactionRepository->getToCartConclusion(
  4071.                 $hashReference, 
  4072.                 TransactionEnum::PAYMENT_BILL
  4073.             );
  4075.             $transactionOffers = $productOfferRepository->getByTransactionHashReference(
  4076.                 $hashReference
  4077.             );
  4079.             if(count($transactionOffers) == TransactionEnum::YES){
  4080.                 $offer = $transactionOffers[0];
  4081.                 $productPage = $offer->getProductPage();
  4082.                 $externalPageLink = $productPage->getExternalConclusionLink();
  4084.                 if(
  4085.                     $productPage->getAllowExternalConclusion() &&
  4086.                     !empty($externalPageLink) &&
  4087.                     $hasApproved
  4088.                 ){
  4089.                     return $this->redirect($externalPageLink, 301);
  4090.                 }
  4091.             }
  4093.             $sOffers = [];
  4095.             foreach ($transactionOffers as $keyOffer => $offer) {
  4096.                 $productOfferSuggestions = $psRepository->getByOfferOriginSimply(
  4097.                     $offer,
  4098.                     ProductSuggestionEnum::EXECUTE_IN_CONCLUSION_PAGE
  4099.                 );
  4101.                 foreach ($productOfferSuggestions as $key => $productSuggestion) {
  4103.                     $productOffer = $productSuggestion->getProductOffer();
  4104.                     $product = $productOffer->getProduct();
  4106.                     if($this->user && !$productRepository->userHasProduct($this->user, $product)){
  4107.                         $productOffer->productSuggestionId = $productSuggestion->getId();
  4108.                         $productOffer->productSuggestionItem = $productSuggestion;
  4109.                         
  4110.                         if($productOffer->getAllowSaleLimit() == ProductOfferEnum::YES){
  4111.                             $saleNumber = $ti->countSalesApprovedByProductOffer(
  4112.                                 $productOffer
  4113.                             );
  4115.                             if($productOffer->getSaleNumberLimit() > $saleNumber){
  4116.                                 $sOffers[$productOffer->getId()] = $productOffer;
  4117.                             }
  4119.                         }else{
  4120.                             $sOffers[$productOffer->getId()] = $productOffer;
  4121.                         }
  4122.                     }
  4123.                 }
  4125.                 $cartRepository->sendConclusionConversion($hashReference);
  4126.             }
  4128.             try{
  4129.             
  4130.                 $transactions = array_merge(
  4131.                     $transactionsCard,
  4132.                     $transactionsPix,
  4133.                     $transactionsBill
  4134.                 );
  4136.                 $pagarMeTransaction = $this->generalService->getService(
  4137.                     'PagarMe\\PagarMeTransaction'
  4138.                 );
  4140.                 foreach ($transactions as $key => $tr) {
  4141.                     if($tr->getGateway() == TransactionEnum::EAD_CHECKOUT){
  4142.                         if($tr->getPaymentMethod() == TransactionEnum::PAYMENT_BILL){
  4143.                             $transactionPagarme = $pagarMeTransaction->get($tr->getHash());
  4144.                             $dateExpire = date(
  4145.                                 'Y-m-d', 
  4146.                                 strtotime($transactionPagarme->boleto_expiration_date)
  4147.                             );
  4149.                             $tr->setBillCode($transactionPagarme->boleto_barcode);
  4150.                             $tr->setBillLink($transactionPagarme->boleto_url);
  4151.                             $tr->setDateExpire($dateExpire);
  4152.                         }else if($tr->getPaymentMethod() == TransactionEnum::PAYMENT_PIX){
  4153.                             $transactionPagarme = $pagarMeTransaction->get($tr->getHash());
  4154.                             $dateExpire = date(
  4155.                                 'Y-m-d', 
  4156.                                 strtotime($transactionPagarme->pix_expiration_date)
  4157.                             );
  4159.                             $tr->setPixCode($transactionPagarme->pix_qr_code);
  4160.                             $tr->setDateExpire($dateExpire);
  4161.                         }
  4162.                     }
  4163.                 }
  4165.                 $this->em->flush();
  4166.             }catch(Exception $e){
  4168.             }
  4170.             $this->data['hasWaiting'] = $hasWaiting;
  4171.             $this->data['hasApproved'] = $hasApproved;
  4172.             $this->data['hasCanceled'] = $hasCanceled;
  4173.             $this->data['hasWaitingCard'] = $hasWaitingCard;
  4174.             $this->data['hasApprovedCard'] = $hasApprovedCard;
  4175.             $this->data['hasCanceledCard'] = $hasCanceledCard;
  4176.             $this->data['hasWaitingBill'] = $hasWaitingBill;
  4177.             $this->data['hasApprovedBill'] = $hasApprovedBill;
  4178.             $this->data['hasCanceledBill'] = $hasCanceledBill;
  4179.             $this->data['hasWaitingPix'] = $hasWaitingPix;
  4180.             $this->data['hasApprovedPix'] = $hasApprovedPix;
  4181.             $this->data['hasCanceledPix'] = $hasCanceledPix;
  4182.             $this->data['transactionsCard'] = $transactionsCard;
  4183.             $this->data['transactionsPix'] = $transactionsPix;
  4184.             $this->data['transactionsBill'] = $transactionsBill;
  4185.             $this->data['productOfferSuggestions'] = $sOffers;
  4186.         }
  4188.         $this->data['customCart'] = true;
  4189.         $this->data['cartConclusion'] = true;
  4191.         return $this->renderEAD('cart/cart-conclusion.html.twig');
  4192.     }
  4194.     /**
  4195.      * @Route(
  4196.      *      path          = "/cart/conclusion/status/{hashReference}/{charge}",
  4197.      *      name          = "cartConclusionCheckStatus",
  4198.      *      methods       = {"GET"},
  4199.      *      defaults      = { "hashReference" = null, "charge" = 0 }
  4200.      * )
  4201.      */
  4202.     public function cartConclusionCheckStatus(Request $request) {
  4203.         $cartRepository = $this->em->getRepository(Cart::class);
  4204.         $transactionRepository = $this->em->getRepository(Transaction::class);
  4205.         $transactionItemRepository = $this->em->getRepository(TransactionItem::class);
  4206.         $pagarMeTransaction = $this->generalService->getService(
  4207.             'PagarMe\\PagarMeTransaction'
  4208.         );
  4210.         $processEad = $this->generalService->getService('Transaction\\ProcessEad');
  4212.         $charge = $request->get('charge');
  4213.         $hashReference = $request->get('hashReference');
  4214.         if(empty($hashReference)){
  4215.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  4216.         }
  4218.         $transactions = $transactionRepository->findBy([
  4219.             "hashReference" => $hashReference,
  4220.             "deleted" => TransactionEnum::ITEM_NO_DELETED
  4221.         ]);
  4223.         $refresh = [];
  4224.         foreach ($transactions as $key => $transaction) {
  4225.             $transactionPagarme = $pagarMeTransaction->get($transaction->getHash());
  4226.             $newStatus = $pagarMeTransaction->getTransactionStatus(
  4227.                 $transactionPagarme->status
  4228.             );
  4230.             if(
  4231.                 $newStatus == TransactionEnum::APPROVED || 
  4232.                 $charge == TransactionEnum::YES && (
  4233.                     !empty($transactionPagarme->boleto_barcode) ||
  4234.                     !empty($transactionPagarme->pix_expiration_date)
  4235.                 )
  4236.             ){
  4237.                 $refresh[] = true;
  4238.             }
  4239.         }
  4241.         $this->em->flush();
  4243.         $data = [
  4244.             "refresh" => (count($refresh) == count($transactions))
  4245.         ];
  4247.         return $this->eadResponse($data, ErrorEnum::SUCCESS);
  4248.     }
  4250.     /**
  4251.      * @Route(
  4252.      *      path          = "/cart/remove/coupon/{id}",
  4253.      *      name          = "cartCouponRemove",
  4254.      *      methods       = {"GET"},
  4255.      *      requirements  = { "id" = "\d+"}
  4256.      * )
  4257.      */
  4258.     public function removeCouponProduct(Request $request) {
  4259.         $cartId = $request->get('id');
  4260.         $cartRepository = $this->em->getRepository(Cart::class);
  4262.         $cart = $cartRepository->findOneBy([
  4263.             "id" => $cartId,
  4264.             "deleted" => CartEnum::ITEM_NO_DELETED
  4265.         ]);
  4266.         
  4267.         if(!$cart){
  4268.             return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  4269.         }
  4271.         if($this->user){
  4272.             if($this->user->getId() != $cart->getUser()->getId()){
  4273.                 return $this->eadResponse(null, ErrorEnum::ACTION_INVALID);
  4274.             }   
  4275.         }
  4277.         if($cart->getProductCoupon()){
  4278.             $product = $cart->getProduct();
  4279.             $productOffer = $cart->getProductOffer();
  4281.             $cart->setPrice($productOffer->getPriceReal());
  4282.             $cart->setMembershipFee(ProductEnum::NO);
  4284.             if(
  4285.                 $product->getType() == ProductEnum::SUBSCRIPTION ||
  4286.                 $productOffer->getAllowRecurrency() == ProductEnum::YES
  4287.             ){
  4288.                 $cart->setMembershipFee($productOffer->getMembershipFee());
  4289.             }
  4291.             $cart->setProductCoupon(null);
  4292.         }
  4294.         $this->em->flush();
  4296.         // return $this->eadResponse($cart->toReturn(), ErrorEnum::SUCCESS);
  4297.         return $this->redirectToRoute('cart');
  4298.     }
  4300.     /**
  4301.      * @Route(
  4302.      *      path          = "/delete/{id}/{isAjaxRequest}",
  4303.      *      name          = "cartDelete",
  4304.      *      methods       = {"GET"},
  4305.      *      requirements  = { "id" = "\d+" },
  4306.      *      defaults      = { "isAjaxRequest" = 0 }
  4307.      * )
  4308.      */
  4309.     public function deleteCart(Request $request) {
  4311.         $isAjaxRequest = (int)$request->get('isAjaxRequest');
  4313.         $cartId = $request->get('id');
  4314.         $cartRepository = $this->em->getRepository(Cart::class);
  4316.         $cart = $cartRepository->findOneBy([
  4317.             "id" => $cartId,
  4318.             "deleted" => CartEnum::ITEM_NO_DELETED
  4319.         ]);
  4320.         
  4321.         if(!$cart){
  4322.             if($isAjaxRequest == CartEnum::YES){
  4323.                 return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  4324.             }
  4325.             return $this->redirectToRoute('notFound');
  4326.         }
  4328.         if($this->user){
  4329.             if($this->user->getId() != $cart->getUser()->getId()){
  4330.                 if($isAjaxRequest == CartEnum::YES){
  4331.                     return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  4332.                 }
  4333.                 return $this->redirectToRoute('notFound');
  4334.             }
  4335.         }else{
  4336.             $cookieName = 'hashcartoff';
  4337.             $hashId = $this->generalService->getCookie($cookieName);
  4339.             if(empty($hashId) || $hashId != $cart->getHashIdentify()){
  4340.                 if($isAjaxRequest == CartEnum::YES){
  4341.                     return $this->eadResponse(null, ErrorEnum::NOT_FOUND);
  4342.                 }
  4343.                 return $this->redirectToRoute('notFound');
  4344.             }
  4345.         }
  4347.         $cartRepository->updateCartProductSuggestion($cart);
  4349.         if($this->user){
  4350.             $whishlistIsActive = $this->em->getRepository(Whishlist::class)->findOneBy([
  4351.                 "product" => $cart->getProduct()->getId(), 
  4352.                 "user" => $cart->getUser()->getId(),
  4353.                 "deleted" => WhishlistEnum::ITEM_NO_DELETED
  4354.             ]);
  4355.     
  4356.             $crmService = $this->generalService->getService('CRM\\CrmService');
  4357.             $dealId = $cart->getPipedriveDeal();
  4358.             $crmService->deleteDeal($dealId);
  4359.     
  4360.             if($whishlistIsActive){
  4361.                 $backWhishlist = $crmService->saveDeal(
  4362.                     $dealId,
  4363.                     $cart->getUser(),
  4364.                     $cart->getProduct(),
  4365.                     'open',
  4366.                     $this->configuration->get("pipedrive_wishlist"),
  4367.                     $cart->getPrice(),
  4368.                     $cart->getProductOffer()->getCurrencyCode()
  4369.                 );
  4370.             }    
  4371.         }
  4373.         $cart->setUtmsUrl(null);
  4374.         $cart->setProductCoupon(null);
  4375.         $cart->delete();
  4376.         $this->em->flush();
  4378.         $mkgService = $this->generalService->getService('Marketing\\MarketingService');
  4379.         $mkgService->setTag(TagsMarketingEnum::TAG_REMOVE_CART);
  4380.         $mkgService->setTextComplement($cart->getProduct()->getTitle());
  4381.         $mkgService->setUser($this->user);
  4382.         $mkgService->send();
  4384.         // AJAX
  4385.         // if($isAjaxRequest == CartEnum::YES){
  4386.             // return $this->redirectToRoute('cart');
  4387.         // }
  4389.         // NAVBAR
  4390.         return $this->redirectToRoute('cart');
  4391.     }
  4392. }