src/Model/DefaultProduct.php line 819

Open in your IDE?
  1. <?php
  2. /**
  3.  * Pimcore
  4.  *
  5.  * This source file is available under two different licenses:
  6.  * - GNU General Public License version 3 (GPLv3)
  7.  * - Pimcore Enterprise License (PEL)
  8.  * Full copyright and license information is available in
  9.  * LICENSE.md which is distributed with this source code.
  10.  *
  11.  * @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  12.  * @license    http://www.pimcore.org/license     GPLv3 and PEL
  13.  */
  14. namespace App\Model;
  16. use App\Model\Product\TraitClasses\Checkoutable;
  17. use App\Tool\AdminStyle;
  18. use App\Tool\SizeSort;
  19. use Pimcore\Cache;
  20. use Pimcore\Model\DataObject\AbstractObject;
  21. use Pimcore\Model\DataObject\Folder;
  22. use Pimcore\Model\DataObject\Product;
  23. use App\Model\DefaultMarca;
  25. class DefaultProduct extends Product
  26. {
  28.     use Checkoutable;
  30.     private $internationalSizeOrden = array('XXS', 'XS', 'S', 'M', 'L', 'XL', 'XXL', '3XL', '4XL');
  32.     public function getElementAdminStyle()
  33.     {
  34.         if (!$this->o_elementAdminStyle) {
  35.             $this->o_elementAdminStyle = new AdminStyle($this);
  36.         }
  38.         return $this->o_elementAdminStyle;
  39.     }
  41.     public function save()
  42.     {
  43.         parent::save();
  45.         Cache::clearTag('object_' . $this->internalGetBaseProduct()->getId());
  46.     }
  48.     public function isActive($inProductList = false): bool
  49.     {
  50.         return $this->isPublished();
  51.     }
  53.     public function getOSDoIndexProduct(): bool
  54.     {
  55.         if ($this->getType() == 'object' && $this->getParent() instanceof Product) {
  56.             return false;
  57.         } else {
  58.             return true;
  59.         }
  60.     }
  62.     public function getOSParentId()
  63.     {
  64.         if ($this->getType() == 'variant' && $this->getParent()->getParent() instanceof Product) {
  65.             return $this->getParent()->getParent()->getId();
  66.         } elseif ($this->getParent() instanceof Product) {
  67.             return parent::getOSParentId();
  68.         } else {
  69.             return $this->getId();
  70.         }
  71.     }
  72.     /*
  73.      *
  74.      * Own functions for bsnbarcelona products
  75.      */
  77.     public function getMarcaObject()
  78.     {
  79.         if (method_exists($this, "getMarca")) {
  80.             $marcaId = $this->getMarca();
  81.             if ($marcaId > 0) {
  82.                 return DefaultMarca::getById($marcaId);
  83.             }
  84.         }
  85.         return null;
  86.     }
  88.     public function getAttributeRelationProductTypeArray()
  89.     {
  90.         $types = array();
  91.         $attributes = $this->getAllAttributes($this);
  92.         if (key_exists("relationproducts", $attributes)) {
  93.             $relationsproducts = $this->getAttributeValue($attributes["relationproducts"]);
  94.             if ($relationsproducts) {
  95.                 foreach ($relationsproducts as $item) {
  96.                     if (!(array_key_exists($item->getTipo(), $types))) {
  97.                         $types[$item->getTipo()] = array();
  98.                     }
  99.                 }
  100.             }
  101.         }
  102.         return $types;
  103.     }
  105.     public function getCatalizador()
  106.     {
  107.         $catalizadores = array();
  108.         $attributes = $this->getAllAttributes($this);
  109.         if (key_exists("relationproducts", $attributes)) {
  110.             $relationsproducts = $this->getAttributeValue($attributes["relationproducts"]);
  111.             if ($relationsproducts) {
  112.                 foreach ($relationsproducts as $item) {
  113.                     if ($item->getTipo() == "Catalizador") {
  114.                         $catalizadores[] = $item;
  115.                     }
  116.                 }
  117.             }
  118.         }
  119.         return $catalizadores;
  120.     }
  122.     public function getKit()
  123.     {
  124.         $kit = array();
  125.         $attributes = $this->getAllAttributes($this);
  126.         if (key_exists("relationproducts", $attributes)) {
  127.             $relationsproducts = $this->getAttributeValue($attributes["relationproducts"]);
  128.             if ($relationsproducts) {
  129.                 foreach ($relationsproducts as $item) {
  130.                     if ($item->getTipo() == "Kit") {
  131.                         $kit[] = $item;
  132.                     }
  133.                 }
  134.             }
  135.         }
  136.         return $kit;
  137.     }
  139.     public function getDisolvente()
  140.     {
  141.         $disolventes = array();
  142.         $attributes = $this->getAllAttributes($this);
  143.         if (key_exists("relationproducts", $attributes)) {
  144.             $relationsproducts = $this->getAttributeValue($attributes["relationproducts"]);
  145.             if ($relationsproducts) {
  146.                 foreach ($relationsproducts as $item) {
  147.                     if ($item->getTipo() == "Disolvente") {
  148.                         $disolventes[] = $item;
  149.                     }
  150.                 }
  151.             }
  152.         }
  153.         return $disolventes;
  154.     }
  156.     public function getCleaner()
  157.     {
  158.         $cleaners = array();
  159.         $attributes = $this->getAllAttributes($this);
  160.         if (key_exists("relationproducts", $attributes)) {
  161.             $relationsproducts = $this->getAttributeValue($attributes["relationproducts"]);
  162.             if ($relationsproducts) {
  163.                 foreach ($relationsproducts as $item) {
  164.                     if ($item->getTipo() == "Cleaner") {
  165.                         $cleaners[] = $item;
  166.                     }
  167.                 }
  168.             }
  169.         }
  170.         return $cleaners;
  171.     }
  173.     public function getReducer()
  174.     {
  175.         $reducers = array();
  176.         $attributes = $this->getAllAttributes($this);
  177.         if (key_exists("relationproducts", $attributes)) {
  178.             $relationsproducts = $this->getAttributeValue($attributes["relationproducts"]);
  179.             if ($relationsproducts) {
  180.                 foreach ($relationsproducts as $item) {
  181.                     if ($item->getTipo() == "Reducer") {
  182.                         $reducers[] = $item;
  183.                     }
  184.                 }
  185.             }
  186.         }
  187.         return $reducers;
  188.     }
  190.     public function getActivador()
  191.     {
  192.         $activadores = array();
  193.         $attributes = $this->getAllAttributes($this);
  194.         if (key_exists("relationproducts", $attributes)) {
  195.             $relationsproducts = $this->getAttributeValue($attributes["relationproducts"]);
  196.             if ($relationsproducts) {
  197.                 foreach ($relationsproducts as $item) {
  198.                     if ($item->getTipo() == "Activador") {
  199.                         $activadores[] = $item;
  200.                     }
  201.                 }
  202.             }
  203.         }
  204.         return $activadores;
  205.     }
  207.     public function getComplement()
  208.     {
  209.         $activadores = array();
  210.         $attributes = $this->getAllAttributes($this);
  211.         if (key_exists("relationproducts", $attributes)) {
  212.             $relationsproducts = $this->getAttributeValue($attributes["relationproducts"]);
  213.             if ($relationsproducts) {
  214.                 foreach ($relationsproducts as $item) {
  215.                     if ($item->getTipo() == "Complemento") {
  216.                         $activadores[] = $item;
  217.                     }
  218.                 }
  219.             }
  220.         }
  221.         return $activadores;
  222.     }
  224.     public function getConverter()
  225.     {
  226.         $converters = array();
  227.         $attributes = $this->getAllAttributes($this);
  228.         if (key_exists("relationproducts", $attributes)) {
  229.             $relationsproducts = $this->getAttributeValue($attributes["relationproducts"]);
  230.             if ($relationsproducts) {
  231.                 foreach ($relationsproducts as $item) {
  232.                     if ($item->getTipo() == "Converter") {
  233.                         $converters[] = $item;
  234.                     }
  235.                 }
  236.             }
  237.         }
  238.         return $converters;
  239.     }
  241.     public function getBase()
  242.     {
  243.         $base = array();
  244.         $attributes = $this->getAllAttributes($this);
  245.         if (key_exists("relationproducts", $attributes)) {
  246.             $relationsproducts = $this->getAttributeValue($attributes["relationproducts"]);
  247.             if ($relationsproducts) {
  248.                 foreach ($relationsproducts as $item) {
  249.                     if ($item->getTipo() == "Base") {
  250.                         $base[] = $item;
  251.                     }
  252.                 }
  253.             }
  254.         }
  255.         return $base;
  256.     }
  258.     public function getProporcionMezcla()
  259.     {
  260.         $proporcion = array();
  262.         $attributes = $this->getAllAttributes($this);
  263.         if (key_exists("relationproducts", $attributes)) {
  264.             $relationsproducts = $this->getAttributeValue($attributes["relationproducts"]);
  265.             if ($relationsproducts) {
  266.                 foreach ($relationsproducts as $item) {
  267.                     if (!empty(trim("" . $item->getMezcla()))) {
  268.                         $proporcion[] = trim("" . $item->getMezcla());
  269.                     }
  270.                 }
  271.             }
  272.         }
  274.         return $proporcion;
  275.     }
  277.     public function getDimensiones($fields = array('ancho', 'largo', 'alto'))
  278.     {
  279.         $dimension = "";
  280.         $attributes = $this->getAllAttributes($this);
  281.         $counter = -1;
  282.         $quantityArray = array();
  283.         $unitArray = array();
  285.         foreach ($fields as $field) {
  286.             if (key_exists($field, $attributes)) {
  287.                 $value = $this->getAttributeValue($attributes[$field]);
  288.                 switch ($attributes[$field]["fieldtype"]) {
  289.                     case "inputQuantityValue":
  290.                     case "quantityValue":
  291.                         if ($value) {
  292.                             $valorNumerico = trim("" . $value->getValue());
  293.                             $unidad = !is_null($value->getUnit()) ? trim("" . $value->getUnit()->getAbbreviation()) : "";
  295.                             if (!empty($valorNumerico)) {
  296.                                 $counter++;
  297.                                 $quantityArray[$counter] = $valorNumerico;
  299.                                 if (!empty($unidad)) {
  300.                                     $unitArray[$counter] = $unidad;
  301.                                 }
  302.                             }
  303.                         }
  304.                         break;
  305.                     default:
  306.                         if (!empty($value)) {
  307.                             $dimension = $value;
  308.                         }
  309.                 }
  310.             }
  311.         }
  313.         if (count($quantityArray) > 0) {
  314.             if (count(array_unique($unitArray)) > 1) {
  315.                 foreach ($quantityArray as $key => $value) {
  316.                     $unit = isset($unitArray[$key]) ? trim("" . $unitArray[$key]) : "";
  318.                     if (!($unit == "\"" || $unit == "'" || $unit == "º" || $unit == "")) {
  319.                         $unit = "&nbsp;" . $unit;
  320.                     }
  321.                     if (!empty(trim("" . $value))) {
  322.                         $quantityArray[$key] = trim("" . $value . $unit);
  323.                     }
  324.                 }
  325.                 $dimension = implode(" x ", $quantityArray);
  326.             } else {
  327.                 $unit = count($unitArray) > 0 ? trim("" . array_pop($unitArray)) : "";
  329.                 if (!($unit == "\"" || $unit == "'" || $unit == "º" || $unit == "")) {
  330.                     $unit = "&nbsp;" . $unit;
  331.                 }
  332.                 $dimension = trim("" . implode(" x ", $quantityArray) . $unit);
  333.             }
  334.         } else {
  335.             return "";
  336.         }
  337.         return $dimension;
  338.     }
  340.     public function getOldDimensionesList($fields = array('ancho', 'largo', 'alto'))
  341.     {
  342.         $variants = $this->getAllActiveVariants();
  343.         $attributes = $this->getAllAttributes($this);
  344.         $dimensionesList = array();
  346.         if (count($variants) > 0) {
  347.             foreach ($variants as $variant) {
  348.                 $dimension = $variant->getDimensiones($fields);
  349.                 if (!empty($dimension)) {
  350.                     $dimensionArray = explode_and_trim(" x ", $dimension);
  351.                     $valueUnitArray = explode_and_trim(" ", $dimensionArray[count($dimensionArray) - 1]);
  352.                     $defaultUnit = "";
  353.                     if (count($valueUnitArray) == 2) {
  354.                         $defaultUnit = $valueUnitArray[1];
  355.                     }
  356.                     $key = "";
  357.                     foreach ($dimensionArray as $valueUnit) {
  358.                         $valueUnitArray = explode_and_trim(" ", $valueUnit);
  360.                         $unit = $defaultUnit;
  361.                         $value = $valueUnitArray[0];
  362.                         if (count($valueUnitArray) == 2) {
  363.                             $unit = $valueUnitArray[1];
  364.                         }
  365.                         $key = is_string($this->convertToMM($value, $unit) ? '' : $key . "_" . str_pad(floor($this->convertToMM($value, $unit)), 6, "0", STR_PAD_LEFT));
  367.                     }
  368.                     $key = trim($key, "_");
  369.                     if (in_array('tallainternational', $fields) && in_array($dimension, $this->internationalSizeOrden)) {
  370.                         $key = array_search($dimension, $this->internationalSizeOrden);
  371.                         $key = str_pad($key, 6, "0", STR_PAD_LEFT);
  372.                     }
  373.                     $dimensionesList[$key] = $dimension;
  374.                 }
  375.             }
  376.         } else {
  377.             $dimension = $this->getDimensiones($fields);
  378.             if (!empty($dimension)) {
  379.                 $dimensionesList["000000"] = $dimension;
  380.             }
  381.         }
  382.         ksort($dimensionesList);
  383.         return $dimensionesList;
  384.     }
  386.     public function getDimensionesList($fields = array('ancho', 'largo', 'alto'))
  387.     {
  388.         $dimensionesList = array();
  390.         $dimension = $this->getDimensiones($fields);
  391.         if (!empty($dimension)) {
  392.             $dimensionesList["000000"] = $dimension;
  393.         }
  395.         ksort($dimensionesList);
  396.         return $dimensionesList;
  397.     }
  399.     public function getCapacity()
  400.     {
  401.         try {
  402.             $capacity = $this->getAttributeValue($this->getAllAttributes($this)["capacidad"]);
  403.             return [
  404.                 'value' => $capacity->getValue(),
  405.                 'unit' => strtoupper($capacity->getUnit()->getAbbreviation())
  406.             ];
  407.         } catch (\Throwable $th) {
  408.             return [
  409.                 'value' => '',
  410.                 'unit' => ''
  411.             ];
  412.         }
  413.     }
  415.     public function getColor()
  416.     {
  417.         try {
  418.             $colorId = $this->getAttributeValue($this->getAllAttributes($this)["color"]);
  419.             $color = \Pimcore\Model\DataObject\Colores::getById($colorId);
  420.             return [
  421.                 'name' => $color->getName(),
  422.                 'hex' => implode(",", $color->getHex()->getCssRgba()),
  423.             ];
  424.         } catch (\Throwable $th) {
  425.             if (is_null($color)){
  426.                 return [
  427.                     'name' => '',
  428.                     'hex' => '',
  429.                 ];
  430.             }else{
  431.                 return [
  432.                     'name' => $color->getName(),
  433.                     'hex' => '',
  434.                 ];
  435.             }
  437.         }
  438.     }
  440.     public function getPresentacionsList($fields = array('presentacion', 'capacidad'))
  441.     {
  442.         $variants = $this->getAllActiveVariants();
  443.         $attributes = $this->getAllAttributes($this);
  444.         $presentacionsList = array();
  445.         if (count($fields) == 2) {
  446.             if (count($variants) > 0) {
  447.                 if (key_exists($fields[0], $attributes)) {
  448.                     foreach ($variants as $variant) {
  450.                         $key = $variant->getAttributeValue($attributes[$fields[0]]);
  451.                         $value = "";
  452.                         if (!key_exists($key, $presentacionsList)) {
  453.                             $presentacionsList[$key] = array();
  454.                         }
  456.                         if (key_exists($fields[1], $attributes)) {
  457.                             $value = $variant->getAttributeValue($attributes[$fields[1]]);
  460.                             if (key_exists($fields[1], $attributes)) {
  461.                                 switch ($attributes[$fields[1]]["fieldtype"]) {
  462.                                     case "inputQuantityValue" :
  463.                                     case "quantityValue" :
  465.                                         $quantity = ($value && method_exists($value, "getValue")) ? trim("" . $value->getValue()) : "";
  466.                                         $unit = ($value && method_exists($value, "getValue")) ? trim("" . $value->getUnit()->getAbbreviation()) : "";
  468.                                         $value = "";
  469.                                         if (!empty($quantity)) {
  470.                                             $value = $quantity . "&nbsp;" . $unit;
  471.                                             switch (true) {
  472.                                                 case(in_array($unit, array("ml", "l", "pt", "gal"))) :
  473.                                                     $orderKey = floor($this->convertToML($quantity, $unit));
  474.                                                     break;
  475.                                                 case(in_array($unit, array("kg", "g"))) :
  476.                                                     $orderKey = floor($this->convertToMG($quantity, $unit));
  477.                                                     break;
  478.                                                 case(in_array($unit, array("mm", "cm", "m"))) :
  479.                                                     $orderKey = floor($this->convertToMM($quantity, $unit));
  480.                                                     break;
  481.                                                 default :
  482.                                                     $orderKey = $quantity;
  483.                                             }
  484.                                         }
  485.                                         break;
  486.                                     default:
  487.                                         $orderKey = $variant->getAttributeValue($attributes[$fields[1]]);
  488.                                 }
  489.                             }
  490.                             if (!empty($value)) {
  491.                                 $orderKey = str_pad($orderKey, 6, "0", STR_PAD_LEFT);
  492.                                 $presentacionsList[$key][$orderKey] = trim("" . $value);
  493.                             }
  494.                         }
  495.                     }
  496.                 }
  497.             } else {
  498.                 if (key_exists($fields[0], $attributes)) {
  499.                     $key = $this->getAttributeValue($attributes[$fields[0]]);
  500. //                    if ($key == null) {
  501. //                        $parent = $this->getParent();
  502. //                        if ($parent->o_type == "object") {
  503. //                      //      $key = $parent->getAttributeValue($attributes[$fields[0]]);
  504. //                        }
  505. //                    }
  506.                     $presentacionsList[$key] = array();
  507.                     if (key_exists($fields[1], $attributes)) {
  509.                         $orderKey = str_pad("", 6, "0", STR_PAD_LEFT);
  510.                         $value = $this->getAttributeValue($attributes[$fields[1]]);
  511.                         if (key_exists($fields[1], $attributes)) {
  512.                             switch ($attributes[$fields[1]]["fieldtype"]) {
  513.                                 case "inputQuantityValue" :
  514.                                 case "quantityValue" :
  516.                                     $quantity = ($value && method_exists($value, "getValue")) ? trim("" . $value->getValue()) : "";
  517.                                     $unit = ($value && method_exists($value, "getUnit") && $value->getUnit()) ? trim("" . $value->getUnit()->getAbbreviation()) : "";
  518.                                     $value = "";
  519.                                     if (!empty($quantity)) {
  520.                                         $value = $quantity . "&nbsp;" . $unit;
  521.                                         switch (true) {
  522.                                             case(in_array($unit, array("ml", "l", "pt", "gal"))) :
  523.                                                 $orderKey = floatval($this->convertToML($quantity, $unit));
  524.                                                 break;
  525.                                             case(in_array($unit, array("kg", "g"))) :
  526.                                                 $sortvalue = floatval($this->convertToMG($quantity, $unit));
  527.                                                 break;
  528.                                             case(in_array($unit, array("mm", "cm", "m"))) :
  529.                                                 $sortvalue = floatval($this->convertToMM($quantity, $unit));
  530.                                                 break;
  531.                                             default :
  532.                                                 $orderKey = $quantity;
  533.                                         }
  534.                                     }
  535.                                     break;
  536.                                 default:
  537.                                     $orderKey = $this->getAttributeValue($attributes[$fields[1]]);
  538.                             }
  539.                             if (!empty($value)) {
  540.                                 $orderKey = str_pad($orderKey, 6, "0", STR_PAD_LEFT);
  541.                                 $presentacionsList[$key][$orderKey] = trim("" . $value);
  542.                             }
  543.                         }
  544.                     }
  545.                 }
  546.             }
  547.         }
  548.         foreach ($presentacionsList as $key => $value) {
  549.             ksort($presentacionsList[$key]);
  550.         }
  551.         $hasValues = true;
  552.         if (count($presentacionsList) == 1) {
  553.             foreach ($presentacionsList as $key => $value) {
  554.                 if ((empty($key)) && (count($value) == 0)) {
  555.                     $presentacionsList = array();
  556.                 }
  557.             }
  558.         }
  560.         return $presentacionsList;
  561.     }
  563.     public function getPresentation(){
  565.         $attributes = $this->getAllAttributes($this);
  566.         $presentacion = "";
  568.         if (key_exists("presentacion", $attributes)) {
  569.             $key = $this->getAttributeValue($attributes["presentacion"]);
  570.             $presentacion = $key;
  571.         }
  573.         return $presentacion;
  575.     }
  577.     public function getCapacidad($field = 'capacidad'){
  578.         $attributes = $this->getAllAttributes($this);
  579.         $presentacionsList = array();
  582.         if (key_exists($field, $attributes)) {
  584.             $orderKey = str_pad("", 6, "0", STR_PAD_LEFT);
  585.             $value = $this->getAttributeValue($attributes[$field]);
  586.             if (key_exists($field, $attributes)) {
  587.                 switch ($attributes[$field]["fieldtype"]) {
  588.                     case "inputQuantityValue" :
  589.                     case "quantityValue" :
  591.                         $quantity = ($value && method_exists($value, "getValue")) ? trim("" . $value->getValue()) : "";
  592.                         $unit = ($value && method_exists($value, "getUnit") && $value->getUnit()) ? trim("" . $value->getUnit()->getAbbreviation()) : "";
  593.                         $value = "";
  594.                         if (!empty($quantity)) {
  595.                             $value = $quantity . "&nbsp;" . $unit;
  596.                             switch (true) {
  597.                                 case(in_array($unit, array("ml", "l", "pt", "gal"))) :
  598.                                     $orderKey = floatval($this->convertToML($quantity, $unit));
  599.                                     break;
  600.                                 case(in_array($unit, array("kg", "g"))) :
  601.                                     $sortvalue = floatval($this->convertToMG($quantity, $unit));
  602.                                     break;
  603.                                 case(in_array($unit, array("mm", "cm", "m"))) :
  604.                                     $sortvalue = floatval($this->convertToMM($quantity, $unit));
  605.                                     break;
  606.                                 default :
  607.                                     $orderKey = $quantity;
  608.                             }
  609.                         }
  610.                         break;
  611.                     default:
  612.                         $orderKey = $this->getAttributeValue($attributes[$fields[1]]);
  613.                 }
  614.                 if (!empty($value)) {
  615.                     $orderKey = str_pad($orderKey, 6, "0", STR_PAD_LEFT);
  616.                     $presentacionsList[$orderKey] = trim("" . $value);
  617.                 }
  618.             }
  619.         }
  621.         return $presentacionsList;
  622.     }
  623.     public function getOldPresentation($fields = array('presentacion', 'capacidad'))
  624.     {
  625.         $attributes = $this->getAllAttributes($this);
  626.         $presentacionsList = array();
  628.         if (count($fields) == 2) {
  629.             if (key_exists($fields[0], $attributes)) {
  630.                 $key = $this->getAttributeValue($attributes[$fields[0]]);
  631. //                    if ($key == null) {
  632. //                        $parent = $this->getParent();
  633. //                        if ($parent->o_type == "object") {
  634. //                      //      $key = $parent->getAttributeValue($attributes[$fields[0]]);
  635. //                        }
  636. //                    }
  637.                 $presentacionsList[$key] = array();
  638.                 if (key_exists($fields[1], $attributes)) {
  640.                     $orderKey = str_pad("", 6, "0", STR_PAD_LEFT);
  641.                     $value = $this->getAttributeValue($attributes[$fields[1]]);
  642.                     if (key_exists($fields[1], $attributes)) {
  643.                         switch ($attributes[$fields[1]]["fieldtype"]) {
  644.                             case "inputQuantityValue" :
  645.                             case "quantityValue" :
  647.                                 $quantity = ($value && method_exists($value, "getValue")) ? trim("" . $value->getValue()) : "";
  648.                                 $unit = ($value && method_exists($value, "getUnit") && $value->getUnit()) ? trim("" . $value->getUnit()->getAbbreviation()) : "";
  649.                                 $value = "";
  650.                                 if (!empty($quantity)) {
  651.                                     $value = $quantity . "&nbsp;" . $unit;
  652.                                     switch (true) {
  653.                                         case(in_array($unit, array("ml", "l", "pt", "gal"))) :
  654.                                             $orderKey = floatval($this->convertToML($quantity, $unit));
  655.                                             break;
  656.                                         case(in_array($unit, array("kg", "g"))) :
  657.                                             $sortvalue = floatval($this->convertToMG($quantity, $unit));
  658.                                             break;
  659.                                         case(in_array($unit, array("mm", "cm", "m"))) :
  660.                                             $sortvalue = floatval($this->convertToMM($quantity, $unit));
  661.                                             break;
  662.                                         default :
  663.                                             $orderKey = $quantity;
  664.                                     }
  665.                                 }
  666.                                 break;
  667.                             default:
  668.                                 $orderKey = $this->getAttributeValue($attributes[$fields[1]]);
  669.                         }
  670.                         if (!empty($value)) {
  671.                             $orderKey = str_pad($orderKey, 6, "0", STR_PAD_LEFT);
  672.                             $presentacionsList[$key][$orderKey] = trim("" . $value);
  673.                         }
  674.                     }
  675.                 }
  676.             }
  677.         }
  678.         foreach ($presentacionsList as $key => $value) {
  679.             ksort($presentacionsList[$key]);
  680.         }
  681.         $hasValues = true;
  682.         if (count($presentacionsList) == 1) {
  683.             foreach ($presentacionsList as $key => $value) {
  684.                 if ((empty($key)) && (count($value) == 0)) {
  685.                     $presentacionsList = array();
  686.                 }
  687.             }
  688.         }
  690.         return $presentacionsList;
  691.     }
  693.     public function getColorList()
  694.     {
  695.         $variants = $this->getAllActiveVariants();
  696.         $attributes = $this->getAllAttributes($this);
  697.         $colorList = array();
  698.         if (count($variants) > 0) {
  699.             if (key_exists('color', $attributes)) {
  700.                 foreach ($variants as $variant) {
  701.                     $colorId = $variant->getAttributeValue($attributes['color']);
  702.                     if ($colorId > 0) {
  703.                         $colorObj = \Pimcore\Model\DataObject\Colores::getById($colorId);
  704.                         if (!empty($colorObj)) {
  705.                             $colorList[$colorObj->getOrder()] = $colorObj;
  706.                         }
  707.                     }
  708.                 }
  709.             }
  710.         } else {
  711.             if (key_exists('color', $attributes)) {
  712.                 $colorId = $this->getAttributeValue($attributes['color']);
  713.                 if ($colorId > 0) {
  714.                     $colorObj = \Pimcore\Model\DataObject\Colores::getById($colorId);
  715.                     if (!empty($colorObj)) {
  716.                         $colorList[$colorObj->getOrder()] = $colorObj;
  717.                     }
  718.                 }
  719.             }
  720.         }
  721.         ksort($colorList, 1);
  722.         return $colorList;
  723.     }
  725.     public function getVariantPriceList()
  726.     {
  727.         $variants = $this->getAllActiveVariants();
  729.         $precios = array();
  730.         // $parentPrice = floatval(str_replace(",", ".", str_replace(".", "", $this->getPrice())));
  731.         $parentPrice = $this->getPrice();
  732.         if (!empty(trim("" . $parentPrice))) {
  733.             $precios[] = $parentPrice;
  734.         }
  735.         foreach ($variants as $variant) {
  736.             //$variantPrice = floatval(str_replace(",", ".", str_replace(".", "", $variant->getPrice())));
  737.             $variantPrice = $variant->getPrice();
  738.             if (!empty(trim("" . $variantPrice))) {
  739.                 $precios[] = $variantPrice;
  740.             }
  741.         }
  743.         $precios = array_unique($precios);
  744.         sort($precios, SORT_NUMERIC);
  745.         return $precios;
  746.     }
  748.     public function getVariantPriceListV2($useLimitedVariants = false)
  749.     {
  750.         if ($useLimitedVariants){
  751.             $variants = $this->getLimitedChildren(35, [AbstractObject::OBJECT_TYPE_VARIANT]);
  752.         }else{
  753.             $variants = $this->getAllActiveVariants();
  754.         }
  756.         $precios = array();
  757.         // $parentPrice = floatval(str_replace(",", ".", str_replace(".", "", $this->getPrice())));
  758.         $parentPrice = $this->getPrice();
  759.         if (!empty(trim("" . $parentPrice))) {
  760.             $precios[] = $parentPrice;
  761.         }
  762.         foreach ($variants as $variant) {
  763.             //$variantPrice = floatval(str_replace(",", ".", str_replace(".", "", $variant->getPrice())));
  764.             $variantPrice = $variant->getPrice();
  765.             if (!empty(trim("" . $variantPrice))) {
  766.                 $precios[] = $variantPrice;
  767.             }
  768.         }
  770.         $precios = array_unique($precios);
  771.         sort($precios, SORT_NUMERIC);
  772.         return $precios;
  773.     }
  775.     public function getVariantPriceAndIdList($useLimitedVariants = false)
  776.     {
  777.         if ($useLimitedVariants) {
  778.             $variants = $this->getLimitedChildren(35, [AbstractObject::OBJECT_TYPE_VARIANT]);
  779.         } else {
  780.             $variants = $this->getAllActiveVariants();
  781.         }
  783.         $precios = [];
  785.         // $parentPrice = floatval(str_replace(",", ".", str_replace(".", "", $this->getPrice())));
  786.         $parentPrice = $this->getPrice();
  787.         if (!empty(trim("" . $parentPrice))) {
  788.             $precios[$this->getId()] = $parentPrice;
  789.         }
  790.         foreach ($variants as $variant) {
  791.             //$variantPrice = floatval(str_replace(",", ".", str_replace(".", "", $variant->getPrice())));
  792.             $variantPrice = $variant->getPrice();
  793.             if (!empty(trim("" . $variantPrice))) {
  794.                 $precios[$variant->getId()] = $variantPrice;
  795.             }
  796.         }
  798.         $precios = array_unique($precios);
  799.         return $precios;
  800.     }
  802.     public function getPriceNumeric()
  803.     {
  804.         return $this->floatvalue($this->getPrice());
  805.     }
  806.     /*
  807.       public function getPrice()
  808.       {
  809.       if (parent::getPrice() && "0" !== parent::getPrice()) {
  810.       return number_format($this->floatvalue(parent::getPrice()), 2, ",", "") ;
  811.       } else {
  812.       return parent::getPrice();
  813.       }
  814.       }
  815.      */
  817.     public function getAllActiveVariants($orderKeys = array())
  818.     {
  819.         $productList = $this->getChildren([AbstractObject::OBJECT_TYPE_VARIANT]);
  821.         $variantsList = array(); // $this->getAllActiveVariantsOrderByPublication($productList);
  822.         if (count($variantsList) == 0) {
  823.             $variantsList = $this->getAllActiveVariantsOrderByKeys($productList, $orderKeys);
  824.         }
  826.         ksort($variantsList);
  827.         return $variantsList;
  828.     }
  830.     private function getAllActiveVariantsOrderByPublication($productList)
  831.     {
  832.         $variantsList = array();
  834.         if (class_exists('\IndabaPublicationBundle\Controller\TreeController')) {
  835.             $variantInfo = $this->getVariantsInfosFromPublication();
  836.             if (count($variantInfo)) {
  837.                 foreach ($productList as $product) {
  838.                     if (!in_array($product->getProductstatus(), array('new', 'decatelogized', 'for_delete'))) {
  839.                         $key = str_pad("0", 6, "0", STR_PAD_LEFT);
  841.                         $variantsList[$key] = $product;
  842.                     }
  843.                 }
  844.             }
  845.         }
  847.         return $variantsList;
  848.     }
  850.     private function getVariantsInfosFromPublication()
  851.     {
  852.         $variantInfo = array();
  853.         $db = \Pimcore\Db::get();
  854.         $query = "SELECT `id`,`structure_path`,`name`  FROM `schrader_catalogue_structure` WHERE `object_id` = " . $this->getId();
  855.         $result = $db->query($query);
  856.         $structurePath = "";
  857.         if ($row = $result->fetch()) {
  858.             $structurePath = $row["structure_path"] . $row["name"] . "/";
  859.         }
  860.         if (!empty($structurePath)) {
  861.             $query = "SELECT `id`,`object_id`,`orden`  FROM `schrader_catalogue_structure` WHERE `structure_path` = '" . $structurePath . "%' Order By `orden`;";
  862.             $result = $db->query($query);
  863.             while ($row = $result->fetch()) {
  864.                 $variantInfo[$row["orden"]] = $row["object_id"];
  865.             }
  866.         }
  868.         return $variantInfo;
  869.     }
  871.     private function getAllActiveVariantsOrderByKeys($productList, $orderKeys = array())
  872.     {
  873.         $variantsList = array();
  874.         $attributes = $this->getAllAttributes($this);
  875.         foreach ($productList as $product) {
  877.             if (!in_array($product->getProductstatus(), array('new', 'decatelogized', 'for_delete'))) {
  878.                 $keyArray = array();
  879.                 foreach ($orderKeys as $orderKey) {
  880.                     \Pimcore\Log\Simple::log("DefaultProduct", $orderKey);
  881.                     if (key_exists($orderKey, $attributes)) {
  882.                         switch ($attributes[$orderKey]["fieldtype"]) {
  883.                             case "inputQuantityValue" :
  884.                             case "quantityValue" :
  885.                                 $value = $product->getAttributeValue($attributes[$orderKey]);
  886.                                 $quantity = ($value && method_exists($value, "getValue")) ? $value->getValue() : "";
  887.                                 $unit = ($value && method_exists($value, "getUnit") && $value->getUnit()) ? $value->getUnit()->getAbbreviation() : "";
  888.                                 if (!empty($quantity)) {
  889.                                     switch (true) {
  890.                                         case(in_array($unit, array("ml", "l", "pt", "gal"))) :
  891.                                             $sortvalue = floor($this->convertToML($quantity, $unit));
  892.                                             break;
  893.                                         case(in_array($unit, array("kg", "g"))) :
  894.                                             $sortvalue = floor($this->convertToMG($quantity, $unit));
  895.                                             break;
  896.                                         case(in_array($unit, array("mm", "cm", "m"))) :
  897.                                             $sortvalue = floor($this->convertToMM($quantity, $unit));
  898.                                             break;
  899.                                         default :
  900.                                             $sortvalue = $quantity;
  901.                                     }
  902.                                     $keyArray[] = str_pad($sortvalue, 6, "0", STR_PAD_LEFT);
  903.                                 }
  904.                                 break;
  905.                             default:
  906.                                 $sortvalue = $product->getAttributeValue($attributes[$orderKey]);
  907.                                 if ($orderKey == 'tallainternational') {
  908.                                     $key = array_search($sortvalue, $this->internationalSizeOrden);
  909.                                     $sortvalue = str_pad($key, 6, "0", STR_PAD_LEFT);
  910.                                 }
  911.                                 $keyArray[] = $sortvalue;
  912.                         }
  913.                     }
  914.                 }
  915.                 $keyArray[] = (!empty($product->getBsncode())) ? $product->getBsncode() : $product->getManufacturercode();
  916.                 $key = implode("_", $keyArray);
  917.                 $variantsList[$key] = $product;
  918.             }
  919.         }
  920.         return $variantsList;
  921.     }
  923.     public function getAttributeValue($fieldinfo)
  924.     {
  925.         // $value = "";
  927.         $fieldObj = $this;
  928.         for ($i = 0; $i < count($fieldinfo["getters"]) - 1; $i++) {
  930.             $getter = $fieldinfo["getters"][$i];
  931.             $fieldObj = $fieldObj->$getter();
  932.         }
  933.         $getter = $fieldinfo["getters"][count($fieldinfo["getters"]) - 1];
  934.         $value = $fieldObj->$getter();
  936.         return $value;
  937.     }
  939.     public function getAllAttributes($obj)
  940.     {
  941.         $fieldArray = array();
  942.         $this->getDataDefinition($obj, $fieldArray);
  943.         $allFields = array();
  944.         foreach ($fieldArray as $key => $field) {
  945.             if ($key == "attributes") {
  946.                 $getterPrdAttribute = "get" . ucfirst($field["name"]);
  947.                 foreach ($field["objectbricks"] as $objbr) {
  948.                     $getterObjectBrick = $objbr["objectbrick"];
  949.                     foreach ($objbr["fields"] as $fieldOB) {
  950.                         $getterField = "get" . ucfirst($fieldOB->name);
  951.                         $valueObject = $obj->$getterPrdAttribute()->$getterObjectBrick()->$getterField();
  952.                         $allFields[$fieldOB->name] = array("fieldtype" => $fieldOB->fieldtype, "name" => $fieldOB->name, "title" => $fieldOB->title, "getters" => array($getterPrdAttribute, $getterObjectBrick, $getterField));
  953.                     }
  954.                 }
  955.             }
  956.         }
  957.         return $allFields;
  958.     }
  960.     public function getVariantsAttributes()
  961.     {
  962.         $excludeArray = $this->getExcludeVariantsFields();
  964.         $attributes = $this->getAllAttributes($this);
  965.         $variants = $this->getAllActiveVariants();
  967.         $variantsFieldArray = array();
  968.         foreach ($attributes as $key => $value) {
  969.             if (!in_array($key, $excludeArray)) {
  970.                 $parentValue = $this->getAttributeValue($value);
  971.                 foreach ($variants as $variant) {
  972.                     $variantValue = $variant->getAttributeValue($value); {
  973.                         if ($parentValue instanceof \Pimcore\Model\DataObject\Data\InputQuantityValue && $variantValue instanceof \Pimcore\Model\DataObject\Data\InputQuantityValue) {
  974.                             if ($parentValue->getValue() !== $variantValue->getValue() || $parentValue->getUnitId() !== $variantValue->getUnitId()) {
  975.                                 $variantsFieldArray[$key] = $value;
  976.                             }
  977.                         }else{
  978.                             if ($parentValue !== $variantValue ) {
  979.                                 $variantsFieldArray[$key] = $value;
  980.                             }
  981.                         }
  982.                     }
  983.                 }
  984.             }
  985.         }
  987.         return $variantsFieldArray;
  988.     }
  990.     public function getDataDefinition($obj, &$fieldArray, $excludeArray = array())
  991.     {
  992.         if (method_exists($obj, "getClass")) {
  993.             $classFielddefinition = $obj->getClass()->getFieldDefinitions();
  994.         } else {
  995.             $classFielddefinition = $obj->getDefinition()->getFieldDefinitions();
  996.         }
  997.         foreach ($classFielddefinition as $key => $fieldDefinition) {
  998.             if (in_array($key, $excludeArray)) {
  999.                 continue;
  1000.             }
  1001.             switch ($fieldDefinition->fieldtype) {
  1002.                 case "panel" :
  1003.                     $this->getChildDataDefinition($fieldDefinition, $fieldArray);
  1004.                     break;
  1005.                 case "localizedfields" :
  1006.                     $this->getFieldDefinitionCache($fieldDefinition, $fieldArray);
  1007.                     break;
  1008.                 case "objectbricks" :
  1009.                     if ($obj && $obj->getAttributes()) {
  1010.                         $objectBricks = $obj->getAttributes()->getBrickGetters();
  1011.                         // $objectBricks = $obj->getAttributes()->items ;
  1012.                         foreach ($objectBricks as $objBr) {
  1013.                             if ($obj->getAttributes()->$objBr()) {
  1014.                                 $fieldArrayObjBrick = array();
  1015.                                 $this->getDataDefinition($obj->getAttributes()->$objBr(), $fieldArrayObjBrick);
  1016.                                 $fieldArray[$key]["name"] = $fieldDefinition->name;
  1017.                                 $fieldArray[$key]["type"] = $fieldDefinition->fieldtype;
  1018.                                 $fieldArray[$key]["objectbricks"][] = array("objectbrick" => $objBr, "fields" => $fieldArrayObjBrick);
  1019.                             }
  1020.                         }
  1021.                     }
  1022.                     break;
  1023.                 default:
  1024.                     if ($fieldDefinition->datatype == "data") {
  1025.                         $fieldArray [$key] = $fieldDefinition;
  1026.                     }
  1027.             }
  1028.         }
  1029.     }
  1031.     private function getChildDataDefinition($fieldDefinition, &$fieldArray)
  1032.     {
  1033.         $childArray = $fieldDefinition->childs;
  1034.         foreach ($childArray as $ch) {
  1035.             if ($ch->datatype == "layout") {
  1036.                 $this->getChildDataDefinition($ch, $fieldArray);
  1037.             } else {
  1038.                 $fieldArray[$ch->name] = $ch;
  1039.             }
  1040.         }
  1041.     }
  1043.     private function getFieldDefinitionCache($fieldDefinition, &$fieldArray)
  1044.     {
  1045.         $childArray = $fieldDefinition->fieldDefinitionsCache;
  1046.         if ($childArray == null) {
  1047.             $childArray = $fieldDefinition->childs;
  1048.         }
  1049.         foreach ($childArray as $ch) {
  1050.             $fieldArray[$ch->name] = $ch;
  1051.         }
  1052.     }
  1054.     private function getExcludeVariantsFields()
  1055.     {
  1056.         $excludeArray = array();
  1057.         $excludeArray[] = "indaba";
  1058.         $excludeArray[] = "view_in_web";
  1059.         $excludeArray[] = "preview";
  1060.         $excludeArray[] = "stock";
  1061.         $excludeArray[] = "bsncode";
  1062.         $excludeArray[] = "productstatus";
  1063.         $excludeArray[] = "titleerp";
  1064.         $excludeArray[] = "barcode";
  1065.         $excludeArray[] = "ubicacion";
  1066.         $excludeArray[] = "name";
  1067.         $excludeArray[] = "shortdescription";
  1068.         $excludeArray[] = "longdescription";
  1069.         $excludeArray[] = "images";
  1070.         $excludeArray[] = "categories";
  1071.         $excludeArray[] = "documents";
  1072.         $excludeArray[] = "urlseofriendly";
  1073.         $excludeArray[] = "seodescription";
  1075.         return $excludeArray;
  1076.     }
  1078.     private function convertToML($quantity, $unit)
  1079.     {
  1080.         $pintToMl = 473.1764;
  1081.         $galToMl = 3785.4118;
  1082.         if (!empty($quantity)) {
  1083.             $quantity = trim("" . $quantity);
  1084.             $quantityArray = explode(" ", $quantity);
  1086.             foreach ($quantityArray as $key => $quantity) {
  1087.                 $quantityArray[$key] = $this->fractionToDecimal($quantity);
  1088.             }
  1090.             if ($unit != "ml") {
  1091.                 switch ($unit) {
  1092.                     case "l" :
  1093.                         $quantity = str_replace(",", ".", "" . $quantityArray[0]);
  1094.                         $quantity = floatval($quantity) * 1000;
  1095.                         break;
  1096.                     case "pt" :
  1097.                         $quantity = 0;
  1098.                         foreach ($quantityArray as $q) {
  1099.                             $quantity = $quantity + ($pintToMl * $q);
  1100.                         }
  1101.                         break;
  1102.                     case "gal" :
  1103.                         $quantity = 0;
  1104.                         foreach ($quantityArray as $q) {
  1105.                             $quantity = $quantity + ($galToMl * $q);
  1106.                         }
  1107.                         break;
  1108.                 }
  1109.             }
  1110.         }
  1111.         return $quantity;
  1112.     }
  1114.     private function convertToMG($quantity, $unit)
  1115.     {
  1116.         if (!empty($quantity)) {
  1117.             $quantity = trim("" . $quantity);
  1118.             $quantityArray = explode(" ", $quantity);
  1120.             foreach ($quantityArray as $key => $quantity) {
  1121.                 $quantityArray[$key] = $this->fractionToDecimal($quantity);
  1122.             }
  1124.             if ($unit != "g") {
  1125.                 switch ($unit) {
  1126.                     case "kg" :
  1127.                         $quantity = str_replace(",", ".", "" . $quantityArray[0]);
  1128.                         $quantity = floatval($quantity) * 1000;
  1129.                         break;
  1130.                 }
  1131.             }
  1132.         }
  1133.         return $quantity;
  1134.     }
  1136.     private function convertToMM($quantity, $unit)
  1137.     {
  1138.         if (!empty($quantity)) {
  1139.             $quantity = trim("" . $quantity);
  1140.             $quantityArray = explode(" ", $quantity);
  1142.             foreach ($quantityArray as $key => $quantity) {
  1143.                 $quantityArray[$key] = $this->fractionToDecimal($quantity);
  1144.             }
  1146.             if ($unit != "mm") {
  1147.                 switch ($unit) {
  1148.                     case "m" :
  1149.                         $quantity = str_replace(",", ".", "" . $quantityArray[0]);
  1150.                         $quantity = floatval($quantity) * 1000;
  1151.                         break;
  1152.                     case "cm" :
  1153.                         $quantity = str_replace(",", ".", "" . $quantityArray[0]);
  1154.                         $quantity = floatval($quantity) * 10;
  1155.                         break;
  1156.                 }
  1157.             }
  1158.         }
  1159.         return $quantity;
  1160.     }
  1162.     private function fractionToDecimal($fraction)
  1163.     {
  1164.         $multipl = 1;
  1165.         $numArray = explode("/", $fraction);
  1166.         $numXArray = explode("x", $numArray[0]);
  1167.         if (count($numXArray) == 2) {
  1168.             $numArray[0] = $numXArray[1];
  1169.             $multipl = $numXArray[0];
  1170.         }
  1171.         if (count($numArray) == 2) {
  1172.             return (intval($numArray[0]) / intval($numArray[1])) * intval($multipl);
  1173.         } else {
  1174.             return $numArray[0];
  1175.         }
  1176.     }
  1177.     /*
  1178.      *
  1179.      * Own functions bsnbarcelona end
  1180.      */
  1182.     protected $prices = [];
  1184.     /**
  1185.      * Returns an array on min and max price for a product based on all it's children
  1186.      *
  1187.      * @param string $priceType (new|old)
  1188.      *
  1189.      * @return array|int|null
  1190.      */
  1191.     public function getPriceRange($priceType = 'new')
  1192.     {
  1193.         if (!array_key_exists($priceType, $this->prices)) {
  1194.             $method = $priceType == 'new' ? 'getPrice' : 'getPriceOld';
  1195.             if ($this->isVariant()) {
  1196.                 return $this->$method();
  1197.             } else {
  1198.                 $prices = [];
  1200.                 $colorSizeVariants = $this->internalGetSizeVariants();
  1201.                 foreach ($colorSizeVariants as $sizeVariants) {
  1202.                     foreach ($sizeVariants as $sizeVariant) {
  1203.                         $prices[] = $sizeVariant->$method();
  1204.                     }
  1205.                 }
  1206.                 if ($prices) {
  1207.                     $min = min($prices);
  1208.                     $max = max($prices);
  1209.                     if ($min == $max) {
  1210.                         $this->prices[$priceType] = $min;
  1211.                     } else {
  1212.                         $this->prices[$priceType] = ['min' => $min, 'max' => $max];
  1213.                     }
  1214.                 } else {
  1215.                     $this->prices[$priceType] = null;
  1216.                 }
  1217.             }
  1218.         }
  1220.         return $this->prices[$priceType];
  1221.     }
  1223.     /**
  1224.      * @return \Pimcore\Model\Asset\Image|null
  1225.      */
  1226.     public function getFirstImageAsset()
  1227.     {
  1228.         if (method_exists($this, "getImages")) {
  1229.             $imageList = $this->getImages();
  1230.             $isOnlyOneImage = (count($imageList) == 1);
  1231.             if (count($imageList) > 1) {
  1232.                 foreach ($imageList as $imageObject) {
  1233.                     if (($imageObject->getWww()) && (($isOnlyOneImage) || ($imageObject->getOrder() < 2))) {
  1234.                         return $imageObject->getElement();
  1235.                     }
  1236.                 }
  1237.             } else {
  1238.                 if ($isOnlyOneImage) {
  1239.                     return $imageList[0]->getElement();
  1240.                 }
  1241.             }
  1242.         }
  1243.         return null;
  1244.     }
  1246.     /**
  1247.      * returns product variant that should be used for detail link
  1248.      *
  1249.      * @return \App\Model\DefaultProduct
  1250.      */
  1251.     public function getLinkProduct()
  1252.     {
  1253.         $firstSizeVariants = $this->getColorVariants(true);
  1254.         return $this; //Link of the same product, not to its variants
  1255. //        if (count($firstSizeVariants) == 0) {
  1256. //            // no variants
  1257. //            return $this;
  1258. //        } else {
  1259. //            return $firstSizeVariants[0];
  1260. //        }
  1261.     }
  1263.     /**
  1264.      * Returns concatenated category names for product
  1265.      *
  1266.      * @param bool $seo to suppress seo name, default is true and returns the seo name if available
  1267.      *
  1268.      * @return string
  1269.      */
  1270.     public function getCategoriesText($seo = true)
  1271.     {
  1272.         $categories = $this->getCategories();
  1273.         $categoriesArray = [];
  1274.         foreach ($categories as $item) {
  1275.             $categoriesArray[] = ($item->getUrlseofriendly() && $seo) ? $item->getUrlseofriendly() : $item->getTitle();
  1276.         }
  1278.         return implode(',', $categoriesArray);
  1279.     }
  1281.     public function getMainMaterialText()
  1282.     {
  1283.         $mainMaterials = $this->getMaterialComposition() ? $this->getMaterialComposition() : [];
  1284.         $mainMaterialsArray = [];
  1285.         foreach ($mainMaterials as $item) {
  1286.             if ($item->getPercent()) {
  1287.                 $mainMaterialsArray[] = $item->getPercent() . '% ' . $item->getObject()->getName();
  1288.             } else {
  1289.                 $mainMaterialsArray[] = $item->getObject()->getName();
  1290.             }
  1291.         }
  1293.         return implode(',', $mainMaterialsArray);
  1294.     }
  1296.     public function getSecondaryMaterialText()
  1297.     {
  1298.         $secondaryMaterials = $this->getSecondaryMaterialComposition() ? $this->getSecondaryMaterialComposition() : [];
  1299.         $secondaryMaterialsArray = [];
  1300.         foreach ($secondaryMaterials as $item) {
  1301.             if ($item->getPercent()) {
  1302.                 $secondaryMaterialsArray[] = $item->getPercent() . '% ' . $item->getObject()->getName();
  1303.             } else {
  1304.                 $secondaryMaterialsArray[] = $item->getObject()->getName();
  1305.             }
  1306.         }
  1308.         return implode(',', $secondaryMaterialsArray);
  1309.     }
  1311.     public function getCanonicalId()
  1312.     {
  1313.         if ($this->isVariant()) {
  1314.             return $this->getParent()->getCanonicalId();
  1315.         } else {
  1316.             return $this->getId();
  1317.         }
  1318.     }
  1320.     /**
  1321.      * Returns the first size variant for all color variants (or just the color variants) of a product regardless if it's the main product or already a color variant
  1322.      *
  1323.      * @param $withSize switch the color with ot without the first size variant
  1324.      *
  1325.      * @return \App\Model\DefaultProduct[]
  1326.      */
  1327.     public function getColorVariants($withSize = true)
  1328.     {
  1329.         if ($withSize) {
  1330.             $firstSizeVariants = [];
  1331.             foreach ($this->internalGetFirstSizeVariants() as $id => $sizeVariant) {
  1332.                 if ($sizeVariant) {
  1333.                     $firstSizeVariants[] = $sizeVariant;
  1334.                 } else {
  1335.                     $firstSizeVariants[] = AbstractObject::getById($id);
  1336.                 }
  1337.             }
  1339.             return $firstSizeVariants;
  1340.         } else {
  1341.             return $this->internalGetColorVariants();
  1342.         }
  1343.     }
  1345.     public $baseProduct = null;
  1346.     public $baseColorVariant = null;
  1347.     private $colorVariants = null;
  1348.     public $firstSizeVariants = null;
  1349.     private $sizeVariants = null;
  1351.     protected function fillBaseProducts()
  1352.     {
  1353.         if (!$this->isVariant()) {
  1354.             $this->baseProduct = $this;
  1355.             $this->baseColorVariant = null;
  1356.         } elseif ($this->getType() == AbstractObject::OBJECT_TYPE_OBJECT) {
  1357.             $this->baseProduct = $this->getParent();
  1358.             $this->baseColorVariant = $this;
  1359.         } elseif ($this->getType() == AbstractObject::OBJECT_TYPE_VARIANT && $this->getParent()->getType() == AbstractObject::OBJECT_TYPE_OBJECT) {
  1360.             $this->baseColorVariant = $this->getParent();
  1361.             $this->baseProduct = $this->getParent()->getParent();
  1362.         } else {
  1363.             throw new \Exception('Invalid Product Tree with object ' . $this->getId());
  1364.         }
  1365.     }
  1367.     protected function fillVariants()
  1368.     {
  1369.         $this->fillBaseProducts();
  1371.         $this->colorVariants = $this->internalGetColorVariants();
  1372.         $this->firstSizeVariants = [];
  1373.         if (!empty($this->colorVariants)) {
  1374.             foreach ($this->colorVariants as $colorVariant) {
  1375.                 $children = $colorVariant->getChildren(([AbstractObject::OBJECT_TYPE_VARIANT]));
  1376.                 $this->firstSizeVariants[$colorVariant->getId()] = reset($children);
  1377.             }
  1378.         }
  1379.     }
  1381.     public function internalGetBaseProduct()
  1382.     {
  1383.         if (empty($this->baseProduct)) {
  1384.             $this->fillVariants();
  1385.         }
  1387.         return $this->baseProduct;
  1388.     }
  1390.     protected function internalGetColorVariants()
  1391.     {
  1392.         if ($this->colorVariants === null) {
  1393.             $this->colorVariants = $this->internalGetBaseProduct()->getChildren([AbstractObject::OBJECT_TYPE_OBJECT]);
  1394.         }
  1396.         return $this->colorVariants;
  1397.     }
  1399.     protected function internalGetSizeVariants()
  1400.     {
  1401.         if ($this->sizeVariants === null) {
  1402.             $this->sizeVariants = [];
  1403.             if (!empty($this->colorVariants)) {
  1404.                 foreach ($this->colorVariants as $colorVariant) {
  1405.                     $this->sizeVariants[$colorVariant->getId()] = $colorVariant->getChildren(([AbstractObject::OBJECT_TYPE_VARIANT]));
  1406.                 }
  1407.             }
  1408.         }
  1410.         return $this->sizeVariants;
  1411.     }
  1413.     protected function internalGetFirstSizeVariants()
  1414.     {
  1415.         if ($this->firstSizeVariants === null) {
  1416.             $this->fillVariants();
  1417.         }
  1419.         return $this->firstSizeVariants;
  1420.     }
  1422.     public function getBaseColorVariant()
  1423.     {
  1424.         if (empty($this->baseColorVariant)) {
  1425.             $this->fillVariants();
  1426.         }
  1428.         return $this->baseColorVariant;
  1429.     }
  1431.     /**
  1432.      * Returns size variants for a product regardless if it's the main product, a color child or a size variant
  1433.      *
  1434.      * @return \App\Model\DefaultProduct[]|null
  1435.      */
  1436.     public function getSizeVariants()
  1437.     {
  1438.         if (empty($this->baseProduct)) {
  1439.             $this->fillBaseProducts();
  1440.         }
  1442.         if ($this->baseColorVariant) {
  1443.             $list = new Product\Listing();
  1444.             $list->setCondition('o_parentId = ?', $this->baseColorVariant->getId());
  1445.             $list->setObjectTypes([AbstractObject::OBJECT_TYPE_VARIANT]);
  1446.             $list->setOrderKey('size');
  1447.             $list->setOrder('ASC');
  1449.             return SizeSort::sort($list->load());
  1450.         } else {
  1451.             return [];
  1452.         }
  1453.     }
  1455.     protected $isVariant = null;
  1457.     /**
  1458.      * Checks if a a product is a variant or the main product
  1459.      *
  1460.      * @return bool
  1461.      */
  1462.     public function isVariant()
  1463.     {
  1464.         if ($this->isVariant === null) {
  1465.             if ($this->getType() == 'object' && $this->getParent() instanceof Folder) {
  1466.                 $this->isVariant = false;
  1467.             } else {
  1468.                 $this->isVariant = true;
  1469.             }
  1470.         }
  1472.         return $this->isVariant;
  1473.     }
  1475.     public function hasTechnologyAttributes()
  1476.     {
  1477.         return $this->getMainMaterialText() || $this->getSecondaryMaterialText() || $this->getFeatures();
  1478.     }
  1480.     public function getFirstCategory()
  1481.     {
  1482.         //\Pimcore\Model\DataObject\AbstractObject::setGetInheritedValues(true);
  1483.         if ($categories = $this->getCategories()) {
  1484.             foreach ($categories as $cat) {
  1485.                 return $cat;
  1486.             }
  1487.         }
  1488.     }
  1490.     public function getPriceTax($tax)
  1491.     {
  1492.         $price = $this->floatvalue($this->getPrice());
  1493.         return $price * $this->floatvalue($tax);
  1494.     }
  1496.     /**
  1497.      * enables inheritance for field collections, if xxxInheritance field is available and set to string 'true'
  1498.      *
  1499.      * @param string $key
  1500.      *
  1501.      * @return mixed|\Pimcore\Model\DataObject\Fieldcollection
  1502.      */
  1503.     public function preGetValue($key)
  1504.     {
  1505.         if ($this->getClass()->getAllowInherit() && AbstractObject::doGetInheritedValues() && $this->getClass()->getFieldDefinition($key) instanceof \Pimcore\Model\DataObject\ClassDefinition\Data\Fieldcollections
  1506.         ) {
  1507.             $checkInheritanceKey = $key . 'Inheritance';
  1508.             if ($this->{
  1509.                 'get' . $checkInheritanceKey
  1510.                 }() == 'true'
  1511.             ) {
  1512.                 $parentValue = $this->getValueFromParent($key);
  1513.                 $data = $this->$key;
  1514.                 if (!$data) {
  1515.                     $data = $this->getClass()->getFieldDefinition($key)->preGetData($this);
  1516.                 }
  1517.                 if (!$data) {
  1518.                     return $parentValue;
  1519.                 } else {
  1520.                     $value = new \Pimcore\Model\DataObject\Fieldcollection($data->getItems());
  1521.                     if (!empty($parentValue)) {
  1522.                         foreach ($parentValue as $entry) {
  1523.                             $value->add($entry);
  1524.                         }
  1525.                     }
  1527.                     return $value;
  1528.                 }
  1529.             }
  1530.         }
  1532.         return parent::preGetValue($key);
  1533.     }
  1535.     function floatvalue($val)
  1536.     {
  1537.         $val = str_replace(",", ".", $val);
  1538.         $val = preg_replace('/\.(?=.*\.)/', '', $val);
  1539.         return floatval($val);
  1540.     }
  1542.     public function getLimitedChildren($limit = 10, $objectTypes = [self::OBJECT_TYPE_VARIANT]) {
  1543.         $list = new Product\Listing();
  1544.         $list->setCondition('o_parentId = ?', $this->getId());
  1545.         $list->setOrderKey(sprintf('o_%s', $this->getChildrenSortBy()));
  1546.         $list->setOrder($this->getChildrenSortOrder());
  1547.         $list->setObjectTypes($objectTypes);
  1548.         $list->setLimit($limit);
  1550.         return $list->load();
  1551.     }
  1552. }