vendor/pimcore/pimcore/bundles/EcommerceFrameworkBundle/IndexService/Config/AbstractConfig.php line 349

Open in your IDE?
  1. <?php
  3. /**
  4.  * Pimcore
  5.  *
  6.  * This source file is available under two different licenses:
  7.  * - GNU General Public License version 3 (GPLv3)
  8.  * - Pimcore Commercial License (PCL)
  9.  * Full copyright and license information is available in
  10.  * LICENSE.md which is distributed with this source code.
  11.  *
  12.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  13.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  14.  */
  16. namespace Pimcore\Bundle\EcommerceFrameworkBundle\IndexService\Config;
  18. use Pimcore\Bundle\EcommerceFrameworkBundle\IndexService\Config\Definition\Attribute;
  19. use Pimcore\Bundle\EcommerceFrameworkBundle\IndexService\Worker\WorkerInterface;
  20. use Pimcore\Bundle\EcommerceFrameworkBundle\Model\AbstractCategory;
  21. use Pimcore\Bundle\EcommerceFrameworkBundle\Model\IndexableInterface;
  22. use Pimcore\Config\Config;
  23. use Pimcore\Model\DataObject;
  25. abstract class AbstractConfig implements ConfigInterface
  26. {
  27.     /**
  28.      * @var string
  29.      */
  30.     protected $tenantName;
  32.     /**
  33.      * @var array
  34.      */
  35.     protected $attributeConfig;
  37.     /**
  38.      * @var array
  39.      */
  40.     protected $searchAttributeConfig;
  42.     /**
  43.      * @var AttributeFactory
  44.      */
  45.     protected $attributeFactory;
  47.     /**
  48.      * @var Attribute[]
  49.      */
  50.     protected $attributes;
  52.     /**
  53.      * @var array
  54.      */
  55.     protected $searchAttributes;
  57.     /**
  58.      * @var array
  59.      */
  60.     protected $filterTypes;
  62.     /**
  63.      * @var WorkerInterface
  64.      */
  65.     protected $tenantWorker;
  67.     /**
  68.      * @var array|null
  69.      */
  70.     protected $filterTypeConfig;
  72.     /**
  73.      * @var array
  74.      */
  75.     protected $options;
  77.     /**
  78.      * @param string $tenantName
  79.      * @param array[]|Attribute[] $attributes
  80.      * @param array $searchAttributes
  81.      * @param array $filterTypes
  82.      * @param array $options
  83.      */
  84.     public function __construct(
  85.         string $tenantName,
  86.         array $attributes,
  87.         array $searchAttributes,
  88.         array $filterTypes,
  89.         array $options = []
  90.     ) {
  91.         $this->tenantName = $tenantName;
  93.         $this->attributeConfig = $attributes;
  94.         $this->searchAttributeConfig = $searchAttributes;
  96.         $this->filterTypes = $filterTypes;
  97.         $this->processOptions($options);
  98.     }
  100.     /**
  101.      * Attribute configuration
  102.      *
  103.      * @return array
  104.      */
  105.     public function getAttributeConfig()
  106.     {
  107.         return $this->attributeConfig;
  108.     }
  110.     /**
  111.      * Sets attribute factory as dependency. This was added as setter for BC reasons and will be added to the constructor
  112.      * signature in Pimcore 10.
  113.      *
  114.      * TODO Pimcore 10 add to constructor signature.
  115.      *
  116.      * @required
  117.      *
  118.      * @param AttributeFactory $attributeFactory
  119.      */
  120.     public function setAttributeFactory(AttributeFactory $attributeFactory)
  121.     {
  122.         if (null !== $this->attributeFactory) {
  123.             throw new \RuntimeException('Attribute factory is already set.');
  124.         }
  126.         $this->attributeFactory = $attributeFactory;
  128.         $this->attributes = [];
  129.         $this->searchAttributes = [];
  131.         $this->buildAttributes($this->attributeConfig);
  133.         foreach ($this->searchAttributeConfig as $searchAttribute) {
  134.             $this->addSearchAttribute($searchAttribute);
  135.         }
  136.     }
  138.     protected function buildAttributes(array $attributes)
  139.     {
  140.         foreach ($attributes as $attribute) {
  141.             if ($attribute instanceof Attribute) {
  142.                 $this->addAttribute($attribute);
  143.             } elseif (is_array($attribute)) {
  144.                 $attribute = $this->attributeFactory->createAttribute($attribute);
  145.                 $this->addAttribute($attribute);
  146.             } else {
  147.                 throw new \InvalidArgumentException(sprintf(
  148.                     'Wrong type for attribute. Expected Attribute or array, got "%s"',
  149.                     is_object($attribute) ? get_class($attribute) : gettype($attribute)
  150.                 ));
  151.             }
  152.         }
  153.     }
  155.     protected function addAttribute(Attribute $attribute)
  156.     {
  157.         $this->attributes[$attribute->getName()] = $attribute;
  158.     }
  160.     protected function addSearchAttribute(string $searchAttribute)
  161.     {
  162.         if (!isset($this->attributes[$searchAttribute])) {
  163.             throw new \InvalidArgumentException(sprintf(
  164.                 'The search attribute "%s" in product index tenant "%s" is not defined as attribute',
  165.                 $searchAttribute,
  166.                 $this->tenantName
  167.             ));
  168.         }
  170.         $this->searchAttributes[] = $searchAttribute;
  171.     }
  173.     protected function processOptions(array $options)
  174.     {
  175.         // noop - to implemented by configs supporting options
  176.     }
  178.     /**
  179.      * {@inheritdoc}
  180.      */
  181.     public function setTenantWorker(WorkerInterface $tenantWorker)
  182.     {
  183.         $this->checkTenantWorker($tenantWorker);
  184.         $this->tenantWorker = $tenantWorker;
  185.     }
  187.     /**
  188.      * Checks if tenant worker matches prerequisites (config wrapped in worker is this instance and instance has no
  189.      * worker set yet).
  190.      *
  191.      * @param WorkerInterface $tenantWorker
  192.      */
  193.     protected function checkTenantWorker(WorkerInterface $tenantWorker)
  194.     {
  195.         if (null !== $this->tenantWorker) {
  196.             throw new \LogicException(sprintf('Worker for tenant "%s" is already set', $this->tenantName));
  197.         }
  199.         // make sure the worker is the one working on this config instance
  200.         if ($tenantWorker->getTenantConfig() !== $this) {
  201.             throw new \LogicException('Worker config does not match the config the worker is about to be set to');
  202.         }
  203.     }
  205.     /**
  206.      * {@inheritdoc}
  207.      */
  208.     public function getTenantWorker()
  209.     {
  210.         // the worker is expected to call setTenantWorker as soon as possible
  211.         if (null === $this->tenantWorker) {
  212.             throw new \RuntimeException('Tenant worker is not set.');
  213.         }
  215.         return $this->tenantWorker;
  216.     }
  218.     /**
  219.      * @return string
  220.      */
  221.     public function getTenantName()
  222.     {
  223.         return $this->tenantName;
  224.     }
  226.     /**
  227.      * Returns configured attributes for product index
  228.      *
  229.      * @return Attribute[]
  230.      */
  231.     public function getAttributes(): array
  232.     {
  233.         // TODO Pimcore 10 remove as soon as attribute factory was added to the constructor.
  234.         if (null === $this->attributes) {
  235.             throw new \RuntimeException('Attributes are not built yet. Is the service properly configured to set an attribute factory?');
  236.         }
  238.         return $this->attributes;
  239.     }
  241.     /**
  242.      * Returns full text search index attribute names for product index
  243.      *
  244.      * @return array
  245.      */
  246.     public function getSearchAttributes(): array
  247.     {
  248.         // TODO Pimcore 10 remove as soon as attribute factory was added to the constructor.
  249.         if (null === $this->attributes) {
  250.             throw new \RuntimeException('Search attributes are not built yet. Is the service properly configured to set an attribute factory?');
  251.         }
  253.         return $this->searchAttributes;
  254.     }
  256.     /**
  257.      * return all supported filter types for product index
  258.      *
  259.      * @return array|null
  260.      */
  261.     public function getFilterTypeConfig()
  262.     {
  263.         return $this->filterTypeConfig;
  264.     }
  266.     /**
  267.      * @param IndexableInterface $object
  268.      *
  269.      * @return bool
  270.      */
  271.     public function isActive(IndexableInterface $object)
  272.     {
  273.         return true;
  274.     }
  276.     /**
  277.      * @param IndexableInterface $object
  278.      * @param int|null $subObjectId
  279.      *
  280.      * @return AbstractCategory[]
  281.      */
  282.     public function getCategories(IndexableInterface $object, $subObjectId = null)
  283.     {
  284.         return $object->getCategories();
  285.     }
  287.     /**
  288.      * creates an array of sub ids for the given object
  289.      * use that function, if one object should be indexed more than once (e.g. if field collections are in use)
  290.      *
  291.      * @param IndexableInterface $object
  292.      *
  293.      * @return IndexableInterface[]
  294.      */
  295.     public function createSubIdsForObject(IndexableInterface $object)
  296.     {
  297.         return [$object->getId() => $object];
  298.     }
  300.     /**
  301.      * checks if there are some zombie subIds around and returns them for cleanup
  302.      *
  303.      * @param IndexableInterface $object
  304.      * @param array $subIds
  305.      *
  306.      * @return array
  307.      */
  308.     public function getSubIdsToCleanup(IndexableInterface $object, array $subIds)
  309.     {
  310.         return [];
  311.     }
  313.     /**
  314.      * creates virtual parent id for given sub id
  315.      * default is getOSParentId
  316.      *
  317.      * @param IndexableInterface $object
  318.      * @param int $subId
  319.      *
  320.      * @return int|string|null
  321.      */
  322.     public function createVirtualParentIdForSubId(IndexableInterface $object, $subId)
  323.     {
  324.         return $object->getOSParentId();
  325.     }
  327.     /**
  328.      * Gets object by id, can consider subIds and therefore return e.g. an array of values
  329.      * always returns object itself - see also getObjectMockupById
  330.      *
  331.      * @param int $objectId
  332.      * @param bool $onlyMainObject - only returns main object
  333.      *
  334.      * @return DataObject|null
  335.      */
  336.     public function getObjectById($objectId, $onlyMainObject = false)
  337.     {
  338.         return DataObject::getById($objectId);
  339.     }
  341.     /**
  342.      * Gets object mockup by id, can consider subIds and therefore return e.g. an array of values
  343.      * always returns a object mockup if available
  344.      *
  345.      * @param int $objectId
  346.      *
  347.      * @return IndexableInterface|null
  348.      */
  349.     public function getObjectMockupById($objectId)
  350.     {
  351.         $object = $this->getObjectById($objectId);
  352.         if ($object instanceof IndexableInterface) {
  353.             return $object;
  354.         }
  356.         return null;
  357.     }
  359.     /**
  360.      * returns column type for id
  361.      *
  362.      * @param bool $isPrimary
  363.      *
  364.      * @return string
  365.      */
  366.     public function getIdColumnType($isPrimary)
  367.     {
  368.         if ($isPrimary) {
  369.             return "int(11) NOT NULL default '0'";
  370.         } else {
  371.             return 'int(11) NOT NULL';
  372.         }
  373.     }
  374. }