src/Twig/Extension/ProductExtension.php line 489

Open in your IDE?
  1. <?php
  2. declare(strict_types=1);
  3. namespace App\Twig\Extension;
  5. use App\Model\DefaultProduct;
  6. use App\Service\CartService;
  7. use App\Service\ProductAttributeData;
  8. use App\Service\ProductAttributeMapper;
  9. use App\Service\ProductAttributeRenderer;
  10. use App\Service\ShopService;
  11. use Pimcore\Log\Simple;
  12. use Twig\Extension\AbstractExtension;
  13. use Twig\TwigFunction;
  14. use Pimcore\Translation\Translator;
  15. use App\Model\Customer;
  18. /**
  19.  * Description of ProductExtension
  20.  *
  21.  * @author PcCom
  22.  */
  23. class ProductExtension extends AbstractExtension
  24. {
  26.     /**
  27.      * @var Translator
  28.      */
  29.     protected $translator;
  31.     /**
  32.      * @var CartService
  33.      */
  34.     protected $cartService;
  35.     /**
  36.      * @var ShopService
  37.      */
  38.     private $shopService;
  40.     private ProductAttributeMapper $mapper;
  41.     private ProductAttributeRenderer $renderer;
  43.     /**
  44.      * GeneralFilterExtension constructor.
  45.      *
  46.      * @param Translator $translator
  47.      * @param CartService $cartService
  48.      * @param ShopService $shopService
  49.      */
  50.     public function __construct(
  51.         Translator $translator,
  52.         CartService $cartService,
  53.         ShopService $shopService,
  54.         ProductAttributeMapper $mapper,
  55.         ProductAttributeRenderer $renderer
  56.     )
  57.     {
  58.         $this->translator = $translator;
  59.         $this->cartService = $cartService;
  60.         $this->shopService = $shopService;
  61.         $this->mapper = $mapper;
  62.         $this->renderer = $renderer;
  63.     }
  65.     /**
  66.      * @return TwigFunction[]
  67.      */
  68.     public function getFunctions()
  69.     {
  70.         return [
  71.             new TwigFunction('app_product_generate_link', [$this, 'generateLink']),
  72.             new TwigFunction('app_product_generate_data', [$this, 'generateData']),
  73.             new TwigFunction('app_product_attributes_rows', [$this, 'getAttributesRows']),
  74.             new TwigFunction('app_product_types_rows', [$this, 'getTypesRows']),
  75.             new TwigFunction('app_product_variants_attributes', [$this, 'getVariantsAttributes']),
  76.             new TwigFunction('app_product_variant_attribute_value', [$this, 'getVariantsAttributeValue']),
  77.             new TwigFunction('app_product_variant_prices', [$this, 'getVariantsPrices']),
  78.             new TwigFunction('app_product_related_products', [$this, 'getRelatedProducts']),
  79.             new TwigFunction('app_product_default_price',[$this,'getDefaultPrice']),
  80.             new TwigFunction('app_product_default_price_with_discount',[$this,'getDefaultPriceWithDiscount']),
  81.             new TwigFunction('app_product_price_with_discount',[$this,'getPriceWithDiscount']),
  82.             new TwigFunction('app_product_haveError',[$this,'getHaveError']),
  83.         ];
  84.     }
  86.     public function generateData($product)
  87.     {
  88.         $data = new ProductAttributeData($this->mapper);
  89.         $data->initialize($product);
  90.         return $data;
  91.     }
  93.     public function getHaveError($product):bool
  94.     {
  95.         $haveError = false;
  97.         if (!$haveError){
  98.             $haveError = $this->checkVariantsWithoutPrice($product);
  99.         }
  101.         return $haveError;
  102.     }
  104.     protected function checkVariantsWithoutPrice($product):bool
  105.     {
  106.         $haveError = false;
  107.         $i = 0;
  108.         $data = $this->generateData($product);
  109.         $variants = $data->variants;
  111.         foreach ($variants as $variant){
  112.             if ($variant->getPrice()){
  113.                 $i++;
  114.             }else{
  115.                 Simple::log("products-with-errors", "product ID: {$variant->getId()} Error type: missing field on price");
  116.             }
  117.         }
  119.         //ERROR PRICE FIELD IS MISSING
  120.         if ($i != count($variants)){
  121.             $haveError = true;
  122.         }
  123.         return $haveError;
  124.     }
  126.     public function getAttributesRows($product, $data) : ?array
  127.     {
  128.         return $this->renderer->generateRows(get_object_vars($data), $product);
  129.     }
  131.     public function getVariantsAttributes(ProductAttributeData $data)
  132.     {
  133.         return $data->getVariantAttributes();
  134.     }
  136.     public function getTypesRows($product, $data): array
  137.     {
  138.         $typeArray = [];
  139.         $typeArray["Activador"] = $this->getActivador($product);
  140.         $typeArray["Base"] = $this->getBaseRow($product);
  141.         $typeArray["Catalizador"] = $this->getCatalizadorRow($product, $data);
  142.         $typeArray["Converter"] = $this->getConverterRow($product);
  143.         $typeArray["Disolvente"] = $this->getDisvolventeRow($product);
  144.         $typeArray["Kit"] = $this->getKitRow($product);
  145.         $typeArray["Cleaner"] = $this->getCleanerRow($product);
  146.         $typeArray["Reducer"] = $this->getReducerRow($product);
  147.         $typeArray["Complemento"] = $this->getComplement($product);
  149.         return array_filter($typeArray);
  150.     }
  152.     protected function getActivador($product): string
  153.     {
  154.         $rowString = "";
  155.         $activadors = $product->getActivador();
  156.         if (count($activadors) > 0) {
  157.             $rowString .= "<tr><td class=\"attributekey\">" . $this->translator->trans("Activador") . ":</td> ";
  158.             $rowString .= "<td class=\"attributevalue\">";
  160.             $resultString = "";
  161.             foreach ($activadors as $activador) {
  162.                 $relProduct = $activador->getElement();
  163.                 $resultString .= "<br/>";
  164.                 if (!empty($relProduct->getBsncode())) {
  165.                     $resultString .= $relProduct->getBsncode() . " - ";
  166.                 }
  167.                 $resultString .= $relProduct->getName();
  168.             }
  169.             $rowString .= trim($resultString, "<br/>");
  171.             $rowString .= "</td></tr>";
  172.         }
  173.         return $rowString;
  174.     }
  176.     protected function getComplement($product){
  177.         $rowString = "";
  178.         $activadors = $product->getComplement();
  179.         if (count($activadors) > 0) {
  180.             $rowString .= "<tr><td class=\"attributekey\">" . $this->translator->trans("Complemento") . ":</td> ";
  181.             $rowString .= "<td class=\"attributevalue\">";
  183.             $resultString = "";
  184.             foreach ($activadors as $activador) {
  185.                 $relProduct = $activador->getElement();
  186.                 $resultString .= "<br/>";
  187.                 if (!empty($relProduct->getBsncode())) {
  188.                     $resultString .= $relProduct->getBsncode() . " - ";
  189.                 }
  190.                 $resultString .= $relProduct->getName();
  191.             }
  192.             $rowString .= trim($resultString, "<br/>");
  194.             $rowString .= "</td></tr>";
  195.         }
  196.         return $rowString;
  197.     }
  199.     protected function getBaseRow($product): string
  200.     {
  201.         $rowString = "";
  202.         $bases = $product->getBase();
  203.         if (count($bases) > 0) {
  204.             $rowString .= "<tr><td class=\"attributekey\">" . $this->translator->trans("Base") . ":</td> ";
  205.             $rowString .= "<td class=\"attributevalue\">";
  207.             $resultString = "";
  208.             foreach ($bases as $base) {
  209.                 $relProduct = $base->getElement();
  210.                 $resultString .= "<br/>";
  211.                 if (!empty($relProduct->getBsncode())) {
  212.                     $resultString .= $relProduct->getBsncode() . " - ";
  213.                 }
  214.                 $resultString .= $relProduct->getName();
  215.             }
  216.             $rowString .= trim($resultString, "<br/>");
  218.             $rowString .= "</td></tr>";
  219.         }
  220.         return $rowString;
  221.     }
  223.     protected function getCatalizadorRow($product, $data): string
  224.     {
  225.         $rowString = "";
  226.         if (!empty($data->valuesArray["catalizador"])) {
  227.             $rowString .= "<tr><td class=\"attributekey\">" . $this->translator->trans($data->attributes["catalizador"]["title"]) . ":</td> ";
  228.             $rowString .= "<td class=\"attributevalue\">" . $this->translator->trans($data->valuesArray["catalizador"]) . "</td></tr>";
  229.         } else {
  230.             $catalizadors = $product->getCatalizador();
  231.             if (count($catalizadors) > 0) {
  232.                 $rowString .= "<tr><td class=\"attributekey\">" . $this->translator->trans("Catalizador") . ":</td> ";
  233.                 $rowString .= "<td class=\"attributevalue\">";
  235.                 $resultString = "";
  236.                 foreach ($catalizadors as $catalizador) {
  237.                     $relProduct = $catalizador->getElement();
  238.                     $resultString .= "<br/>";
  239.                     if (!empty($relProduct->getBsncode())) {
  240.                         $resultString .= $relProduct->getBsncode() . " - ";
  241.                     }
  242.                     $resultString .= $relProduct->getName();
  243.                 }
  244.                 $rowString .= trim($resultString, "<br/>");
  246.                 $rowString .= "</td></tr>";
  247.             }
  248.         }
  250.         return $rowString;
  251.     }
  253.     protected function getConverterRow($product): string
  254.     {
  255.         $rowString = "";
  256.         $converters = $product->getConverter();
  257.         if (count($converters) > 0) {
  258.             $rowString .= "<tr><td class=\"attributekey\">" . $this->translator->trans("Converter") . ":</td> ";
  259.             $rowString .= "<td class=\"attributevalue\">";
  261.             $resultString = "";
  262.             foreach ($converters as $converter) {
  263.                 $relProduct = $converter->getElement();
  264.                 $resultString .= "<br/>";
  265.                 if (!empty($relProduct->getBsncode())) {
  266.                     $resultString .= $relProduct->getBsncode() . " - ";
  267.                 }
  268.                 $resultString .= $relProduct->getName();
  269.             }
  270.             $rowString .= trim($resultString, "<br/>");
  272.             $rowString .= "</td></tr>";
  273.         }
  274.         return $rowString;
  275.     }
  277.     protected function getDisvolventeRow($product): string
  278.     {
  279.         $rowString = "";
  281.         $disolventes = $product->getDisolvente();
  282.         if (count($disolventes) > 0) {
  283.             $rowString .= "<tr><td class=\"attributekey\">";
  285.             if ($this->translator->getLocale() == 'es') {
  286.                 $rowString .= "Disolvente:";
  287.             } elseif ($this->translator->getLocale() == 'en') {
  288.                 $rowString .= "Solvent:";
  289.             } else {
  290.                 $rowString .= "Solvent:";
  291.             }
  293.             $rowString .= ":</td> ";
  294.             $rowString .= "<td class=\"attributevalue\">";
  296.             $resultString = "";
  297.             foreach ($disolventes as $disolvente) {
  298.                 $relProduct = $disolvente->getElement();
  299.                 $resultString .= "<br/>";
  300.                 if (!empty($relProduct->getBsncode())) {
  301.                     $resultString .= $relProduct->getBsncode() . " - ";
  302.                 }
  303.                 $resultString .= $relProduct->getName();
  304.             }
  305.             $rowString .= trim($resultString, "<br/>");
  307.             $rowString .= "</td></tr>";
  308.         }
  310.         return $rowString;
  311.     }
  314.     protected function getKitRow($product): string
  315.     {
  316.         $rowString = "";
  318.         $kits = $product->getKit();
  319.         if (count($kits) > 0) {
  320.             $rowString .= "<tr><td class=\"attributekey\">" . $this->translator->trans("Kit") . ":</td> ";
  321.             $rowString .= "<td class=\"attributevalue\">";
  323.             $resultString = "";
  324.             foreach ($kits as $kit) {
  325.                 $relProduct = $kit->getElement();
  326.                 $resultString .= "<br/>";
  327.                 if (!empty($relProduct->getBsncode())) {
  328.                     $resultString .= $relProduct->getBsncode() . " - ";
  329.                 }
  330.                 $resultString .= $relProduct->getName();
  331.             }
  332.             $rowString .= trim($resultString, "<br/>");
  334.             $rowString .= "</td></tr>";
  335.         }
  337.         return $rowString;
  338.     }
  340.     public function getCleanerRow($product): string
  341.     {
  342.         $rowString = "";
  344.         $cleaners = $product->getCleaner();
  345.         if (count($cleaners) > 0) {
  346.             $rowString .= "<tr><td class=\"attributekey\">" . $this->translator->trans("Cleaner") . ":</td> ";
  347.             $rowString .= "<td class=\"attributevalue\">";
  349.             $resultString = "";
  350.             foreach ($cleaners as $cleaner) {
  351.                 $relProduct = $cleaner->getElement();
  352.                 $resultString .= "<br/>";
  353.                 if (!empty($relProduct->getBsncode())) {
  354.                     $resultString .= $relProduct->getBsncode() . " - ";
  355.                 }
  356.                 $resultString .= $relProduct->getName();
  357.             }
  358.             $rowString .= trim($resultString, "<br/>");
  360.             $rowString .= "</td></tr>";
  361.         }
  363.         return $rowString;
  364.     }
  366.     protected function getReducerRow($product): string
  367.     {
  368.         $rowString = "";
  370.         $reducers = $product->getReducer();
  371.         if (count($reducers) > 0) {
  372.             $rowString .= "<tr><td class=\"attributekey\">" . $this->translator->trans("Reducer") . ":</td> ";
  373.             $rowString .= "<td class=\"attributevalue\">";
  375.             $resultString = "";
  376.             foreach ($reducers as $reducer) {
  377.                 $relProduct = $reducer->getElement();
  378.                 $resultString .= "<br/>";
  379.                 if (!empty($relProduct->getBsncode())) {
  380.                     $resultString .= $relProduct->getBsncode() . " - ";
  381.                 }
  382.                 $resultString .= $relProduct->getName();
  383.             }
  384.             $rowString .= trim($resultString, "<br/>");
  386.             $rowString .= "</td></tr>";
  387.         }
  389.         return $rowString;
  390.     }
  392.     public function getVariantsAttributeValue($variant, $field)
  393.     {
  394.         $data = new \stdClass();
  395.         $value = $variant->getAttributeValue($field);
  396.         $textAlign = "text-align:center;";
  398.         switch ($field["fieldtype"]) {
  399.             case "inputQuantityValue" :
  400.             case "quantityValue" :
  401.                 $textAlign = "text-align:center;";
  402.                 break;
  403.         }
  404.         switch ($field["name"]) {
  405.             case "color" :
  406.                 $colorObj = \Pimcore\Model\DataObject\Colores::getById($value);
  407.                 if ($colorObj) {
  408.                     if (method_exists($colorObj, "getName")) {
  409.                         $value = $colorObj->getName();
  410.                     }
  411.                     if (method_exists($colorObj, "getHex")) {
  412.                         $hexObj = $colorObj->getHex();
  413.                         if($hexObj != null){
  414.                             if (method_exists($hexObj, "getHex")) {
  415.                                 $hexValue = $hexObj->getHex();
  417.                                 $classStyle = "class=\"fa fa-square\" style=\"color:" . $hexValue . "\"";
  418.                                 if (empty($hexValue) || ($hexValue == "#ffffff")) {
  419.                                     $classStyle = "class=\"fa fa-square-o\"";
  420.                                 }
  421.                             }
  422.                         }
  423.                     }
  424.                 }
  425.                 break;
  426.         }
  427.         if (is_array($value)) {
  428.             $value = implode(" | ", $value);
  429.         }
  431.         $data->textAlign = $textAlign;
  432.         $data->value = $value;
  433.         return $data;
  434.     }
  436.     public function getVariantsPrices($variant, $iva)
  437.     {
  438.         $data = new \stdClass();
  440.         $precioReal = $variant->getPriceNumeric();
  441.         $precioIVAReal = 0;
  442.         $precioIVA = "";
  443.         $precioTotal = "";
  444.         if (!empty($precioReal)) {
  445.             $precioIVAReal = $variant->getPriceTax($iva);
  446.             $precioIVA = number_format($precioIVAReal, 2, ",", ".");
  448.             $precioTotal = number_format(((float) $precioReal) + ((float) $precioIVAReal), 2, ",", ".");
  449.             $precioReal = number_format($precioReal, 2, ",", ".");
  450.         }
  451.         $data->precioIVA = $precioIVA;
  452.         $data->precioTotal = $precioTotal;
  453.         $data->precioReal = $precioReal;
  454.         return $data;
  455.     }
  457.     public function getRelatedProducts($product)
  458.     {
  459.         $relatedProducts = [];
  461.         $attributes = $product->getAllAttributes($product);
  462.         $relatedProducts = array();
  463.         if (key_exists("relationproducts", $attributes)) {
  464.             $relationproducts = $product->getAttributeValue($attributes["relationproducts"]);
  465.             if (count($relationproducts) > 0) {
  466.                 foreach ($relationproducts as $relationproduct) {
  467.                     $relatedProducts[] = $relationproduct->getElement();
  468.                 }
  469.             }
  470.         }
  472.         if (method_exists($product, "getGeneralrelatedproducts")) {
  473.             $relationproducts = $product->getGeneralrelatedproducts();
  474.             if (count($relationproducts) > 0) {
  475.                 foreach ($relationproducts as $relationproduct) {
  476.                     $relatedProducts[] = $relationproduct->getElement();
  477.                 }
  478.             }
  479.         }
  481.         return $relatedProducts;
  482.     }
  484.     public function generateLink($product, array $params, array $extra): string
  485.     {
  486.         try {
  487.             /** @var DefaultProduct $linkProduct */
  488.             $linkProduct = $product->getLinkProduct();
  489.             $link = $linkProduct->getDetailUrl($params);
  491.             $authenticated = ($extra['authenticated']) ?? false;
  492.             $isProductlist = ($extra['isProductlist']) ?? false;
  493.             $isRelatedProduct = ($extra['isRelatedProduct']) ?? false;
  495.             $baseUrl = explode('?', $_SERVER['REQUEST_URI']);
  496.             $unique = "";
  497.             if (count($baseUrl) > 1) {
  498.                 $unique = "?" . $baseUrl[1];
  499.             }
  501.             if ($isProductlist && !$isRelatedProduct) {
  502.                 $urlArray = explode("/", $link);
  503.                 $link = $baseUrl[0] . "/" . $urlArray[count($urlArray) - 1];
  504.                 if ($authenticated) {
  505.                     $link = $link . $unique;
  506.                 }
  507.             }
  508.         }catch (\Exception $exception){
  509.             $link = '';
  510.         }
  513.         return $link;
  514.     }
  516.     //Get lower price of the product variants
  517.     public function getDefaultPriceWithDiscount($product,$userIdSage)
  518.     {
  519.         $mountOfVariants = count($product->getAllActiveVariants());
  521.         //Does it have variants?
  522.         $haveVariants = $mountOfVariants;
  523.         $optimized = ($haveVariants > 35);
  525.         if($mountOfVariants){
  526.             // START LOWER PRICE WITH DISCOUNT V2
  527.             $prices =  $product->getVariantPriceAndIdList($optimized);
  528.             //replace this format 54,24 to 54.24
  529.             $prices = str_replace(',','.',$prices);
  530.             //convert string prices to float prices
  531.             $prices = array_map('floatval', $prices);
  533.             $min_value = min($prices);
  534.             $keys = array_keys($prices, $min_value);
  535.             //Calculate the discount but for one of the cheapest products found in its variants
  536.             $product = DefaultProduct::getById($keys[0]);
  537.             //END LOWER PRICE WITH DISCOUNT V2
  538.         }
  540.         return $this->shopService->getProductDiscount($product->getBsncode(), $userIdSage);
  541.     }
  543.     //Get lower price of the product variants
  544.     public function getPriceWithDiscount($product,$userIdSage): array
  545.     {
  546.         return $this->shopService->getProductDiscount($product->getBsncode(), $userIdSage);
  547.     }
  549.     public function getDefaultPrice($product)
  550.     {
  551.         $mountOfVariants = count($product->getAllActiveVariants());
  552.         $optimized = ($mountOfVariants > 35);
  553.         $prices = $product->getVariantPriceList($optimized);
  555.         if (empty($prices)) {
  556.             return 0;
  557.         }
  559.         $floatPrices = array_map(function($price) {
  560.             return floatval(str_replace(',', '.', $price));
  561.         }, $prices);
  563.         return min($floatPrices);
  564.     }
  567. }