src/EventListener/ObjectUpdateListener.php line 56

Open in your IDE?
  1. <?php
  2. namespace App\EventListener;
  4. use App\Model\Product\AutoFields;
  5. use App\Model\Product\LandedCost;
  6. use App\Model\Product\TariffCode;
  7. use App\Model\Product\Wholesale\PriceTable;
  8. use App\Services\ExportService;
  9. use Jabber\GenericBundle\EventListener\PimcoreAdmin;
  10. use Jabber\ObjectDropdownBundle\Cache\Memcached\CacheKeys;
  11. use Jabber\ObjectDropdownBundle\Objects\OptionsProvider;
  12. use Pimcore;
  13. use Pimcore\Event\Model\ElementEventInterface;
  14. use Pimcore\Event\Model\DataObjectEvent;
  15. use Pimcore\Event\Model\AssetEvent;
  16. use Pimcore\Event\Model\DocumentEvent;
  17. use Pimcore\Model\Asset;
  18. use Pimcore\Model\DataObject;
  19. use Pimcore\Model\DataObject\Product;
  20. use Pimcore\Model\DataObject\Retailer;
  21. use Pimcore\Model\DataObject\Size;
  22. use Pimcore\Model\DataObject\SizeGroup;
  23. use Pimcore\Model\DataObject\SizeGroup\Listing;
  24. use Pimcore\Model\User\AbstractUser;
  25. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  26. use Pimcore\Model\DataObject\Barcodes\Listing as BarcodeListing;
  27. use Pimcore\Model\DataObject\Collections;
  28. use Pimcore\Model\DataObject\Colour;
  29. use Pimcore\Model\DataObject\Department;
  30. use Pimcore\Model\DataObject\MainGroup;
  31. use Pimcore\Model\DataObject\SubGroup;
  33. class ObjectUpdateListener {
  35.     private $params;
  37.     public function __construct(ParameterBagInterface $params) {
  38.         $this->params = $params;
  39.     }
  41.     private function IsSystemUser($dataObject) {
  42.         $user = \Pimcore\Model\User::getById($dataObject->getUserModification());
  43.         if ($user instanceof \Pimcore\Model\User) {
  44.             if ($user->getId() == 0) {
  45.                 return true;
  46.             }
  47.             if (!empty($this->params->get('system_user_id'))) {
  48.                 if ($user->getParentId() == $this->params->get('system_user_id')) {
  49.                     return true;
  50.                 }
  51.             }
  52.         }
  53.         return false;
  54.     }
  56.     public function onPostUpdate (ElementEventInterface $e) {
  58.         if (!$e->hasArgument('isAutoSave')) {
  59.             if($e instanceof AssetEvent) {
  60.                 // do something with the asset
  61.                 $foo = $e->getAsset();
  62.             } else if ($e instanceof DocumentEvent) {
  63.                 // do something with the document
  64.                 $foo = $e->getDocument();
  65.             } else if ($e instanceof DataObjectEvent) {
  66.                 // do something with the object
  67.                 $dataObject = $e->getObject();
  68.                 if ($dataObject instanceof Product) {
  69.                     $dirtyDetection = $dataObject->isDirtyDetectionDisabled();
  70.                     
  71.                     if ($dataObject->getType() == "variant") {
  72.                         
  73.                         $this->PublishChildren($dataObject);
  74.                     }
  75.                 } else {
  76.                     $this->ClearCachedData($dataObject); //Has to be within the post and not pre otherwise the updated value will not be read
  77.                 }
  78.             }
  79.         }
  80.     }
  82.     public function onPreUpdate (ElementEventInterface $e) {
  83.         if (!$e->hasArgument('isAutoSave')) {
  84.             if($e instanceof AssetEvent) {
  85.                 // do something with the asset
  86.                 $foo = $e->getAsset();
  87.             } else if ($e instanceof DocumentEvent) {
  88.                 // do something with the document
  89.                 $foo = $e->getDocument();
  90.             } else if ($e instanceof DataObjectEvent) {
  91.                 // do something with the object
  92.                 $dataObject = $e->getObject();
  93.                 if (!$this->IsSystemUser($dataObject)) {
  94.                 
  95.                 
  96.                     $parentPath = $dataObject->getParent();
  97.                     $baseFolder = $this->GetBaseFolder($parentPath);
  99.                     if ($dataObject instanceof Product) {
  100.                         $autoFields = new AutoFields();
  101.                         $dataObject = $autoFields->ProductLevel($dataObject);
  103.                         if ($dataObject->getType() == "variant") {
  105.                             if ($dataObject->isPublished() == false) {
  106.                                 //$dataObject = $this->GenerateSKU($dataObject);
  107.                             }
  108.                             $this->CheckVariantMandatoryFields($dataObject);
  109.                             $dataObject = $this->getSizeRange($dataObject);
  110.                             $dataObject = $this->AddWholesalePrices($dataObject);
  111.                             $dataObject = $this->LandedCostTable($dataObject);
  112.                             //$dataObject = $this->GetBarcode($dataObject);
  113.                             $dataObject = $autoFields->LaunchMonth($dataObject);
  114.                             //$dataObject = $this->GetSimilarWeight($dataObject);
  115.                             //$this->ValidateTariffCode($dataObject);
  116.                         } else if ($dataObject->getType() == "object") {
  117.                             //$dataObject = $this->GetClassificationStore($dataObject);
  118.                             $dataObject = $this->MoveObject($dataObject);
  119.                             $this->CheckMaterialPercentage($dataObject);
  120.                         }
  121.                         if (method_exists($dataObject, "getImages")) {
  122.                             //$this->ChangeImagePaths($dataObject);
  123.                             //$this->AddImageMetaDataAndChangePath($dataObject);
  124.                         }
  128.                     } else if ($dataObject instanceof SizeGroup) {
  129.                         $dataObject = $this->ReorderSizeGroup($dataObject);
  130.                     }
  132.                     if (
  133.                         get_class($dataObject) == "Pimcore\Model\DataObject\Colour" || get_class($dataObject) == "Pimcore\Model\DataObject\Size" || get_class($dataObject) == "Pimcore\Model\DataObject\Supplier" || get_class($dataObject) == "Pimcore\Model\DataObject\Contact"
  134.                     ) {
  135.                         $exportCheck = $dataObject->getProperty("EXPORTED_PRIAM");
  136.                         if (($exportCheck === false || empty($exportCheck)) && $dataObject->getPublished() == true) {
  137.                             $exportService = new ExportService($this->params);
  138.                             $exportService->GenerateExport([$dataObject], null, null, null, true);
  139.                             $dataObject->setProperty("EXPORTED_PRIAM", "bool", true);
  140.                         }
  141.                     }
  142.                 }
  144.             }
  145.         }
  146.     }
  148.     private function GetBarcode($dataObject) {
  150.         if ($this->GetLevel($dataObject) == 3) {
  151.             $currentBarcode = $dataObject->getEAN();
  153.             if (empty($currentBarcode)) {
  154.                 $barcodeObject = new BarcodeListing();
  155.                 $barcodeObject->filterByUsed(0, "=");
  156.                 $barcodeObject->setLimit(1);
  158.                 foreach ($barcodeObject as $barcode) {
  159.                     $barcode->setProduct($dataObject);
  160.                     $barcode->setUsed(true);
  161.                     $barcode->save();
  162.                     $dataObject->setEAN($barcode->getBarcode());
  163.                     break;
  164.                 }
  166.             }
  168.         }
  169.         return $dataObject;
  170.     }
  172.     private function ReorderSizeGroup(SizeGroup $dataObject) {
  173.         $sizeList = [];
  174.         if (is_iterable($dataObject->getSize())) {
  175.             foreach ($dataObject->getSize() as $size) {
  176.                 $sizeList[] = $size;
  177.             }
  178.             sort($sizeList);
  179.             //throw new \Exception(json_encode($sizeList));
  180.             $dataObject->setSize($sizeList);
  181.         }
  182.         return $dataObject;
  183.     }
  185.     private function ValidateTariffCode($dataObject) {
  186.         if ($dataObject->getPublished() == true) {
  187.             $tariffObject = new TariffCode();
  188.             $tariffCode = $this->GetInheritedField($dataObject, 'IETariffCode');
  189.             $validCode = $tariffObject->ValidateTariffCode($tariffCode);
  190.             if ($validCode == false) {
  191.                 throw new \Pimcore\Model\Element\ValidationException('The selected tariff code is invalid. Your product cannot be saved');
  192.             }
  193.         }
  195.     }
  197.     private function PublishChildren(DataObject $dataObject) {
  198.         if ($dataObject->getParent()->getType() == "object") {
  199.             if ($dataObject->isPublished()) {
  200.                 foreach ($dataObject->getChildren([DataObject::OBJECT_TYPE_VARIANT], true) as $child) {
  201.                     if (!$child->isPublished()) {
  202.                         $child->setPublished(true);
  203.                         $child->save();
  204.                     }
  205.                 }
  206.             } else {
  207.                 foreach ($dataObject->getChildren([DataObject::OBJECT_TYPE_VARIANT]) as $child) {
  208.                     $child->setPublished(false);
  209.                     $child->save();
  210.                 }
  211.             }    
  212.         }
  213.         
  214.         // if ($dataObject->isPublished()) {
  215.         //     if ($dataObject->getParent()->getType() == "object") {
  216.         //         $versions = $dataObject->getVersions();
  217.         //         if (isset($versions[count($versions)-2])) {
  218.         //             $previousVersion = $versions[count($versions)-2];
  219.         //             $previousObject = $previousVersion->getData();
  220.         //             if ($previousObject->getPublished() == false) {
  221.         //                 // $productQuery = new Product\Listing();
  222.         //                 // $productQuery->filterByPublished(false);
  223.         //                 // $productQuery->setCondition('o_parentId = ?', [$dataObject->getId()]);
  224.         //                 // foreach($productQuery as $child) {
  225.         //                 //     $child->setPublished(true);
  226.         //                 //     $child->save();
  227.         //                 // }
  228.         //                 foreach ($dataObject->getChildren([DataObject::OBJECT_TYPE_VARIANT], true) as $child) {
  229.         //                     if ($child->getPublished() == false) {
  230.         //                         $child->setPublished(true);
  231.         //                         $child->save();
  232.         //                     }
  233.         //                 }
  234.         //             }
  235.         //         } else {
  236.         //             foreach ($dataObject->getChildren([DataObject::OBJECT_TYPE_VARIANT], true) as $child) {
  237.         //                 if ($child->getPublished() == false) {
  238.         //                     $child->setPublished(true);
  239.         //                     $child->save();
  240.         //                 }
  241.         //             }
  242.         //         }
  243.         //     }
  244.         // }
  245.     }
  247.     public function GetInheritedField($product, $field, $minLevel = 0) {
  248.         if (!is_object($product)) {
  249.             $product = Product::GetById($product, false);
  250.         }
  251.         if ($product->getType() == "object" && $minLevel > 0) {
  252.             return;
  253.         }
  255.         $function = "get$field";
  256.         $responseData = $product->$function();
  257.         if (empty($responseData) && $product->getType() != "object") {
  258.             return $this->GetInheritedField($product->getParent(), $field, $minLevel);
  259.         } else {
  260.             return $responseData;
  261.         }
  262.     }
  264.     /**
  265.      * Intercepts the users save commmand and checks mandatory data that is not mandatory at the parent level
  266.      *
  267.      * Mandatory fields are specified in the parameter bag in the services file
  268.      *
  269.      * @param DataObject $dataObject
  270.      * @return void
  271.      * @throws \Pimcore\Model\Element\ValidationException
  272.      */
  273.     private function CheckVariantMandatoryFields(DataObject $dataObject) {
  274.         if ($dataObject->getPublished() == true) {
  275.             $variantMandatoryFields = $this->params->get('variant_mandatory_fields');
  276.             $productDepth = $this->GetLevel($dataObject);
  278.             if (isset($variantMandatoryFields['Product']['Lvl'.$productDepth])) {
  279.                 $fieldList = $variantMandatoryFields['Product']['Lvl'.$productDepth];
  280.                 foreach ($fieldList as $requiredField) {
  281.                     $function = "get" . $requiredField;
  282.                     if (method_exists($dataObject, $function)) {
  283.                         if (empty($this->GetInheritedField($dataObject, $requiredField, 0))) {
  284.                             throw new \Pimcore\Model\Element\ValidationException("The mandatory field $requiredField has not been populated. To publish your product this data first needs to be entered. (" . $dataObject->getId() . " - ".  $dataObject->getUserModification() . ")");
  285.                         }
  286.                     }
  287.                 }
  288.             }
  289.         }
  290.     }
  292.     
  294.     /**
  295.      * Returns the level of the product so we know if it is a colour or size variant
  296.      *
  297.      * @param DataObject $dataObject
  298.      * @return integer
  299.      */
  300.     private function GetLevel(DataObject $dataObject) {
  301.         $levelCount = 0;
  302.         do {
  303.             $levelCount++;
  304.             $dataObject = $dataObject->getParent();
  305.             if ($levelCount > 5) {
  306.                 break;
  307.             }
  308.         } while ($dataObject->getType() != "folder");
  310.         return $levelCount;
  311.     }
  313.     private function GenerateSKU(DataObject $dataObject) {
  315.         $sku = "";
  316.         //$styleCode = explode(".", $dataObject->getSKU())[0];
  317.         $styleCode = $dataObject->getSKU();
  318.         if ($dataObject->getType() == "variant") {
  319.             $styleCode = $dataObject->getParent()->getSKU();
  320.         }
  322.         $sku = $styleCode;
  323.         $colourCode = $this->GetColourCode($dataObject);
  324.         $sizeCode = $this->GetSizeCode($dataObject);
  326.         if (!empty($colourCode)) {
  327.             $sku = $styleCode . "." . $colourCode;
  328.         }
  329.         if (!empty($sizeCode)) {
  330.             $sku = $sku . "." . $sizeCode;
  331.         }
  333.         if ($dataObject->getSKU() != $sku && $dataObject->getChildAmount(false) > 0) {
  334.             //Change child sku values
  335.             $this->AlterChildSKUs($dataObject, $styleCode, $colourCode);
  336.         }
  337.         $dataObject->setSKU($sku);
  338.         $dataObject->setKey($sku);
  340.         return $dataObject;
  341.     }
  343.     private function UpdateStatus(DataObject $dataObject) {
  344.         $status = "NEW";
  345.         $user = AbstractUser::getById($dataObject->getUserModification());
  346.         $userName = "system";
  347.         if (!empty($user)) {
  348.             $userName = $user->getName();
  349.         }
  351.         if (strpos($dataObject->getFullPath(), "Archive") !== false) {
  352.             $status = "ARCHIVED";
  353.         } elseif ($dataObject->getCreationDate() == $dataObject->getModificationDate() || $userName == "system") {
  354.             $status = "NEW";
  355.         } else {
  356.             if ($dataObject->getProperty("EXPORTED_PRIAM") == true) {
  357.                 $status = "CREATED";
  358.             } else {
  359.                 $status = "EDITING";
  360.             }
  361.         }
  362.         $dataObject->setStatus($status);
  363.         return $dataObject;
  364.     }
  366.     private function ClearCachedData($dataObject) {
  367.         if (!$dataObject instanceof Product) {
  371.             $class = get_class($dataObject);
  372.             $className = str_replace("Pimcore\\Model\\DataObject\\", "", $class);
  373.             $cacheKeyProvider = new CacheKeys();
  374.             $response = $cacheKeyProvider->DeleteAllKeysContainingString("selectoptions_{$className}_");
  376.             //throw new \Exception(json_encode($keyList));
  377.             $this->RecacheData($className, $class);
  378.         }
  379.     }
  381.     private function RecacheData($className, $classPath) {
  382.         if (in_array($className, ['Department', 'MainGroup', 'SubGroup', 'Collections', 'Season', 'ColourGroup', 'Size', 'Colour', 'SizeGroup', 'Brand'])) {
  383.             $cacheValues = [];
  384.             
  385.             
  386.             $objectListing = new $classPath();
  387.             $optionsProvider = new OptionsProvider();
  388.             $optionsProvider->GenerateFilteredOptions($objectListing, $className);
  389.             // $objectList = $objectListing->getList();
  390.             // $classFiltering = method_exists($objectList->current(), 'getAllowedClasses');
  391.             // $idGetter = method_exists($objectList->current(), 'get' . $className . 'ID') ? 'get' . $className . 'ID' : null;
  392.             // if (!empty($idGetter)) {
  393.             //     foreach ($objectList as $object) {
  394.             //         $cacheValues['all'][] = ["key"=>$object->getName('en_GB'), "value"=>$object->$idGetter()];
  395.             //         if ($classFiltering == true) {
  396.             //             foreach ($object->getAllowedClasses() as $allowedClass) {
  397.             //                 $cacheValues[$allowedClass->__toString()][] = ["key"=>$object->getName('en_GB'), "value"=>$object->$idGetter()];
  398.             //             }
  399.             //         }
  400.             //     }
  402.             //     $cache = new \Memcached();
  403.             //     $cache->addServer('localhost', 11211);
  404.             //     foreach ($cacheValues as $key=>$value) {
  405.             //         $escapedKey = preg_quote($key);
  406.             //         $escapedKey = str_replace(" ", "", $escapedKey);
  407.             //         //apcu_add("selectoptions_{$className}_{$escapedKey}", $value);
  408.             //         $cache->add("selectoptions_{$className}_{$escapedKey}", $value);
  409.             //         //\Pimcore\Log\Simple::log("TestEventListener", "added key: " . "selectoptions_{$className}_{$escapedKey}");
  410.             //     }
  411.             // }
  412.         }
  413.     }
  415.     private function GetClassificationStore(DataObject $dataObject) {
  416.         //$pathArray = explode("/",$dataObject->getPath());
  417.         $classifiction = [];
  418.         $classifiction[] = $dataObject->getDepartment();
  419.         $classifiction[] = $dataObject->getMainGroup();
  420.         $classifiction[] = $dataObject->getSubGroup();
  421.         //
  422.         $storeId = 1;
  423.         $groupConfig = new \Pimcore\Model\DataObject\Classificationstore\GroupConfig();
  424.         //$groupConfig->
  425.         $activeGroup = [];
  426.         foreach ($classifiction as $path) {
  427.             if (!empty($path)) {
  428.                 for ($i = 0; $collection = $groupConfig->getByName("{$path}_{$i}"); ++$i) {
  429.                     if (empty($collection)) {
  430.                         break;
  431.                     }
  432.                     $activeGroup[$collection->getId()] = true;
  433.                 }
  434.             }
  436.         }
  441.         $dataObject->getClassificationData()->setActiveGroups($activeGroup);
  442.         return $dataObject;
  443.         //$dataObject->getTestStore()-
  445.     }
  448.     private function LandedCostTable(Product $dataObject) {
  449.         try {
  450.             $landedCost = new LandedCost();
  451.             $dataObject = $landedCost->AddToHistory($dataObject);
  452.         } catch (\Exception $e) {
  454.         }
  455.         return $dataObject;
  456.     }
  458.     private function AddWholesalePrices(Product $dataObject) {
  459.         try {
  460.             $wholesaleClass = new PriceTable();
  461.             $newDataObject = $wholesaleClass->AddWholesalePrice($dataObject);
  462.             return $newDataObject;
  463.         } catch (\Exception $e) {
  464.             return $dataObject;
  465.         }
  466.     }
  468.     private function getSizeRange($product) {
  469.         //if (empty($product->getSizeGroup())) {
  470.             if (empty($product->getSize()) && empty($product->getSizeGroup())) {
  471.                 $childList = $product->getChildren([$product::OBJECT_TYPE_VARIANT]);
  472.                 $sizeList = [];
  473.                 $sizeListNames = [];
  474.                 foreach ($childList as $child) {
  475.                     $sizeName = Size::getBySizeID($child->getSize());
  476.                     if (method_exists($sizeName, 'current') && $sizeName->current() instanceof Size) {
  477.                         $sizeListNames[] = $sizeName->current()->getName();
  478.                         $sizeList[] = $child->getSize();
  479.                     }
  480.                 }
  481.                 $sizeCondition = "Size = ',";
  482.                 $sizeCondition .= implode(",", $sizeList);
  483.                 $sizeCondition .= ",'";
  486.                 $sizeListing = new \Pimcore\Model\DataObject\SizeGroup\Listing();
  487.                 $sizeListing->setCondition($sizeCondition);
  488.                 if (!empty($sizeListing->current())) {
  489.                     $product->setSizeGroup($sizeListing->current()->getName('en_GB'), 'en_GB');
  490.                     $product->setSizeGroup($sizeListing->current()->getName('en_US'), 'en_US');
  491.                 } else {
  492.                     if (empty($product->getSizeGroup())) {
  493.                         $product->setSizeGroup(implode(",", $sizeList));
  494.                     }
  495.                 }
  496.             }
  497.         //}
  498.         return $product;
  499.     }
  501.     /**
  502.      * Reviews the Fabric Composition field on an object to ensure that the percentages are correct and a fabric has not been duplicated
  503.      *
  504.      * @param Product $dataObject
  505.      * @return void
  506.      */
  507.     private function CheckMaterialPercentage(Product $dataObject) {
  508.         $materialComp = $dataObject->getFabricComposition();
  509.         $materialArray = [];
  510.         $percentage = 0;
  511.         if (is_iterable($materialComp)) {
  512.             foreach ($materialComp as $material) {
  513.                 $percentage += $material->getPercentage();
  514.                 if (key_exists($material->getFabric(), $materialArray)) {
  515.                     throw new \Exception("You have duplicated a fabric in the Fabric Composition field.");
  516.                 }
  517.                 $materialArray[$material->getFabric()] = 1;
  518.                 if ($percentage > 100) {
  519.                     throw new \Exception("The cumulative percentage of your Fabric Composition field is greater than 100%. Please correct your percentages to continue.");
  520.                 }
  521.             }
  522.             if ($percentage > 0 && $percentage < 100) {
  523.                 throw new \Exception("Your Fabric Composition adds up to $percentage%. Please ensure this equals 100% before continuing.");
  524.             }
  525.         }
  527.     }
  529.     /**
  530.      * Moves a product to the correct folder
  531.      *
  532.      * Changes may be made if a product has been archived or department/maingroup/subgroup is modified
  533.      *
  534.      * @param DataObject $dataObject
  535.      * @return DataObject
  536.      */
  537.     private function MoveObject(DataObject $dataObject) {
  538.         
  539.         $dataObject = $this->GetParentFromAttributes($dataObject);
  540.         $properties = $dataObject->getProperties();
  541.         foreach ($properties as $property) {
  542.             if ($property->getName() == "ARCHIVED") {
  543.                 if ($property->getData() == true) {
  544.                     $parentDirectory = $this->GetArchivePath((string) $dataObject->getParent());
  545.                 } else {
  546.                     $parentDirectory = $this->GetNonArchivePath((string) $dataObject->getParent());
  547.                 }
  549.                 if ($parentDirectory instanceof DataObject && $parentDirectory->getType() == "folder") {
  550.                     $dataObject->setParent($parentDirectory);
  551.                     return $dataObject;
  552.                 }
  553.             }
  554.         }
  555.         return $dataObject;
  556.     }
  558.     private function GetParentFromAttributes(DataObject $dataObject) {
  559.         $path = "/Products";
  560.         
  561.         try {
  562.             if (!empty($dataObject->getDepartment()) && !empty($dataObject->getMainGroup()) && !empty($dataObject->getSubGroup())) {
  563.                 
  564.                 $departmentObject = Department::getByDepartmentID($dataObject->getDepartment());
  565.                 $maingroupObject = MainGroup::getByMainGroupID($dataObject->getMainGroup());
  566.                 $subgroupObject = SubGroup::getBySubGroupID($dataObject->getSubGroup());
  568.                 
  569.                 
  570.                 if (method_exists($departmentObject, "current") && method_exists($maingroupObject, "current") && method_exists($subgroupObject, "current")) {
  571.                     $path .= "/" . $departmentObject->current()->getName();
  572.                     $path .= "/" . $maingroupObject->current()->getName();
  573.                     $path .= "/" . $subgroupObject->current()->getName();     
  575.                     $object = new DataObject();
  576.                     $parentObject = $object->getByPath($path);
  577.                     if ($parentObject instanceof DataObject && $parentObject->getType() == "folder") {
  578.                         $dataObject->setParent($parentObject);
  579.                     }                   
  580.                 }
  581.             }
  582.         } catch (\Exception $e) {
  583.             die($e->getMessage());
  584.         }
  586.         return $dataObject;
  588.     }
  590.     /**
  591.      * Retrieves the archive path at the correct level given the passed directory structure
  592.      *
  593.      * @param string $path
  594.      * @param integer $archiveDepth
  595.      * @return DataObject
  596.      */
  597.     private function GetArchivePath($path, $archiveDepth = 2) {
  598.         $explodedPath = explode("/", $path);
  599.         $archiveSections = [];
  600.         foreach ($explodedPath as $key=>$value) {
  601.             $archiveSections[] = $value;
  602.             if ($key == $archiveDepth) {
  603.                 $archiveSections[] = "Archive";
  604.             }
  606.         }
  607.         $archivePath = implode("/", $archiveSections);
  608.         $dataObject = new DataObject();
  609.         return $dataObject->getByPath($archivePath);
  610.     }
  612.     private function GetNonArchivePath($path) {
  613.         $path = str_replace("/Archive", "", $path);
  614.         $dataObject = new DataObject();
  615.         return $dataObject->getByPath($path);
  616.     }
  620.     private function GeneratePriamExport(DataObject $dataObject) {
  621.         if ($dataObject->isPublished()) {
  622.             if (get_class($dataObject) == "Pimcore\Model\DataObject\Colour") {
  623.                 $dirPath = $this->params->get('priam_export_colour');
  624.                 $fileName = "interface_import_colours_".date("YmdHis").".csv";
  625.                 $data = [
  626.                     ['Season_identifier', 'Colour_identifier', 'Description', 'Short_description'],
  627.                     [null, $dataObject->getColourID(), $dataObject->getName(), null]
  628.                 ];
  629.             } else if (get_class($dataObject) == "Pimcore\Model\DataObject\Size") {
  630.                 $dirPath = $this->params->get('priam_export_size');
  631.                 $fileName = "interface_import_sizes_".date("YmdHis").".csv";
  632.                 $data = [
  633.                     ['Size_code', 'Description', 'Short_description'],
  634.                     [$dataObject->getSizeID(), $dataObject->getName(), null]
  635.                 ];
  636.             }
  637.             $fp = fopen($dirPath . "/" . $fileName, 'w+');
  638.             foreach ($data as $fields) {
  639.                 fputcsv($fp, $fields);
  640.             }
  641.             fclose($fp);
  642.         }
  643.     }
  645.     private function CreateERPItem($dataObject) {
  648.         $erpId = $dataObject->getProperty("erp_id");
  649.         if (empty($erpId)) {
  651.             $curl = curl_init();
  653.             $params = [
  654.                 'ref'=>$dataObject->getSKU(),
  655.                 'label'=>$dataObject->getTitle(),
  656.                 'description'=>$dataObject->getDescription(),
  657.                 'price'=>$dataObject->getPricingCost()
  658.             ];
  660.             curl_setopt_array($curl, array(
  661.             CURLOPT_URL => 'http://erp.thebroady.co.uk/api/index.php/products',
  662.             CURLOPT_RETURNTRANSFER => true,
  663.             CURLOPT_ENCODING => '',
  664.             CURLOPT_MAXREDIRS => 10,
  665.             CURLOPT_TIMEOUT => 0,
  666.             CURLOPT_FOLLOWLOCATION => true,
  667.             CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  668.             CURLOPT_CUSTOMREQUEST => 'POST',
  669.             CURLOPT_POSTFIELDS => http_build_query($params),
  670.             CURLOPT_HTTPHEADER => array(
  671.                 'DOLAPIKEY: b8eiW04DlZt3Pgp3MAu2n5GFD4CfE02d',
  672.                 'Content-Type: application/x-www-form-urlencoded'
  673.             ),
  674.             ));
  676.             $response = curl_exec($curl);
  678.             curl_close($curl);
  680.             $dataObject->setProperty("erp_id","Text",$response);
  681.         }
  684.     }
  686.     /**
  687.      * Renames image paths to become the same as the object
  688.      *
  689.      * @param DataObject $dataObject
  690.      * @param Asset $image
  691.      * @return Asset
  692.      */
  693.     private function ChangeImagePaths($dataObject, $image) {
  695.         $assetFolder = $this->DoesAssetFolderExist($dataObject);
  696.         $image->setParent($assetFolder);
  697.         return $image;
  698.     }
  700.     private function SaveAsset(Asset\Image $image) {
  701.         $fullPath = $image->getParent()->getfullPath() . "/" . $image->getFilename();
  702.         $existingAsset = Asset::getByPath($fullPath);
  703.         if ($existingAsset instanceof Asset) {
  704.             $existingData = $existingAsset->getData();
  705.             $imageData = $image->getData();
  706.             if ($existingAsset->getData() == $image->getData()) {
  707.                 $image->save();
  708.                 // The existing image is the same as the one being uploaded
  709.             } else {
  710.                 $pathInfo = pathinfo($image->getFilename());
  711.                 $image->setFilename("0_" . $pathInfo['filename'] . "." . $pathInfo['extension']);
  712.                 $image->save();
  713.             }
  714.         } else {
  715.             $image->save();
  716.         }
  717.     }
  719.     /**
  720.      * Add metadata from the product to the image
  721.      *
  722.      * @param Product $dataObject
  723.      * @return void
  724.      */
  725.     private function AddImageMetaDataAndChangePath(Product $dataObject) {
  726.         $images = $dataObject->getImages();
  727.         foreach ($images as $hotspotImage) {
  728.             if (!empty($hotspotImage)) {
  729.                 $image = $hotspotImage->getImage();
  730.                 if (!empty($image) && is_object($image)) {
  731.                     if (method_exists($image, "addMetadata")) {
  732.                         $image = $this->AddImageMetaData($image, $dataObject);
  733.                         $image = $this->ChangeImagePaths($dataObject, $image);
  734.                         
  735.                         $this->SaveAsset($image);
  736.                     }
  737.                 }
  738.             }
  739.         }
  740.         $mannequin = $dataObject->getMannequinShot();
  741.         foreach ($mannequin as $hotspotImage) {
  742.             if (!empty($hotspotImage)) {
  743.                 $image = $hotspotImage->getImage();
  744.                 if (!empty($image) && is_object($image)) {
  745.                     if (method_exists($image, "addMetadata")) {
  746.                         $image = $this->AddImageMetaData($image, $dataObject, false, true);
  747.                         $image = $this->ChangeImagePaths($dataObject, $image);
  748.                         $image->save();
  749.                     }
  750.                 }
  751.             }
  752.         }
  753.         $cad = $dataObject->getCad();
  754.         if (!empty($cad) && is_object($cad) && method_exists($cad, "addMetadata")) {
  755.             $cad = $this->AddImageMetaData($cad, $dataObject, true);
  756.             $cad = $this->ChangeImagePaths($dataObject, $cad);
  757.             //$cad->save();
  758.         }
  759.     }
  761.     private function AddImageMetaData($image, $dataObject, $cad = false, $mannequin = false) {
  762.         if ($cad == true) {
  763.             $image->addMetadata("cad", "checkbox", true);
  764.         }
  765.         if ($mannequin == true) {
  766.             $image->addMetadata("mannequin", "checkbox", true);
  767.         }
  768.         $image->addMetadata("linked_item", "object", $dataObject);
  769.         $image->addMetadata("collection", "input", $this->GetDropdownValue('Collections', $this->GetInheritedField($dataObject, 'Collection')));
  770.         $image->addMetadata("department", "input", $this->GetDropdownValue('Department', $this->GetInheritedField($dataObject, 'Department')));
  771.         $image->addMetadata("maingroup", "input", $this->GetDropdownValue('MainGroup', $this->GetInheritedField($dataObject, 'MainGroup')));
  772.         $image->addMetadata("subgroup", "input", $this->GetDropdownValue('SubGroup', $this->GetInheritedField($dataObject, 'SubGroup')));
  773.         //$image->addMetadata("sustainable", "input", $this->GetInheritedField($dataObject, 'Sustainable'));
  774.         //$image->addMetadata("brand", "input", $this->GetInheritedField($dataObject, 'Brand'));
  775.         if ($dataObject->getType() == "object") {
  776.             $image->addMetadata("mpn", "input", $dataObject->getSKU());
  777.         } else if (empty($dataObject->getSize())) {
  778.             $parent = $dataObject->getParent();
  779.             $image->addMetadata("mpn", "input", $parent->getSKU());
  780.             $image->addMetadata("msn", "input", $dataObject->getSKU());
  781.             $image->addMetadata("colour", "input", $this->GetDropdownValue('Colour', $dataObject->getColour()));
  782.             $image->addMetadata("colourgroup", "input", $dataObject->getColourGroup());
  783.             $image->addMetadata("season", "input", $this->GetDropdownValue('Season', $this->GetInheritedField($dataObject, 'Season')));
  784.         }
  786.         return $image;
  787.     }
  789.     /**
  790.      * Gets the value of the select option
  791.      *
  792.      * This is required as selected values are often other objects within Pimcore. Due to the additional filtering of options we've used I also have to get the values from our custom class
  793.      *
  794.      * @param string $field Classname
  795.      * @param string $id The ID field that we need to search for
  796.      * @return string
  797.      */
  798.     private function GetDropdownValue($field, $id) {
  800.         //$selectOptions = new \App\Controller\Selects\SelectOptions();
  801.         $selectOptions = new OptionsProvider();
  802.         $valuesSingle = $selectOptions->GetAllOptions("Pimcore\\Model\\DataObject\\$field", $field, "en_GB");
  803.         if (is_object($valuesSingle) || is_array($valuesSingle)) {
  804.             foreach ($valuesSingle as $values) {
  805.                 if ($values['value'] == $id) {
  806.                     return $values['key'];
  807.                 }
  808.             }
  809.         }
  811.         return $id;
  812.     }
  814.     /**
  815.      * Change the child SKU values upon a colour change
  816.      *
  817.      * @param AbstractObject $dataObject
  818.      * @return void
  819.      */
  820.     private function AlterChildSKUs($dataObject, $styleCode, $colourCode) {
  821.         $children = $dataObject->getChildren([DataObject::OBJECT_TYPE_VARIANT]);
  822.         foreach ($children as $child) {
  823.             $sizeCode = $this->GetSizeCode($child);
  824.             if (!empty($sizeCode)) {
  825.                 $child->setSKU($styleCode. "." .$colourCode . "." .$sizeCode);
  826.                 $child->setKey($styleCode. "." .$colourCode . "." .$sizeCode);
  827.                 $child->save();
  828.             }
  829.         }
  830.     }
  832.     /**
  833.      * Checks for a path matching your product path. If non exists your path is created.
  834.      *
  835.      * The path will be cleaned from the SKU fields and if Archive is stated this will also be removed.
  836.      *
  837.      * @param Product $dataObject
  838.      * @return Asset\Folder
  839.      */
  840.     private function DoesAssetFolderExist($dataObject) {
  842.         //structure based on dept-collection-colour
  843.         $assetStructure = ['Products'];
  844.         $dataObject->setGetInheritedValues(true);
  845.         if (!empty($dataObject->getDepartment())) {
  846.             $departmentObject = Department::getByDepartmentID($dataObject->getDepartment());
  847.             if (method_exists($departmentObject, 'current') && !empty($departmentObject->current())) {
  848.                 $assetStructure[] = str_replace("/", "-", $departmentObject->current()->getName());
  849.                 if (!empty($dataObject->getCollection())) {
  850.                     $collectionObject = Collections::getByCollectionsID($dataObject->getCollection());
  851.                     if (method_exists($collectionObject, 'current') && !empty($collectionObject->current())) {
  852.                         $assetStructure[] = str_replace("/", "-", $collectionObject->current()->getName());
  853.                         if (!empty($dataObject->getColour())) {
  854.                             $colourObject = Colour::getByColourID($dataObject->getColour());
  855.                             if (method_exists($colourObject, 'current') && !empty($colourObject->current())) {
  856.                                 $assetStructure[] = str_replace("/", "-", $colourObject->current()->getName());
  857.                             }
  858.                         }
  859.                     }
  860.                 }
  861.             }
  862.         }
  864.         $fullPath = '/' . implode('/', $assetStructure);
  865.         $folderExists = Asset\Service::pathExists($fullPath);
  866.         if ($folderExists == false) {
  867.             return Asset\Service::createFolderByPath($fullPath);
  868.         } else {
  869.             return Asset\Service::getElementByPath('asset', $fullPath);
  870.         }
  874.         // $objectPath = $dataObject->__toString();
  875.         // $replaceValues = ["/Archive"];
  876.         // switch ($dataObject->getType()) {
  877.         //     case "variant":
  878.         //         $replaceValues[] = "/".$dataObject->getSKU();
  879.         //         $dataObject = $dataObject->getParent();
  880.         //     case "object":
  881.         //         $replaceValues[] = "/".$dataObject->getSKU();
  882.         // }
  885.         // $cleanPath = str_replace($replaceValues, "", $objectPath);
  886.         // $folderExists = Asset\Service::pathExists($cleanPath);
  887.         // if ($folderExists == false) {
  888.         //     return Asset\Service::createFolderByPath($cleanPath);
  889.         // } else {
  890.         //     return Asset\Service::getElementByPath('asset', $cleanPath);
  891.         // }
  892.     }
  894.     private function GenerateChildrenOnTemplateSizes($dataObject) {
  895.         $dataObject = $this->RefreshObject($dataObject);
  896.         $brick = $dataObject->getSizeGenerator();
  897.         if (!empty($brick->getSizeGen()->getGroupedSize())) {
  898.             foreach ($brick->getSizeGen()->getGroupedSize() as $groupedSize) {
  899.                 $sizeGroupListing = new DataObject\SizeGroup\Listing();
  900.                 $sizeGroupFilter = $sizeGroupListing->filterBySizeGroupID($groupedSize);
  901.                 foreach ($sizeGroupFilter as $filteredValue) {
  902.                     foreach ($filteredValue->getCupSizes() as $cupSize) {
  903.                         foreach ($filteredValue->getBackSizes() as $backSize) {
  904.                             $filterResult = $this->GetExistingSize($cupSize, $backSize);
  905.                             foreach ($filterResult as $result) {
  906.                                 $this->CreateVariant($dataObject, $result, 'size');
  907.                             }
  908.                         }
  909.                     }
  911.                 }
  912.             }
  913.         } else if (!empty($brick->getSizeGen()->getCupSizes())) {
  914.             foreach ($brick->getSizeGen()->getCupSizes() as $cupSize) {
  915.                 foreach ($brick->getSizeGen()->getBackSizes() as $backSize) {
  916.                     $filterResult = $this->GetExistingSize($cupSize, $backSize);
  917.                     foreach ($filterResult as $result) {
  918.                         $this->CreateVariant($dataObject, $result, 'size');
  919.                     }
  920.                 }
  922.             }
  924.         }
  926.     }
  928.     private function GetExistingSize($cupSize, $backSize) {
  929.         $entries = new DataObject\Size\Listing();
  930.         $cupSizeName = strtoupper(str_replace(['cup','_'],'',$cupSize));
  931.         $backSizeName = strtoupper(str_replace(['back','_'],'',$backSize));
  933.         $filterResult=$entries->setCondition("name LIKE ?", [$backSizeName.$cupSizeName]);
  934.         return $filterResult;
  935.     }
  937.     /**
  938.      * Change the child SKU values upon a colour change
  939.      *
  940.      * @param AbstractObject $dataObject
  941.      * @param AbstractObject $variationObject
  942.      * @param string $variationType
  943.      * @return void
  944.      */
  945.     private function CreateVariant($dataObject, $variationObject, $variationType) {
  947.         if ($variationType == "size") {
  948.             if (!empty($dataObject) && !$this->DoesChildExist($dataObject, $dataObject->getKey().".".$variationObject->getSizeID())) {
  950.                 $objectX = new Product();
  951.                 $objectX->setParent($dataObject);
  952.                 $objectX->setKey($dataObject->getKey().".".$variationObject->getSizeID());
  953.                 $objectX->setSKU($dataObject->getKey().".".$variationObject->getSizeID());
  954.                 $objectX->setSize($variationObject->getName());
  955.                 $objectX->setType(DataObject::OBJECT_TYPE_VARIANT);
  956.                 $objectX->save();
  957.             }
  959.         }
  960.     }
  962.     private function RefreshObject($object) {
  963.         $dataObject = new DataObject();
  964.         $refreshedObject = $dataObject->getById($object->getId());
  965.         return $refreshedObject;
  966.     }
  968.     private function DoesChildExist($parentObject, $childKey) {
  969.         $children = $parentObject->getChildren([DataObject::OBJECT_TYPE_VARIANT], true);
  971.         foreach ($children as $child) {
  972.             if (!empty($child) && $child->getKey() == $childKey) {
  973.                 return true;
  974.             }
  975.         }
  976.         return false;
  977.     }
  979.     /**
  980.      * Gets the colour object from the given data object
  981.      *
  982.      * If the colour can not be identified against this variaition product it will have a look at the parent to see if the value has been filled out.
  983.      * This has to be done as variant inheritance does not allow the values to be retrieved through the API
  984.      *
  985.      * @param AbstractObject $dataObject
  986.      * @return string
  987.      */
  988.     private function GetColourCode($dataObject) {
  989.         try {
  990.             if (!empty($dataObject->getColour())) {
  991.                 if (is_string($dataObject->getColour()) || is_integer($dataObject->getColour())) {
  992.                     return $dataObject->getColour();
  993.                 } else if (!empty($dataObject->getColour()->getColourBrick())) {
  994.                     return $dataObject->getColour()->getColourBrick()->getColour();
  995.                 }
  996.             } else if (!empty($dataObject->getParent()->getColour())) {
  997.                 if (is_string($dataObject->getParent()->getColour()) || is_integer($dataObject->getParent()->getColour())) {
  998.                     return $dataObject->getParent()->getColour();
  999.                 }
  1000.             }
  1001.         } catch (\Exception $e) {
  1003.         }
  1004.     }
  1006.     /**
  1007.      * Gets the string code for the given product
  1008.      *
  1009.      * @param AbstractObject $dataObject
  1010.      * @return string
  1011.      */
  1012.     private function GetSizeCode($dataObject) {
  1013.         try {
  1014.             if (!empty($dataObject->getSize())) {
  1015.                 if (is_string($dataObject->getSize()) || is_integer($dataObject->getSize())) {
  1016.                     return $dataObject->getSize();
  1017.                 } else if (!empty($dataObject->getSize()->getSizeBrick())) {
  1018.                     return $dataObject->getSize()->getSizeBrick()->getSize();
  1019.                 }
  1020.             }
  1022.         } catch (\Exception $e) {
  1024.         }
  1025.     }
  1027.     private function GetBaseFolder($parentPath) {
  1028.         $baseFolder = explode("/", $parentPath);
  1029.         if (count($baseFolder) >= 2) {
  1030.             return $baseFolder[1];
  1031.         }
  1032.     }
  1034.     private function GetParentKey($parentPath) {
  1035.         $pathParts = explode("/", $parentPath);
  1036.         if (count($pathParts) >= 1) {
  1037.             return $pathParts[count($pathParts)-1];
  1038.         }
  1039.     }
  1041.     private function fieldExists($dataObject, $field) {
  1042.         try {
  1043.             $function = "get".$field;
  1044.             $dataObject->$function();
  1045.             return true;
  1046.         } catch (\Exception $e) {
  1047.             return false;
  1048.         }
  1049.     }
  1051. }