src/Twig/FunctionsExtension.php line 880

Open in your IDE?
  1. <?php
  3. namespace EADPlataforma\Twig;
  5. use Twig\Extension\AbstractExtension;
  6. use Twig\TwigFunction;
  7. use EADPlataforma\Services\GeneralService;
  8. use EADPlataforma\Services\ConfigurationService;
  9. use EADPlataforma\Entity\Cart;
  10. use EADPlataforma\Entity\Course;
  11. use EADPlataforma\Entity\Product;
  12. use EADPlataforma\Entity\ProductOffer;
  13. use EADPlataforma\Entity\ProductCoupon;
  14. use EADPlataforma\Entity\Whishlist;
  15. use EADPlataforma\Entity\Exam;
  16. use EADPlataforma\Entity\Enrollment;
  17. use EADPlataforma\Entity\User;
  18. use EADPlataforma\Entity\Category;
  19. use EADPlataforma\Entity\CourseTestimonial;
  20. use EADPlataforma\Entity\TransactionItem;
  21. use EADPlataforma\Entity\UserCustomField;
  22. use EADPlataforma\Entity\PageSection;
  23. use EADPlataforma\Entity\UserSubscription;
  24. use EADPlataforma\Enum\ExamEnum;
  25. use EADPlataforma\Enum\CartEnum;
  26. use EADPlataforma\Enum\ClientEnum;
  27. use EADPlataforma\Enum\CourseEnum;
  28. use EADPlataforma\Enum\ProductEnum;
  29. use EADPlataforma\Enum\ProductOfferEnum;
  30. use EADPlataforma\Enum\ReceiverEnum;
  31. use EADPlataforma\Enum\WhishlistEnum;
  32. use EADPlataforma\Enum\EnrollmentEnum;
  33. use EADPlataforma\Enum\UserCustomFieldEnum;
  34. use EADPlataforma\Enum\PageSectionEnum;
  35. use EADPlataforma\Util\DateTimeUtil;
  38. class FunctionsExtension extends AbstractExtension
  39. {   
  40.     /**
  41.      * @var GeneralService
  42.      */
  43.     private $generalService;
  45.     /**
  46.      * @var ConfigurationService
  47.      */
  48.     private $configuration;
  50.     /**
  51.      * @var SchoolEntityManager
  52.      */
  53.     protected $em;
  55.     /**
  56.      * @var User $user
  57.      */
  58.     protected $user;
  60.     /**
  61.      * @var Array $results
  62.      */
  63.     protected $results = [];
  64.     
  65.     /**
  66.      * @var Array $arrValue
  67.      */
  68.     protected $arrValue = [];
  70.     // SECTIONS
  71.     private $sectionTemplates = [
  72.         'headSection' => 'includes/menu-section',
  73.         'bannerSection' => 'home/banner-section',
  74.         'searchSection' => 'includes/search-section',
  76.         'productSpotlightOfferSection' => 'product/product-section',
  77.         'enrollmentSection' => 'user/enrollment/enrollment-section',
  78.         'productCourseSection' => 'product/product-section',
  79.         'productLastCourseSection' => 'product/product-section',
  80.         'productBestSellersSection' => 'product/product-section',
  82.         'productPlanSection' => [
  83.             'light' => 'product/product-section',
  84.             'dark'  => 'product/product-box-home-section',
  85.         ],
  87.         'productComboSection' => 'product/product-section',
  88.         'productUserRecomendationSection' => 'product/product-section',
  89.         'productBestSection' => 'product/product-section',
  90.         'productRandomWhishlistSection' => 'product/product-section',
  92.         'productCategorySection' => 'product/product-category-section',
  93.         'teacherSection' => 'teacher/teacher-section',
  94.         'schoolNumberSection' => 'home/school-numbers-section',
  95.         'faqSection' => 'faq/faq-section',
  96.         'testimonialSection' => 'course/course-testimonial-section',
  97.         'newsSection' => 'home/newsletter-section',
  98.         'socialSection' => 'includes/social-section',
  99.         'institutionalSection' => 'institutional/institutional-section',
  100.         'stampsSection' => 'includes/stamps-section',
  101.     ];
  103.     /**
  104.      * Constructor
  105.      *
  106.      * @param GeneralService $generalService
  107.      */
  108.     public function __construct(GeneralService $generalService)
  109.     {
  110.         $this->generalService = $generalService;
  111.         $this->em = $this->generalService->getService('SchoolEntityManager');
  112.     }
  114.     public function getConfiguration()
  115.     {   
  116.         if(!$this->configuration){
  117.             $this->configuration = $this->generalService->getService('ConfigurationService');
  118.         }
  120.         return $this->configuration;
  121.     }
  123.     public function getUser()
  124.     {
  125.         if(!$this->user){
  126.             $this->user = $this->generalService->getService('UserSessionService')->getUser();
  127.         }
  129.         return $this->user;
  130.     }
  132.     public function getFunctions()
  133.     {
  134.         return [
  135.             new TwigFunction('getConfig', [$this, 'getConfig']),
  136.             new TwigFunction('getCss', [$this, 'getCss']),
  137.             new TwigFunction('getScript', [$this, 'getScript']),
  138.             new TwigFunction('checkConfigHasScript', [$this, 'checkConfigHasScript']),
  139.             new TwigFunction('getMeta', [$this, 'getMeta']),
  140.             new TwigFunction('getConfigPayment', [$this, 'getConfigPayment']),
  141.             new TwigFunction('isModuleActive', [$this, 'isModuleActive']),
  142.             new TwigFunction('isPlanModuleActive', [$this, 'isPlanModuleActive']),
  143.             new TwigFunction('getSection', [$this, 'getSection']),
  144.             new TwigFunction('getPermission', [$this, 'getPermission']),
  145.             new TwigFunction('isLow', [$this, 'isLow']),
  146.             new TwigFunction('isMiddle', [$this, 'isMiddle']),
  147.             new TwigFunction('isHigh', [$this, 'isHigh']),
  148.             new TwigFunction(
  149.                 'getInfoAccessProductOffer', [$this, 'getInfoAccessProductOffer']
  150.             ),
  151.             new TwigFunction(
  152.                 'checkProductOfferIsOnSale', [$this, 'checkProductOfferIsOnSale']
  153.             ),
  154.             new TwigFunction(
  155.                 'getOfferProductSubscription', [$this, 'getOfferProductSubscription']
  156.             ),
  157.             new TwigFunction('getClient', [$this, 'getClient']),
  158.             new TwigFunction('getUserCartNumber', [$this, 'getUserCartNumber']),
  159.             new TwigFunction('getUserCartSubTotal', [$this, 'getUserCartSubTotal']),
  160.             new TwigFunction('getUserCartMenuItems', [$this, 'getUserCartMenuItems']),
  161.             new TwigFunction('productIsInCart', [$this, 'productIsInCart']),
  162.             new TwigFunction('getExamType', [$this, 'getExamType']),
  163.             new TwigFunction('getEnrollmentStatus', [$this, 'getEnrollmentStatus']),
  164.             new TwigFunction('getEnrollmentSituation', [$this, 'getEnrollmentSituation']),
  165.             new TwigFunction(
  166.                 'getEnrollmentSituationClass', [$this, 'getEnrollmentSituationClass']
  167.             ),
  168.             new TwigFunction(
  169.                 'getEnrollmentPeriodLabel', [$this, 'getEnrollmentPeriodLabel']
  170.             ),
  171.             new TwigFunction('printValueOrEmpty', [$this, 'printValueOrEmpty']),
  172.             new TwigFunction('isInWhishlist', [$this, 'isInWhishlist']),
  173.             new TwigFunction('plural', [$this, 'plural']),
  174.             new TwigFunction('installments', [$this, 'installments']),
  175.             new TwigFunction('htmlDecode', [$this, 'htmlDecode']),
  176.             new TwigFunction('getLanguage', [$this, 'getLanguage']),
  177.             new TwigFunction('getLanguageModule', [$this, 'getLanguageModule']),
  178.             new TwigFunction('workLoadText', [$this, 'workLoadText']),
  179.             new TwigFunction('existReceiverEAD', [$this, 'existReceiverEAD']),
  180.             new TwigFunction('getFilePathComplete', [$this, 'getFilePathComplete']),
  181.             new TwigFunction('getTextProductType', [$this, 'getTextProductType']),
  182.             new TwigFunction('discountPercent', [$this, 'discountPercent']),
  183.             new TwigFunction('enum', [$this, 'enum']),
  184.             new TwigFunction('getScoreCourse', [$this, 'getScoreCourse']),
  185.             new TwigFunction('getScoreProduct', [$this, 'getScoreProduct']),
  186.             new TwigFunction('getTimeTotalProduct', [$this, 'getTimeTotalProduct']),
  187.             new TwigFunction('getOfferParcelInfo', [$this, 'getOfferParcelInfo']),
  188.             new TwigFunction('getOfferContract', [$this, 'getOfferContract']),
  189.             new TwigFunction('installmentPeriodText', [$this, 'installmentPeriodText']),
  190.             new TwigFunction('courseByProductTotal', [$this, 'courseByProductTotal']),
  191.             new TwigFunction('userHasProduct', [$this, 'userHasProduct']),
  192.             new TwigFunction('hasInCart', [$this, 'hasInCart']),
  193.             new TwigFunction(
  194.                 'getFirstCourseIdFromProduct', [$this, 'getFirstCourseIdFromProduct']
  195.             ),
  196.             new TwigFunction(
  197.                 'getProductTypeTextTranslate', [$this, 'getProductTypeTextTranslate']
  198.             ),
  199.             new TwigFunction('encodeHex', [$this, 'encodeHex']),
  200.             new TwigFunction('getDefaultRecaptcha', [$this, 'getDefaultRecaptcha']),
  201.             new TwigFunction('getFields', [$this, 'getFields']),
  202.             new TwigFunction('clearSocialUrl', [$this, 'clearSocialUrl']),
  203.             new TwigFunction('checkSection', [$this, 'checkSection']),
  204.             new TwigFunction('paintStars', [$this, 'paintStars']),
  205.             new TwigFunction('getCategoryOffers', [$this, 'getCategoryOffers']),
  206.             new TwigFunction('HEXtoRGB', [$this, 'HEXtoRGB']),
  207.             new TwigFunction('RGBtoHSL', [$this, 'RGBtoHSL']),
  208.             new TwigFunction('HEXtoHSL', [$this, 'HEXtoHSL']),
  209.             new TwigFunction('setValue', [$this, 'setValue']),
  210.             new TwigFunction('getValue', [$this, 'getValue']),
  211.             new TwigFunction('pageSectionFormat', [$this, 'pageSectionFormat']),
  212.             new TwigFunction('pageSectionPosition', [$this, 'pageSectionPosition']),
  213.             new TwigFunction('pageSectionTemplateItem', [$this, 'pageSectionTemplateItem']),
  214.             new TwigFunction('pageSectionItems', [$this, 'pageSectionItems']),
  215.             new TwigFunction('pageSectionLinkAll', [$this, 'pageSectionLinkAll']),
  216.             new TwigFunction('isPageSection', [$this, 'isPageSection']),
  217.             new TwigFunction('pageSectionShowAll', [$this, 'pageSectionShowAll']),
  218.             new TwigFunction('getPlanCycleString', [$this, 'getPlanCycleString']),
  219.             new TwigFunction('getPlanCycleStringProductDetail', [
  220.                 $this, 'getPlanCycleStringProductDetail'
  221.             ]),
  222.             new TwigFunction('getDocumentFormat', [$this, 'getDocumentFormat']),
  223.             new TwigFunction('getUserSubscriptionError', [$this, 'getUserSubscriptionError']),
  224.             new TwigFunction('getVimeoFormatIframe', [$this, 'getVimeoFormatIframe']),
  225.             new TwigFunction('isValidCard', [$this, 'isValidCard']),
  226.             new TwigFunction('stringOrigin', [$this, 'stringOrigin']),
  227.             new TwigFunction('stringStatus', [$this, 'stringStatus']),
  228.         ];
  229.     }
  231.     public function getConfig(string $configName)
  232.     {
  233.         $value = $this->getConfiguration()->get($configName);
  235.         $cleanKeys = [
  236.             "contract",
  237.             "privacy_policy",
  238.         ];
  240.         if(in_array($configName, $cleanKeys)){
  241.             $stringUtil = $this->generalService->getUtil('StringUtil');
  242.             $value = $stringUtil->removeScripts($value);
  243.         }
  245.         return $value;
  246.     }
  248.     public function getMeta(string $configName)
  249.     {
  250.         return $this->getConfiguration()->get($configName);
  251.     }
  253.     public function getCss(string $configName)
  254.     {
  255.         return $this->getConfiguration()->get($configName);
  256.     }
  258.     public function getScript(string $configName, ?string $nonceHash = "")
  259.     {
  260.         $value = $this->getConfiguration()->get($configName);
  262.         $scripts = [ 'scripts' ];
  264.         if(in_array($configName, $scripts)){
  265.             $value = htmlspecialchars_decode($value, ENT_QUOTES);
  266.         }
  268.         $value = str_replace("<script ", "<script nonce='{$nonceHash}' ", $value);
  269.         $value = str_replace("<script>", "<script nonce='{$nonceHash}'>", $value);
  271.         return $value;
  272.     }
  274.     public function checkConfigHasScript(string $configName)
  275.     {
  276.         $value = $this->getConfiguration()->get($configName);
  277.         
  278.         return stristr($value, 'script');
  279.     }
  281.     public function getConfigPayment()
  282.     {
  283.         return $this->getConfiguration()->getPaymentConfig();
  284.     }
  286.     public function isModuleActive($moduleName)
  287.     {
  288.         return $this->getConfiguration()->isModuleActive($moduleName);
  289.     }
  291.     public function isPlanModuleActive($moduleName)
  292.     {
  293.         return $this->getConfiguration()->checkModuleIsAbleOnPlan($moduleName);
  294.     }
  296.     public function getPermission($level1 = null, $level2 = null, $level3 = null, $level4 = null)
  297.     {
  298.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  300.         return $userPermissionUtil->getPermission($level1, $level2, $level3, $level4);
  301.     }
  303.     public function isLow(int $permissionValue)
  304.     {
  305.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  307.         return $userPermissionUtil->isLow($permissionValue);
  308.     }
  310.     public function isMiddle(int $permissionValue)
  311.     {
  312.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  314.         return $userPermissionUtil->isMiddle($permissionValue);
  315.     }
  317.     public function isHigh(int $permissionValue)
  318.     {
  319.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  321.         return $userPermissionUtil->isHigh($permissionValue);
  322.     }
  324.     public function getInfoAccessProductOffer(
  325.         ProductOffer $productOffer, 
  326.         ?bool $isNext = false, 
  327.         ?ProductCoupon $productCoupon = null, 
  328.         ?bool $isOfferSpotligth = false
  329.     )
  330.     {
  331.         $data = (object)[
  332.             "link" => "#",
  333.             "text" => "buy_now",
  334.             "allowBuyNow" => false,
  335.             "isFree" => false,
  336.             "dateSaleOffer" => null,
  337.             "userHasProduct" => false,
  338.             "saleOfferStart" => false,
  339.             "saleChannelOption" => false,
  340.             "colorBtnWaitList" => false
  341.         ];
  343.         $product = $productOffer->getProduct();
  344.         $productRepository = $this->em->getRepository(Product::class);
  346.         if($this->getUser()){
  347.             $dataProduct = $productRepository->userHasProduct($this->getUser(), $product);
  349.             if($dataProduct){
  350.                 $data->userHasProduct = true;
  351.                 $routeName = null;
  352.                 $routeParams = null;
  353.                 if($dataProduct->type == ProductEnum::COURSE){
  354.                     $routeName = 'courseIndex';
  356.                     $routeParams = [ 
  357.                         "id" => $dataProduct->elementId 
  358.                     ];
  359.                 }else if($dataProduct->type == ProductEnum::SUBSCRIPTION){
  360.                     $routeName = 'resume';
  361.                 }
  363.                 if(!empty($routeName)){
  364.                     $data->link = $this->generalService->generateUrl(
  365.                         $routeName, 
  366.                         $routeParams
  367.                     );
  368.                     $data->text = $this->getConfiguration()->getLanguage(
  369.                         'access2', 'product'
  370.                     );
  371.                 }
  372.             }
  373.         }
  375.         if(!$data->userHasProduct){
  377.             $saleIsOpen = $this->checkProductOfferIsOnSale($productOffer);
  378.             if(
  379.                 $productOffer->getSaleOption() == ProductOfferEnum::FREE && 
  380.                 $saleIsOpen
  381.             ){
  383.                 $data->isFree = true;
  385.                 if($productOffer->getSaleChannel() == ProductOfferEnum::EXTERNAL){
  386.                     $data->link = $productOffer->getExternalCheckoutLink();
  387.                     $data->saleChannelOption = true;
  388.                 }else{
  389.                     if($this->getUser()){
  390.                         $data->link = $this->generalService->generateUrl(
  391.                             'cartCreateEnroll', 
  392.                             [ "productOfferId" => $productOffer->getId() ]
  393.                         );
  394.                     }else{
  395.                         $data->link = '#fast-register-modal';
  396.                     }
  397.                 }
  399.                 $data->text = $this->getConfiguration()->getLanguage(
  400.                     'enroll', 'product'
  401.                 );
  402.                 
  403.             }else{
  404.                 if($saleIsOpen){
  405.                     if($productOffer->getSaleChannel() == ProductOfferEnum::EXTERNAL){
  406.                         $data->link = $productOffer->getExternalCheckoutLink();
  407.                         $data->saleChannelOption = true;
  408.                     }else{
  409.                         $data->allowBuyNow = true;
  410.                         $data->link = $this->generalService->generateUrl('cartAdd', [ 
  411.                             "poID" => $productOffer->getId(),
  412.                             "pcID" => ($productCoupon ? $productCoupon->getId() : 0)
  413.                         ]);
  415.                         if(
  416.                             $productOffer->getAllowRecurrency() == ProductOfferEnum::YES || 
  417.                             $product->getType() == ProductEnum::SUBSCRIPTION
  418.                         ){
  419.                             $data->text = $this->getConfiguration()->getLanguage(
  420.                                 'subscribe_now', 'product'
  421.                             );
  423.                             if($productOffer->getAllowTrial() == ProductOfferEnum::YES){
  424.                                 $data->saleChannelOption = true;
  425.                             }
  426.                                 
  427.                             if(
  428.                                 $product->getType() == ProductEnum::SUBSCRIPTION && 
  429.                                 $isOfferSpotligth
  430.                             ){
  431.                                 $data->link = "#section-plan-cycles";
  432.                             }else if($productOffer->getAllowTrial() == ProductOfferEnum::YES){
  433.                                 $dataProduct = false;
  434.                                 if($this->getUser()){
  435.                                     $dataProduct = $productRepository->userHasProduct(
  436.                                         $this->getUser(), 
  437.                                         $product,
  438.                                         true
  439.                                     );
  440.                                 }
  442.                                 if(!$dataProduct || empty($this->getUser())){
  443.                                     $data->link = $this->generalService->generateUrl(
  444.                                         'cartIndividual', [ 
  445.                                         "poHash" => $productOffer->getOfferLink(),
  446.                                         "pcKey" => (
  447.                                             $productCoupon ? 
  448.                                             $productCoupon->getKey() : 
  449.                                             null
  450.                                         )
  451.                                     ]);
  452.                                 }
  453.                             }
  454.                         }
  455.                     }
  456.                 }else{
  457.                     $next = $productOffer->getNextProductOffer();
  458.                     if($next && !$isNext){
  459.                         if(
  460.                             $next->getStatus() == ProductOfferEnum::PUBLISHED && 
  461.                             $next->isNotDeleted()
  462.                         ){
  463.                             return $this->getInfoAccessProductOffer(
  464.                                 $next, 
  465.                                 true, 
  466.                                 $productCoupon
  467.                             );
  468.                         }
  469.                     }
  471.                     $getDiffStart = $productOffer->getDiffDuration();
  473.                     if($getDiffStart['start'] == true) {
  474.                         $data->dateSaleOffer = $productOffer->getSaleDateStart();
  475.                         $data->saleOfferStart = true;
  476.                     }else{
  477.                         $data->dateSaleOffer = $productOffer->getSaleDateClose();
  478.                     }
  480.                     $data->colorBtnWaitList = true;
  481.                     $data->link = '#wait-list-modal';
  482.                     $data->text = $this->getConfiguration()->getLanguage(
  483.                         'join_the_list',
  484.                         'product'
  485.                     );
  486.                 }
  487.             }
  488.         }
  490.         return $data;
  491.     }
  493.     public function getOfferProductSubscription(ProductOffer $productOfferDefault)
  494.     {
  495.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  496.         $product = $productOfferDefault->getProduct();
  498.         $monthOffer = $productOfferRepository->getDefaultOrCustomByCycle(
  499.             $product,
  500.             ProductOfferEnum::CYCLE_MONTHLY
  501.         );
  503.         $quarterlyOffer = $productOfferRepository->getDefaultOrCustomByCycle(
  504.             $product,
  505.             ProductOfferEnum::CYCLE_QUARTERLY
  506.         );
  508.         $semiannualOffer = $productOfferRepository->getDefaultOrCustomByCycle(
  509.             $product,
  510.             ProductOfferEnum::CYCLE_SEMIANNUAL
  511.         );
  513.         $yearlyOffer = $productOfferRepository->getDefaultOrCustomByCycle(
  514.             $product,
  515.             ProductOfferEnum::CYCLE_YEARLY
  516.         );
  518.         $biennialOffer = $productOfferRepository->getDefaultOrCustomByCycle(
  519.             $product,
  520.             ProductOfferEnum::CYCLE_BIENNIAL
  521.         );
  523.         $triennialOffer = $productOfferRepository->getDefaultOrCustomByCycle(
  524.             $product,
  525.             ProductOfferEnum::CYCLE_TRIENNIAL
  526.         );
  528.         $weeklyOffer = $productOfferRepository->getDefaultOrCustomByCycle(
  529.             $product,
  530.             ProductOfferEnum::CYCLE_WEEKLY
  531.         );
  533.         $biweeklyOffer = $productOfferRepository->getDefaultOrCustomByCycle(
  534.             $product,
  535.             ProductOfferEnum::CYCLE_BIWEEKLY
  536.         );
  538.         $productOffers = array_filter([
  539.             $monthOffer,
  540.             $quarterlyOffer,
  541.             $semiannualOffer,
  542.             $yearlyOffer,
  543.             $biennialOffer,
  544.             $triennialOffer,
  545.             $weeklyOffer,
  546.             $biweeklyOffer,
  547.         ]);
  549.         return $productOfferRepository->returnProductOfferOrProductNextPlan(
  550.             $productOfferDefault, 
  551.             $productOffers
  552.         );
  553.     }
  555.     public function checkProductOfferIsOnSale(ProductOffer $productOffer)
  556.     {
  557.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  558.         return $productOfferRepository->checkProductOfferIsOnSale($productOffer);
  559.     }
  561.     public function getClient()
  562.     {
  563.         return $this->getConfiguration()->getClient();
  564.     }
  566.     public function getUserCartNumber()
  567.     {
  568.         $cartRepository = $this->em->getRepository(Cart::class);
  569.         return $cartRepository->countUserOnCart();
  570.     }
  572.     public function getUserCartSubTotal()
  573.     {
  574.         $cartRepository = $this->em->getRepository(Cart::class);
  575.         if($this->getUser()){
  576.             return $cartRepository->getUserSubTotal($this->getUser()->getId());
  577.         }else{
  578.             $hashIdentify = $this->generalService->getCookie('hashcartoff');
  579.             if(!empty($hashIdentify)){
  580.                 return $cartRepository->getHashSubTotal($hashIdentify);
  581.             }
  582.         }
  583.         return 0;
  584.     }
  586.     public function getUserCartMenuItems(?int $limit = 2)
  587.     {
  588.         $cartRepository = $this->em->getRepository(Cart::class);
  589.         if($this->getUser()){
  590.             return $cartRepository->getUserValidCarts($this->getUser()->getId(), null, $limit);
  591.         }else{
  592.             $hashIdentify = $this->generalService->getCookie('hashcartoff');
  593.             if(!empty($hashIdentify)){
  594.                 return $cartRepository->getHashValidCarts($hashIdentify, null, $limit);
  595.             }
  596.         }
  598.         return [];
  599.     }
  601.     public function productIsInCart(int $productId, ?int $productOfferId = null)
  602.     {
  603.         $cartRepository = $this->em->getRepository(Cart::class);
  605.         $hashIdentify = $this->generalService->getCookie('hashcartoff');
  606.         if(!$this->getUser() && empty($hashIdentify)){
  607.             return false;
  608.         }
  610.         $filter = [
  611.             "product" => $productId, 
  612.             "deleted" => CartEnum::ITEM_NO_DELETED
  613.         ];
  615.         if($this->getUser()){
  616.             $filter["user"] = $this->getUser()->getId();
  617.         }else if(!empty($hashIdentify)){
  618.             $filter["hashIdentify"] = $hashIdentify;
  619.         }
  621.         if(!empty($productOfferId)){
  622.             $filter["productOffer"] = $productOfferId;
  623.         }
  625.         $cartSave = $cartRepository->findOneBy($filter);
  627.         return ($cartSave ? true : false);
  628.     }
  630.     public function getExamType(int $examType)
  631.     {
  632.         $examRepository = $this->em->getRepository(Exam::class);
  633.         return $examRepository->getExamTypeText($examType);
  634.     }
  636.     public function getEnrollmentStatus(int $status)
  637.     {
  638.         $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  639.         return $enrollmentRepository->getStringStatus($status);
  640.     }
  642.     public function getEnrollmentSituation(?Enrollment $enrollment = null)
  643.     {
  644.         $situation = EnrollmentEnum::SITUATION_NOT_STARTED;
  645.         if($enrollment){
  646.             $situation = $enrollment->getSituation();
  647.         }
  649.         $situationLabels = [
  650.             EnrollmentEnum::SITUATION_STARTED => "in_progress",
  651.             EnrollmentEnum::SITUATION_NOT_STARTED => "not_started",
  652.             EnrollmentEnum::SITUATION_COMPLETED => "completed",
  653.         ];
  655.         $index = $situationLabels[$situation];
  657.         return $this->getConfiguration()->getLanguage($index, 'user_resume');
  658.     }
  660.     public function getEnrollmentSituationClass(?Enrollment $enrollment = null)
  661.     {
  662.         $situation = EnrollmentEnum::SITUATION_NOT_STARTED;
  663.         if($enrollment){
  664.             $situation = $enrollment->getSituation();
  665.         }
  667.         $situationLabels = [
  668.             EnrollmentEnum::SITUATION_STARTED => "information",
  669.             EnrollmentEnum::SITUATION_NOT_STARTED => "",
  670.             EnrollmentEnum::SITUATION_COMPLETED => "success",
  671.         ];
  673.         return $situationLabels[$situation];
  674.     }
  676.     public function getEnrollmentPeriodLabel(?Enrollment $enrollment = null, ?Course $course = null)
  677.     {
  678.         if($enrollment){
  679.             $datePeriod = $enrollment->getDatePeriod('d/m/Y');
  680.             if($datePeriod == "09/09/9999"){
  681.                 return $this->getConfiguration()->getLanguage('lifetime', 'enrollments');
  682.             }
  684.             if($enrollment->getStatus(false, true) == EnrollmentEnum::STATUS_EXPIRED){
  685.                 return $this->getConfiguration()->getLanguage('expired', 'user_resume');
  686.             }
  688.             $txt = $this->getConfiguration()->getLanguage('access_until', 'user_resume');
  689.             if($datePeriod == date('d/m/Y')){
  690.                 $time = date('H:i:s');
  691.                 return "{$txt} {$time}";
  692.             }
  694.             return "{$txt} {$datePeriod}";
  696.         }else if($course){
  698.             if($course->getLifetimePeriod() == CourseEnum::YES){
  699.                 return $this->getConfiguration()->getLanguage('lifetime', 'enrollments');
  700.             }
  702.             $datePeriod = date('d/m/Y', strtotime(" + {$course->getAccessPeriod()} days"));
  703.             $txt = $this->getConfiguration()->getLanguage('access_until', 'user_resume');
  704.             
  705.             return "{$txt} {$datePeriod}";
  706.         }
  708.         return $this->getConfiguration()->getLanguage('expired', 'user_resume');
  709.     }
  711.     public function isInWhishlist(int $productId)
  712.     {
  713.         if(!$this->getUser()){
  714.             return false;
  715.         }
  717.         $whishlistRepository = $this->em->getRepository(Whishlist::class);
  719.         $whishlistSave = $whishlistRepository->findOneBy([
  720.             "product" => $productId, 
  721.             "user" => $this->getUser()->getId(),
  722.             "deleted" => WhishlistEnum::ITEM_NO_DELETED
  723.         ]);
  725.         return ( $whishlistSave ? true : false );
  726.     }
  728.     public function printValueOrEmpty($value)
  729.     {
  730.         return (!empty($value) ? $value : '---');
  731.     }
  733.     public function getSection($sectionName)
  734.     {
  735.         $theme = $this->getConfiguration()->get('website_theme');
  737.         if(empty($theme))
  738.         {
  739.             $theme = 'light';
  740.         }
  742.         if(empty($this->sectionTemplates[$sectionName]))
  743.         {
  744.             return false;
  745.         }
  747.         $sectionFile = $this->sectionTemplates[$sectionName];
  749.         if(is_array($sectionFile))
  750.         {
  751.             $sectionFile = $sectionFile[$theme];
  752.         }
  754.         $sectionFile = "website/{$sectionFile}.html.twig";
  756.         return $sectionFile;
  757.     }
  759.     // PLURAL
  760.     public function plural($numero, $tx_singular, $tx_plural)
  761.     {
  762.         return ($numero == 1) ? $tx_singular : $tx_plural;
  763.     }
  765.     // INSTALLMENTS
  766.     public function installmentPeriodText($subscriptionCycleEnum)
  767.     {
  768.         // Cycle X Months
  769.         $installmentMonths = [
  770.             ProductOfferEnum::CYCLE_MONTHLY => [
  771.                 "period" => 1,
  772.                 "text" => $this->getConfiguration()->getLanguage('monthly', 'product'),
  773.                 "textPlan" => $this->getConfiguration()->getLanguage('monthly_plan', 'product'),
  774.             ],
  776.             ProductOfferEnum::CYCLE_QUARTERLY => [
  777.                 "period" => 3,
  778.                 "text" => $this->getConfiguration()->getLanguage('quarterly', 'product'),
  779.                 "textPlan" => $this->getConfiguration()->getLanguage('quarterly_plan', 'product'),
  780.             ],
  782.             ProductOfferEnum::CYCLE_SEMIANNUAL => [
  783.                 "period" => 6,
  784.                 "text" => $this->getConfiguration()->getLanguage('semiannual', 'product'),
  785.                 "textPlan" => $this->getConfiguration()->getLanguage('semiannual_plan', 'product'),
  786.             ],
  788.             ProductOfferEnum::CYCLE_YEARLY => [
  789.                 "period" => 12,
  790.                 "text" => $this->getConfiguration()->getLanguage('yearly', 'product'),
  791.                 "textPlan" => $this->getConfiguration()->getLanguage('yearly_plan', 'product'),
  792.             ],
  794.             ProductOfferEnum::CYCLE_WEEKLY => [
  795.                 "period" => 1,
  796.                 "text" => $this->getConfiguration()->getLanguage('weekly', 'product'),
  797.                 "textPlan" => $this->getConfiguration()->getLanguage('weekly_plan', 'product'),
  798.             ],
  800.             ProductOfferEnum::CYCLE_BIWEEKLY => [
  801.                 "period" => 1,
  802.                 "text" => $this->getConfiguration()->getLanguage('biweekly', 'product'),
  803.                 "textPlan" => $this->getConfiguration()->getLanguage('biweekly_plan', 'product'),
  804.             ],
  806.             ProductOfferEnum::CYCLE_BIENNIAL => [
  807.                 "period" => 24,
  808.                 "text" => $this->getConfiguration()->getLanguage('biennial', 'product'),
  809.                 "textPlan" => $this->getConfiguration()->getLanguage('biennial_plan', 'product'),
  810.             ],
  812.             ProductOfferEnum::CYCLE_TRIENNIAL => [
  813.                 "period" => 36,
  814.                 "text" => $this->getConfiguration()->getLanguage('triennial', 'product'),
  815.                 "textPlan" => $this->getConfiguration()->getLanguage('triennial_plan', 'product'),
  816.             ],
  817.         ];
  819.         if (isset($installmentMonths[$subscriptionCycleEnum])){
  820.             return (object)$installmentMonths[$subscriptionCycleEnum];
  821.         }
  823.         return (object)$installmentMonths[ProductOfferEnum::CYCLE_MONTHLY];
  824.     }
  826.     public function installments(ProductOffer $productOffer)
  827.     {
  828.         $months = $this->installmentPeriodText($productOffer->getPlanCycle());
  830.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  832.         $numberUtil = $this->generalService->getUtil('NumberUtil');
  833.         
  834.         $parcelInfo = $numberUtil->getNumberMaxParcel(
  835.             $productOffer->getPriceReal(true),
  836.             $productOfferRepository->getInstallmentNumberMax($productOffer),
  837.             $productOfferRepository->getFreeInstallment($productOffer),
  838.             $productOffer->getSaleOption(),
  839.             $productOffer->getTypeCheckout(),
  840.             false
  841.         );
  843.         return [
  844.             'number'=> $parcelInfo->maxInstallments,
  845.             'value' => $parcelInfo->parcelPrice,
  846.             'period'=> $months->text,
  847.         ];
  848.     }
  850.     // HTML DECODE ENTITIES
  851.     public function htmlDecode($txt)
  852.     {
  853.         return html_entity_decode($txt);
  854.     }
  856.     // HTML DECODE ENTITIES
  857.     public function existReceiverEAD()
  858.     {
  859.         $receiverSchool = $this->getConfiguration()->getReceiverSchool(ReceiverEnum::EAD_CHECKOUT);
  861.         return ($receiverSchool? true : false);
  862.     }
  864.     // TRANSLATION
  865.     public function getLanguage($key, $file){
  866.         return $this->getConfiguration()->getLanguage($key, $file);
  867.     }
  869.     public function getLanguageModule($module){
  870.         return $this->getConfiguration()->getLanguageModule($module);
  871.     }
  873.     public function workLoadText(?string $workload = null)
  874.     {
  876.         if(empty($workload)){
  877.             return;
  878.         }
  880.         return DateTimeUtil::workloadFormat(
  881.             $workload, false, $this->getLanguageModule('util')
  882.         );
  883.     }
  885.     public function getFilePathComplete($config)
  886.     {
  887.         $fileService = $this->generalService->getService('FileService');
  889.         $config = (object)$config;
  891.         $config->fileName = (!empty($config->fileName) ? $config->fileName : null);
  892.         $config->pathConst = (!empty($config->pathConst) ? $config->pathConst : null);
  893.         $config->addUpload = (!empty($config->addUpload) ? $config->addUpload : false);
  894.         $config->addStream = (!empty($config->addStream) ? $config->addStream : false);
  895.         $config->option = (!empty($config->option) ? $config->option : null);
  897.         $pathCdn = $fileService->getFilePathComplete(
  898.             $config->fileName,
  899.             $config->pathConst,
  900.             $config->addUpload,
  901.             $config->addStream,
  902.             $config->option,
  903.             true
  904.         );
  906.         $pathCreateCrop = $fileService->getFilePathComplete(
  907.             $config->fileName,
  908.             $config->pathConst,
  909.             $config->addUpload,
  910.             $config->addStream,
  911.             $config->option
  912.         );
  914.         return (object)[
  915.             "pathCdn" => $pathCdn,
  916.             "pathCreateCrop" => $pathCreateCrop,
  917.         ];
  918.     }
  920.     public function getTextProductType($type)
  921.     {
  922.         switch ($type) {
  923.             case ProductEnum::COURSE:
  924.                 return 'curso';
  925.                 break;
  926.             case ProductEnum::SUBSCRIPTION:
  927.                 return 'plano';
  928.                 break;
  929.             case ProductEnum::COMBO:
  930.                 return 'combo';
  931.                 break;
  932.             case ProductEnum::CERTIFICATE:
  933.                 return 'certificado';
  934.                 break;
  935.             case ProductEnum::LIVE:
  936.                 return 'live';
  937.                 break;
  938.         }
  939.     }
  941.     public function getProductTypeTextTranslate(int $type)
  942.     {
  943.         switch ($type) {
  944.             case ProductEnum::COURSE:
  945.                 return $this->getConfiguration()->getLanguage('course', 'util');
  946.                 break;
  947.             case ProductEnum::SUBSCRIPTION:
  948.                 return $this->getConfiguration()->getLanguage('subscription', 'util');
  949.                 break;
  950.             case ProductEnum::COMBO:
  951.                 return 'Combo';
  952.                 break;
  953.             default:
  954.                 return $this->getConfiguration()->getLanguage('course', 'util');;
  955.                 break;
  956.         }
  957.         
  958.         return 0;
  959.     }
  961.     public function discountPercent($priceReal, $priceDisplay)
  962.     {
  963.         return ($priceDisplay == 0)? false : (1 - $priceReal / $priceDisplay) * 100;
  964.     }
  966.     public function enum($key)
  967.     {
  968.         return constant("EADPlataforma\\Enum\\{$key}");
  969.     }
  971.     public function getScoreCourse(Course $course)
  972.     {
  973.         $courseTestimonialRepository = $this->em->getRepository(CourseTestimonial::class);
  975.         //Course Stars
  976.         $scoreCourse = $courseTestimonialRepository->getScoreByCourse(
  977.             $course
  978.         );
  980.         if(empty($scoreCourse->fiveStar)){
  981.             $scoreCourse->fiveStar = CourseEnum::NO;
  982.         }
  983.           
  984.         if(empty($scoreCourse->fourStar)){
  985.             $scoreCourse->fourStar = CourseEnum::NO;
  986.         }
  987.         
  988.         if(empty($scoreCourse->threeStar)){
  989.             $scoreCourse->threeStar = CourseEnum::NO;
  990.         }
  991.         
  992.         if(empty($scoreCourse->twoStar)){
  993.             $scoreCourse->twoStar = CourseEnum::NO;
  994.         }
  995.         
  996.         if(empty($scoreCourse->oneStar)){
  997.             $scoreCourse->oneStar = CourseEnum::NO;
  998.         }
  1000.         $scoreCourse->splitScore = [
  1001.             $scoreCourse->fiveStar,
  1002.             $scoreCourse->fourStar,
  1003.             $scoreCourse->threeStar,
  1004.             $scoreCourse->twoStar,
  1005.             $scoreCourse->oneStar,
  1006.         ];
  1008.         return $scoreCourse;
  1009.     }
  1011.     public function getTimeTotalProduct(Product $product)
  1012.     {
  1013.         $courseRepository = $this->em->getRepository(Course::class);
  1014.         $timeTotal = $courseRepository->getAllCourseTimeByProduct($product);
  1016.         return $timeTotal;
  1017.     }
  1019.     public function getScoreProduct(Product $product)
  1020.     {
  1021.         $courseTestimonialRepository = $this->em->getRepository(CourseTestimonial::class);
  1023.         //Course Stars
  1024.         $scoreProduct = $courseTestimonialRepository->getScoreByProduct(
  1025.             $product
  1026.         );
  1027.         
  1028.         if(empty($scoreProduct->fiveStar)){
  1029.             $scoreProduct->fiveStar = ProductEnum::NO;
  1030.         }
  1031.           
  1032.         if(empty($scoreProduct->fourStar)){
  1033.             $scoreProduct->fourStar = ProductEnum::NO;
  1034.         }
  1035.         
  1036.         if(empty($scoreProduct->threeStar)){
  1037.             $scoreProduct->threeStar = ProductEnum::NO;
  1038.         }
  1039.         
  1040.         if(empty($scoreProduct->twoStar)){
  1041.             $scoreProduct->twoStar = ProductEnum::NO;
  1042.         }
  1043.         
  1044.         if(empty($scoreProduct->oneStar)){
  1045.             $scoreProduct->oneStar = ProductEnum::NO;
  1046.         }
  1048.         $scoreProduct->splitScore = [
  1049.             $scoreProduct->fiveStar,
  1050.             $scoreProduct->fourStar,
  1051.             $scoreProduct->threeStar,
  1052.             $scoreProduct->twoStar,
  1053.             $scoreProduct->oneStar,
  1054.         ];
  1056.         return $scoreProduct;
  1057.     }
  1059.     public function getOfferContract(ProductOffer $productOffer)
  1060.     {
  1061.         // Product contract
  1062.         $contract = trim($productOffer->getProduct()->getContract());
  1064.         if (empty($contract) or preg_match('/^null$/i', $contract))
  1065.         {
  1066.             // Config contract
  1067.             $contract = trim($this->getConfig('contract'));
  1069.             if (empty($contract) or preg_match('/^null$/i', $contract))
  1070.             {
  1071.                 $contract = false;
  1072.             }
  1073.         }
  1075.         return $contract;
  1076.     }
  1078.     public function getOfferParcelInfo(ProductOffer $productOffer, ?Cart $cart = null)
  1079.     {
  1080.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  1081.         $numberUtil = $this->generalService->getUtil('NumberUtil');
  1083.         $freeInstallments = $productOfferRepository->getFreeInstallment($productOffer);
  1084.         $parcelInfo = $numberUtil->getNumberMaxParcel(
  1085.             ($cart ? $cart->getPrice(true) : $productOffer->getPriceReal(true)),
  1086.             $productOfferRepository->getInstallmentNumberMax($productOffer),
  1087.             $freeInstallments,
  1088.             $productOffer->getSaleOption(),
  1089.             $productOffer->getTypeCheckout(),
  1090.             false
  1091.         );
  1093.         $paymentConfig = $this->getConfiguration()->getPaymentConfig();
  1095.         $pagarMeTransaction = $this->generalService->getService(
  1096.             'PagarMe\\PagarMeTransaction'
  1097.         );
  1099.         $installmentsOptions = $pagarMeTransaction->calculateInstallments([
  1100.             'amount' => $productOffer->getPriceReal(true),
  1101.             'free_installments' => $freeInstallments,
  1102.             'max_installments' => $parcelInfo->maxInstallments,
  1103.             'interest_rate' => $paymentConfig->installmentInterest
  1104.         ]);
  1106.         $parcelInfo->installmentsOptions = $installmentsOptions;
  1108.         return $parcelInfo;
  1109.     }
  1111.     public function courseByProductTotal($productId){
  1113.         $courseRepository = $this->em->getRepository(Course::class);
  1114.         $courseTotal = $courseRepository->getPublishedCourseNumberByProduct(
  1115.             $productId
  1116.         );
  1118.         return $courseTotal;
  1119.     }
  1121.     public function userHasProduct(Product $product, ?bool $ignoreStatus = false){
  1123.         $hashResult = md5(
  1124.             (
  1125.                 $this->getUser() ? 
  1126.                 $this->getUser()->getId() : 
  1127.                 null
  1128.             ) . $product->getId() . (
  1129.                 $ignoreStatus ?
  1130.                 ProductOfferEnum::YES :
  1131.                 ProductOfferEnum::NO
  1132.             )
  1133.         );
  1135.         if(isset($this->results["userHasProduct_{$hashResult}"])){
  1136.             return $this->results["userHasProduct_{$hashResult}"];
  1137.         }
  1139.         if(!$this->getUser()){
  1140.             $this->results["userHasProduct_{$hashResult}"] = false;
  1141.             return $this->results["userHasProduct_{$hashResult}"];
  1142.         }
  1144.         $productRepository = $this->em->getRepository(Product::class);
  1145.         $dataProduct = $productRepository->userHasProduct(
  1146.             $this->getUser(),
  1147.             $product,
  1148.             false,
  1149.             $ignoreStatus
  1150.         );
  1152.         $this->results["userHasProduct_{$hashResult}"] = ($dataProduct ? true : false);
  1154.         return $this->results["userHasProduct_{$hashResult}"];
  1155.     }
  1157.     public function hasInCart(array $productOffers)
  1158.     {
  1159.         $has = true;
  1161.         foreach ($productOffers as $key => $productOffer) {
  1162.             if(!$this->productIsInCart($productOffer->getProduct()->getId())){
  1163.                 $has = false;
  1164.             }
  1165.         }
  1167.         return $has;
  1168.     }
  1170.     public function getFirstCourseIdFromProduct(Product $product)
  1171.     {
  1172.         $courses = $product->getCourse();
  1174.         foreach ($courses as $key => $course) {
  1175.             return $course->getId();
  1176.         }
  1178.         return;
  1179.     }
  1181.     public function encodeHex($value)
  1182.     {
  1183.         $stringUtil = $this->generalService->getUtil('StringUtil');
  1184.         $hash = $stringUtil->encodeHex($value, false, false);
  1186.         return $hash;
  1187.     }
  1189.     public function getDefaultRecaptcha(){
  1190.         return $this->getConfiguration()->getDefaultRecaptcha();
  1191.     }
  1193.     public function getFields()
  1194.     {
  1195.         $fields = [];
  1196.         if($this->getConfiguration()->checkModuleIsAbleOnPlan('customFormModule')){
  1197.             $fields = $this->em->getRepository(UserCustomField::class)->findBy([
  1198.                 "deleted" => UserCustomFieldEnum::ITEM_NO_DELETED,
  1199.                 "status" => UserCustomFieldEnum::PUBLISHED,
  1200.                 "showInRegister" => UserCustomFieldEnum::YES,
  1201.             ],
  1202.             [ "order" => "ASC" ]);
  1204.             foreach ($fields as $key => $field) {
  1205.                 
  1206.                 $field->optionsObj = null;
  1207.                 
  1208.                 $options = $field->getOptions();
  1209.                 if(!empty($options)){
  1210.                     $field->optionsObj = json_decode($options);
  1211.                 }
  1213.                 $fields[$key] = $field;
  1214.             }
  1215.         }
  1217.         return $fields;
  1218.     }
  1220.     public function clearSocialUrl($slug, $url)
  1221.     {
  1222.         $formats = [
  1224.             // WHATSAPP
  1225.             'whatsapp'  => 'https://api.whatsapp.com/send/?phone=%s',
  1227.             // LINKEDIN
  1228.             'linkedin'  => 'https://linkedin.com/%s',
  1230.             // YOUTUBE
  1231.             'youtube'   => 'https://www.youtube.com/%s',
  1233.             // PINTEREST
  1234.             'pinterest' => 'https://br.pinterest.com/%s',
  1236.             // INSTAGRAM
  1237.             'instagram' => 'https://www.instagram.com/%s/?hl=pt-br',
  1239.             // SNAPCHAT
  1240.             'snapchat'  => 'https://www.snapchat.com/add/%s',
  1242.             // FACEBOOK
  1243.             'facebook'  => 'https://www.facebook.com/%s',
  1245.             // TWITTER
  1246.             'twitter'   => 'https://twitter.com/%s',
  1248.             // SPOTIFY
  1249.             'spotify'   => 'https://open.spotify.com/show/%s',
  1251.             // TIKTOK
  1252.             'tiktok'   => 'https://tiktok.com/%s',
  1253.         ];
  1256.         // WHATSAPP
  1257.         if ($slug == 'whatsapp')
  1258.         {
  1259.             $url = preg_replace("/[^0-9]/", "", $url);
  1260.         }
  1262.         // NÃO whatsapp
  1263.         else
  1264.         {
  1265.             $url = preg_replace('/^(.*)\?(.*)$/', '$1', $url);
  1267.             $url = trim($url, '/');
  1269.             // LINKEDIN
  1270.             if ($slug == 'linkedin')
  1271.             {
  1272.                 $url = preg_replace('/^(.*?)(((company|in)\/)?[^\/]*)$/', '$2', $url);
  1273.             }
  1275.             // NÃO linkedin
  1276.             else
  1277.             {
  1278.                 $url = preg_replace('/^(.*?)([^\/]*)$/', '$2', $url);
  1279.             }
  1280.         }
  1282.         $url = sprintf($formats[$slug], $url);
  1284.         return $url;
  1285.     }
  1287.     public function checkSection(string $sectionName)
  1288.     {
  1289.         $sectionConfigHome = json_decode(
  1290.             $this->getConfiguration()->get('section_config_home')
  1291.         );
  1293.         if(isset($sectionConfigHome->{$sectionName})){
  1294.             if(isset($sectionConfigHome->{$sectionName}->active)){
  1295.                 return $sectionConfigHome->{$sectionName}->active == ClientEnum::YES;
  1296.             }
  1297.         }
  1299.         return false;
  1300.     }
  1302.     public function paintStars($score, $halfStars = true)
  1303.     {
  1304.         $score = abs($score);
  1306.         $frac = array_replace([false, false], explode('.', $score));
  1308.         $half = [];
  1310.         if ($halfStars && in_array($frac[1], range(5, 9)))
  1311.         {
  1312.             $half = [$frac[0] => 'half'];
  1313.         }
  1315.         $base = array_fill(0, 5, 'off');
  1317.         $full = array_fill(0, floor($score), 'on');
  1319.         $paint = array_replace($base, $full, $half);
  1321.         return $paint;
  1322.     }
  1324.     public function getCategoryOffers(){
  1325.         $categoryRepository = $this->em->getRepository(Category::class);
  1326.         $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  1328.         $productCategories = $categoryRepository->getCategories();
  1330.         $categoryOffers = [];
  1331.         foreach ($productCategories as $key => $category) {
  1333.             $category = (object)$category;
  1335.             $category->productOffers = $productOfferRepository->getPublicProductOffers([
  1336.                 "category" => $category->getId(),
  1337.                 "limit" => 6
  1338.             ]);
  1340.             $categoryOffers[$key] = $category;
  1341.         }
  1343.         return $categoryOffers;
  1344.     }
  1346.     public function HEXtoRGB($hex)
  1347.     {
  1348.         return sscanf($hex, "#%02x%02x%02x");
  1349.     }
  1351.     public function RGBtoHSL($r, $g, $b)
  1352.     {
  1353.         $oldR = $r;
  1354.         $oldG = $g;
  1355.         $oldB = $b;
  1357.         $r /= 255;
  1358.         $g /= 255;
  1359.         $b /= 255;
  1361.         $max = max($r, $g, $b);
  1362.         $min = min($r, $g, $b);
  1364.         $h; $s;
  1365.         $l = ($max + $min) / 2;
  1366.         $d = $max - $min;
  1368.             if ($d == 0){
  1370.                 $h = $s = 0; // achromatic
  1372.             } else {
  1374.                 $s = $d / (1 - abs(2 * $l - 1));
  1376.                 switch($max){
  1378.                     case $r:
  1379.                         $h = 60 * fmod((($g - $b) / $d), 6);
  1380.                         {
  1381.                             if ($b > $g)
  1382.                             $h += 360;
  1383.                         }
  1384.                         break;
  1386.                     case $g:
  1387.                         $h = 60 * (($b - $r) / $d + 2);
  1388.                         break;
  1390.                     case $b: 
  1391.                         $h = 60 * (($r - $g) / $d + 4);
  1392.                         break;
  1393.                 }                               
  1394.         }
  1396.         return [round($h, 2), round($s, 2), round($l, 2)];
  1397.     }
  1399.     public function HEXtoHSL($hex)
  1400.     {
  1401.         list($r, $g, $b) = $this->HEXtoRGB($hex);
  1403.         return $this->RGBtoHSL($r, $g, $b);
  1404.     }
  1406.     public function setValue(string $key, $value = null)
  1407.     {
  1408.         $this->arrValue[$key] = $value;
  1410.         return;
  1411.     }
  1413.     public function getValue(string $key)
  1414.     {
  1415.         return (isset($this->arrValue[$key]) ? $this->arrValue[$key] : null);
  1416.     }
  1418.     public function pageSectionFormat(int $formatType)
  1419.     {
  1420.         $formats = [
  1421.             PageSectionEnum::BOX_DEFAULT => "default",
  1422.             PageSectionEnum::BOX_EXPAND => "expand",
  1423.             PageSectionEnum::BOX_STAND => "stand",
  1424.             PageSectionEnum::BOX_ROUND => "round",
  1425.         ];
  1427.         return (!empty($formats[$formatType]) ? $formats[$formatType] : "default");
  1428.     }
  1430.     public function pageSectionPosition(int $position)
  1431.     {
  1432.         $positions = [
  1433.             PageSectionEnum::LEFT => "left",
  1434.             PageSectionEnum::CENTER => "center",
  1435.             PageSectionEnum::RIGHT => "right",
  1436.         ];
  1438.         return (!empty($positions[$position]) ? $positions[$position] : "center");
  1439.     }
  1441.     public function pageSectionTemplateItem(PageSection $pageSection)
  1442.     {
  1443.         $typeItem = $pageSection->getTypeItem();
  1444.         $type = $pageSection->getTypeItem();
  1446.         $productType = [
  1447.             PageSectionEnum::ALL_PRODUCT,
  1448.             PageSectionEnum::PRODUCT_SPOTLIGHT,
  1449.             PageSectionEnum::PRODUCT_SUGGESTION,
  1450.             PageSectionEnum::PRODUCT_COURSE,
  1451.             PageSectionEnum::PRODUCT_SUBSCRIPTION,
  1452.             PageSectionEnum::PRODUCT_COMBO,
  1453.             PageSectionEnum::PRODUCT_LIVE,
  1454.             PageSectionEnum::PRODUCT_BY_CATEGORY,
  1455.             PageSectionEnum::PRODUCT_WISHLIST,
  1456.         ];
  1458.         $slug_format = [
  1459.             'default' => '-default',
  1460.             // 'expand'  => '-spotlight',
  1461.             'expand'  => '-expand',
  1462.             'stand'   => '-stand',
  1463.             'round'   => '-round',
  1464.         ];
  1466.         $slug = $slug_format[$this->pageSectionFormat($pageSection->getType())];
  1468.         $template = null;
  1470.         if(in_array($typeItem, $productType)){
  1471.             $template = "website/product/product-item-box{$slug}.html.twig";
  1472.         }else if($typeItem == PageSectionEnum::COURSE_STARTED){
  1473.             $template = "website/course/course-item-box{$slug}-home.html.twig";
  1474.         }
  1476.         return $template;
  1477.     }
  1479.     public function pageSectionItems(PageSection $pageSection)
  1480.     {
  1481.         $typeItem = $pageSection->getTypeItem();
  1482.         $allItem = $pageSection->getAllItem() == PageSectionEnum::YES;
  1483.         $item = json_decode($pageSection->getItem());
  1484.         $orderItem = $pageSection->getOrderItem();
  1485.         $limit = $pageSection->getNumberOfLine() * $pageSection->getNumberPerLine();
  1487.         $items = [];
  1489.         $productType = [
  1490.             PageSectionEnum::ALL_PRODUCT,
  1491.             PageSectionEnum::PRODUCT_SPOTLIGHT,
  1492.             PageSectionEnum::PRODUCT_SUGGESTION,
  1493.             PageSectionEnum::PRODUCT_COURSE,
  1494.             PageSectionEnum::PRODUCT_SUBSCRIPTION,
  1495.             PageSectionEnum::PRODUCT_COMBO,
  1496.             PageSectionEnum::PRODUCT_LIVE,
  1497.             PageSectionEnum::PRODUCT_BY_CATEGORY,
  1498.             PageSectionEnum::PRODUCT_WISHLIST,
  1499.         ];
  1501.         //CATEGORY,
  1502.         //TEACHER,
  1503.         //FAQ,
  1504.         //TESTIMONIAL
  1506.         if(in_array($typeItem, $productType)){
  1508.             if($typeItem == PageSectionEnum::PRODUCT_WISHLIST && !$this->user){
  1509.                 return [];
  1510.             }
  1512.             $productIds = (
  1513.                 !$allItem && !empty($item) && is_array($item) ? 
  1514.                 $item : 
  1515.                 null
  1516.             );
  1518.             $productRepository = $this->em->getRepository(Product::class);
  1519.             if(empty($productIds) && $typeItem == PageSectionEnum::PRODUCT_SUGGESTION){
  1520.                 $productIds = $productRepository->getProductsInCache();
  1521.             }
  1523.             $typeOriginal = [
  1524.                 PageSectionEnum::PRODUCT_COURSE => ProductEnum::COURSE,
  1525.                 PageSectionEnum::PRODUCT_SUBSCRIPTION => ProductEnum::SUBSCRIPTION,
  1526.                 PageSectionEnum::PRODUCT_COMBO => ProductEnum::COMBO,
  1527.                 PageSectionEnum::PRODUCT_LIVE => ProductEnum::LIVE,
  1528.             ];
  1530.             $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  1531.             $items = $productOfferRepository->getPublicProductOffersNew([
  1532.                 "type" => (
  1533.                     isset($typeOriginal[$typeItem]) ? 
  1534.                     $typeOriginal[$typeItem] : 
  1535.                     null
  1536.                 ),
  1537.                 "category" => (
  1538.                     $typeItem == PageSectionEnum::PRODUCT_BY_CATEGORY && 
  1539.                     $pageSection->getCategory() ? 
  1540.                     $pageSection->getCategory()->getId() : 
  1541.                     null
  1542.                 ),
  1543.                 "limit" => $limit,
  1544.                 "spotlight" => (
  1545.                     $typeItem == PageSectionEnum::PRODUCT_SPOTLIGHT ? 
  1546.                     PageSectionEnum::YES : 
  1547.                     PageSectionEnum::NO
  1548.                 ),
  1549.                 "wishlist" => (
  1550.                     $typeItem == PageSectionEnum::PRODUCT_WISHLIST ? 
  1551.                     PageSectionEnum::YES : 
  1552.                     PageSectionEnum::NO
  1553.                 ),
  1554.                 "order" => $pageSection->getOrderItem(),
  1555.                 "productIds" => $productIds,
  1556.             ]);
  1558.             $user = $this->getUser();
  1559.             if($user && $pageSection->getShowEnrollment() == PageSectionEnum::NO){
  1560.                 $aux = [];
  1561.                 foreach ($items as $key => $offer) {
  1562.                     if(!$productRepository->userHasProduct($user, $offer->getProduct())){
  1563.                         $aux[] = $offer;
  1564.                     }
  1565.                 }
  1567.                 $items =  $aux;
  1568.             }
  1569.         }else if($typeItem == PageSectionEnum::COURSE_STARTED && $this->getUser()){
  1570.             $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  1571.             $enrollments = $enrollmentRepository->getResumeEnrollment(
  1572.                 $this->getUser()->getId(),
  1573.                 [ EnrollmentEnum::SITUATION_STARTED ],
  1574.                 null,
  1575.                 null,
  1576.                 null,
  1577.                 null,
  1578.                 $limit
  1579.             );
  1581.             foreach ($enrollments as $key => $enrollment) {
  1582.                 $items[] = $enrollment->getCourse();
  1583.             }
  1584.         }
  1586.         return $items;
  1587.     }
  1589.     public function pageSectionLinkAll(PageSection $pageSection)
  1590.     {
  1591.         $typeItem = $pageSection->getTypeItem();
  1592.         $category = $pageSection->getCategory();
  1594.         $categoryLink = "/products";
  1595.         if($typeItem == PageSectionEnum::PRODUCT_BY_CATEGORY && $category){
  1596.             $categoryLink = "/products/{$category->getSlug()}";
  1597.         }
  1599.         $links = [
  1600.             PageSectionEnum::ALL_PRODUCT          => '/products',
  1601.             PageSectionEnum::PRODUCT_SPOTLIGHT    => '/products',
  1602.             PageSectionEnum::PRODUCT_SUGGESTION   => '/products',
  1603.             PageSectionEnum::PRODUCT_COURSE       => '/courses',
  1604.             PageSectionEnum::PRODUCT_SUBSCRIPTION => '/plans',
  1605.             PageSectionEnum::PRODUCT_COMBO        => '/combos',
  1606.             PageSectionEnum::PRODUCT_LIVE         => '/lives',
  1607.             PageSectionEnum::PRODUCT_BY_CATEGORY  => $categoryLink,
  1608.             PageSectionEnum::PRODUCT_WISHLIST     => '/wishlist',
  1609.             PageSectionEnum::COURSE_STARTED       => '/resume',
  1610.         ];
  1612.         return isset($links[$typeItem]) ? $links[$typeItem] : "/";
  1613.     }
  1615.     public function isPageSection($pageSection) {
  1616.         return  $pageSection instanceof PageSection;
  1617.     }
  1619.     public function pageSectionShowAll(PageSection $pageSection)
  1620.     {
  1621.         $typeItem = $pageSection->getTypeItem();
  1622.         $allItem = $pageSection->getAllItem() == PageSectionEnum::YES;
  1623.         $item = json_decode($pageSection->getItem());
  1624.         $limit = $pageSection->getNumberOfLine() * $pageSection->getNumberPerLine();
  1626.         $items = [];
  1628.         $productType = [
  1629.             PageSectionEnum::ALL_PRODUCT,
  1630.             PageSectionEnum::PRODUCT_SPOTLIGHT,
  1631.             PageSectionEnum::PRODUCT_SUGGESTION,
  1632.             PageSectionEnum::PRODUCT_COURSE,
  1633.             PageSectionEnum::PRODUCT_SUBSCRIPTION,
  1634.             PageSectionEnum::PRODUCT_COMBO,
  1635.             PageSectionEnum::PRODUCT_LIVE,
  1636.             PageSectionEnum::PRODUCT_BY_CATEGORY,
  1637.             PageSectionEnum::PRODUCT_WISHLIST,
  1638.         ];
  1640.         //CATEGORY,
  1641.         //TEACHER,
  1642.         //FAQ,
  1643.         //TESTIMONIAL
  1645.         if(in_array($typeItem, $productType)){
  1647.             if($typeItem == PageSectionEnum::PRODUCT_WISHLIST && !$this->user){
  1648.                 return [];
  1649.             }
  1651.             $productIds = (
  1652.                 !$allItem && !empty($item) && is_array($item) ? 
  1653.                 $item : 
  1654.                 null
  1655.             );
  1657.             $productRepository = $this->em->getRepository(Product::class);
  1658.             if(empty($productIds) && $typeItem == PageSectionEnum::PRODUCT_SUGGESTION){
  1659.                 $productIds = $productRepository->getProductsInCache();
  1660.             }
  1662.             $typeOriginal = [
  1663.                 PageSectionEnum::PRODUCT_COURSE => ProductEnum::COURSE,
  1664.                 PageSectionEnum::PRODUCT_SUBSCRIPTION => ProductEnum::SUBSCRIPTION,
  1665.                 PageSectionEnum::PRODUCT_COMBO => ProductEnum::COMBO,
  1666.                 PageSectionEnum::PRODUCT_LIVE => ProductEnum::LIVE,
  1667.             ];
  1669.             $productOfferRepository = $this->em->getRepository(ProductOffer::class);
  1670.             $total = $productOfferRepository->countPublicProductOffersNew([
  1671.                 "type" => (
  1672.                     isset($typeOriginal[$typeItem]) ? 
  1673.                     $typeOriginal[$typeItem] : 
  1674.                     null
  1675.                 ),
  1676.                 "category" => (
  1677.                     $typeItem == PageSectionEnum::PRODUCT_BY_CATEGORY && 
  1678.                     $pageSection->getCategory() ? 
  1679.                     $pageSection->getCategory()->getId() : 
  1680.                     null
  1681.                 ),
  1682.                 "spotlight" => (
  1683.                     $typeItem == PageSectionEnum::PRODUCT_SPOTLIGHT ? 
  1684.                     PageSectionEnum::YES : 
  1685.                     PageSectionEnum::NO
  1686.                 ),
  1687.                 "wishlist" => (
  1688.                     $typeItem == PageSectionEnum::PRODUCT_WISHLIST ? 
  1689.                     PageSectionEnum::YES : 
  1690.                     PageSectionEnum::NO
  1691.                 ),
  1692.                 "productIds" => $productIds,
  1693.             ]);
  1695.             return ($total > $limit);
  1697.         }else if($typeItem == PageSectionEnum::COURSE_STARTED && $this->getUser()){
  1698.             return true;
  1699.         }
  1701.         return false;
  1702.     }
  1704.     public function getPlanCycleString(int $cycleOption){
  1705.         return $this->em->getRepository(UserSubscription::class)->getPlanCycleString(
  1706.             $cycleOption
  1707.         );
  1708.     }
  1710.     public function getPlanCycleStringProductDetail(int $cycleOption){
  1711.         return $this->em->getRepository(UserSubscription::class)->getPlanCycleStringProductDetail(
  1712.             $cycleOption
  1713.         );
  1714.     }
  1716.     public function getDocumentFormat(int $document){
  1718.         $cnpj_cpf = preg_replace("/\D/", '', $document);
  1719.   
  1720.         if (strlen($cnpj_cpf) === 11) {
  1721.           return preg_replace("/(\d{3})(\d{3})(\d{3})(\d{2})/", "\$1.\$2.\$3-\$4", $cnpj_cpf);
  1722.         } 
  1723.         
  1724.         return preg_replace("/(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})/", "\$1.\$2.\$3/\$4-\$5", $cnpj_cpf);
  1725.     }
  1726.   
  1727.     public function getUserSubscriptionError($errorMessage){
  1728.         $errorMessage = explode("MESSAGE: ", $errorMessage);
  1729.         return $errorMessage[1];
  1730.     }
  1732.     public function getVimeoFormatIframe(string $link){
  1734.         $url = null;
  1736.         if(strpos($link, '/manage/videos')){
  1737.             $url = str_replace('/manage/videos', '', $link);
  1738.         }
  1739.         
  1740.         return $url;
  1741.     }
  1743.     public function isValidCard($dateExpire)
  1744.     {
  1745.         $y = (int)date('y');
  1746.         $m = (int)date('m');
  1748.         $expire = explode('/', $dateExpire);
  1750.         $ySave = (int)$expire[1];
  1751.         $mSave = (int)$expire[0];
  1753.         if($y > $ySave || ($y == $ySave && $m >= $mSave)){
  1754.             return false;
  1755.         }
  1757.         return true;
  1758.     }
  1760.     public function stringOrigin($origin)
  1761.     {
  1762.         $string = '';
  1763.         switch ($origin) {
  1764.             case EnrollmentEnum::ORIGIN_FREE:
  1765.                 $string = $this->getConfiguration()->getLanguage(
  1766.                     'free', 'enrollments'
  1767.                 );
  1768.             break;
  1769.             case EnrollmentEnum::ORIGIN_SALE:
  1770.                 $string = $this->getConfiguration()->getLanguage(
  1771.                     'sale', 'enrollments'
  1772.                 );
  1773.             break;
  1774.             case EnrollmentEnum::ORIGIN_SUBSCRIPTION:
  1775.                 $string = $this->getConfiguration()->getLanguage(
  1776.                     'subscription', 'enrollments'
  1777.                 );
  1778.             break;
  1779.             case EnrollmentEnum::ORIGIN_GROUP:
  1780.                 $string = $this->getConfiguration()->getLanguage(
  1781.                     'group', 'enrollments'
  1782.                 );
  1783.             break;
  1784.             case EnrollmentEnum::ORIGIN_COUPOM:
  1785.                 $string = $this->getConfiguration()->getLanguage(
  1786.                     'coupom', 'enrollments'
  1787.                 );
  1788.             break;
  1789.             case EnrollmentEnum::ORIGIN_API:
  1790.                 $string = 'Api';
  1791.             break;
  1792.             case EnrollmentEnum::ORIGIN_CHARGE:
  1793.                 $string = $this->getConfiguration()->getLanguage(
  1794.                     'charge', 'enrollments'
  1795.                 );
  1796.             break;
  1797.         }
  1799.         return $string;
  1800.     }
  1802.     public function stringStatus(Enrollment $enrollment)
  1803.     {
  1804.         $string = '';
  1805.         switch ($enrollment->getStatus()) {
  1806.             case EnrollmentEnum::STATUS_ACTIVE:
  1807.                 if(strtotime($enrollment->getDatePeriod('Y-m-d')) < strtotime(date('Y-m-d'))){
  1808.                     $string = $this->getConfiguration()->getLanguage(
  1809.                         'expired', 'enrollments'
  1810.                     ); 
  1811.                 }else{
  1812.                     $string = $this->getConfiguration()->getLanguage(
  1813.                         'active', 'enrollments'
  1814.                     ); 
  1815.                 }
  1816.             break;
  1817.             case EnrollmentEnum::STATUS_SUSPENDED:
  1818.                 $string = $this->getConfiguration()->getLanguage(
  1819.                     'suspended', 'enrollments'
  1820.                 ); 
  1821.             break;
  1822.             case EnrollmentEnum::STATUS_CANCELED:
  1823.                 $string = $this->getConfiguration()->getLanguage(
  1824.                     'canceled', 'enrollments'
  1825.                 );
  1826.             break;
  1827.         }
  1829.         return $string;
  1830.     }
  1831. }