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

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\Model\DataObject;
  24. abstract class AbstractConfig implements ConfigInterface
  25. {
  26.     /**
  27.      * @var string
  28.      */
  29.     protected $tenantName;
  31.     /**
  32.      * @var array
  33.      */
  34.     protected $attributeConfig;
  36.     /**
  37.      * @var array
  38.      */
  39.     protected $searchAttributeConfig;
  41.     /**
  42.      * @var AttributeFactory
  43.      */
  44.     protected $attributeFactory;
  46.     /**
  47.      * @var Attribute[]
  48.      */
  49.     protected $attributes;
  51.     /**
  52.      * @var array
  53.      */
  54.     protected $searchAttributes;
  56.     /**
  57.      * @var array
  58.      */
  59.     protected $filterTypes;
  61.     /**
  62.      * @var WorkerInterface
  63.      */
  64.     protected $tenantWorker;
  66.     /**
  67.      * @var array|null
  68.      */
  69.     protected $filterTypeConfig;
  71.     /**
  72.      * @var array
  73.      */
  74.     protected $options;
  76.     /**
  77.      * @param string $tenantName
  78.      * @param array[]|Attribute[] $attributes
  79.      * @param array $searchAttributes
  80.      * @param array $filterTypes
  81.      * @param array $options
  82.      */
  83.     public function __construct(
  84.         string $tenantName,
  85.         array $attributes,
  86.         array $searchAttributes,
  87.         array $filterTypes,
  88.         array $options = []
  89.     ) {
  90.         $this->tenantName = $tenantName;
  92.         $this->attributeConfig = $attributes;
  93.         $this->searchAttributeConfig = $searchAttributes;
  95.         $this->filterTypes = $filterTypes;
  96.         $this->processOptions($options);
  97.     }
  99.     /**
  100.      * Attribute configuration
  101.      *
  102.      * @return array
  103.      */
  104.     public function getAttributeConfig()
  105.     {
  106.         return $this->attributeConfig;
  107.     }
  109.     /**
  110.      * Sets attribute factory as dependency. This was added as setter for BC reasons and will be added to the constructor
  111.      * signature in Pimcore 10.
  112.      *
  113.      * TODO Pimcore 10 add to constructor signature.
  114.      *
  115.      * @required
  116.      *
  117.      * @param AttributeFactory $attributeFactory
  118.      */
  119.     public function setAttributeFactory(AttributeFactory $attributeFactory)
  120.     {
  121.         if (null !== $this->attributeFactory) {
  122.             throw new \RuntimeException('Attribute factory is already set.');
  123.         }
  125.         $this->attributeFactory = $attributeFactory;
  127.         $this->attributes = [];
  128.         $this->searchAttributes = [];
  130.         $this->buildAttributes($this->attributeConfig);
  132.         foreach ($this->searchAttributeConfig as $searchAttribute) {
  133.             $this->addSearchAttribute($searchAttribute);
  134.         }
  135.     }
  137.     protected function buildAttributes(array $attributes)
  138.     {
  139.         foreach ($attributes as $attribute) {
  140.             if ($attribute instanceof Attribute) {
  141.                 $this->addAttribute($attribute);
  142.             } elseif (is_array($attribute)) {
  143.                 $attribute = $this->attributeFactory->createAttribute($attribute);
  144.                 $this->addAttribute($attribute);
  145.             } else {
  146.                 throw new \InvalidArgumentException(sprintf(
  147.                     'Wrong type for attribute. Expected Attribute or array, got "%s"',
  148.                     is_object($attribute) ? get_class($attribute) : gettype($attribute)
  149.                 ));
  150.             }
  151.         }
  152.     }
  154.     protected function addAttribute(Attribute $attribute)
  155.     {
  156.         $this->attributes[$attribute->getName()] = $attribute;
  157.     }
  159.     protected function addSearchAttribute(string $searchAttribute)
  160.     {
  161.         if (!isset($this->attributes[$searchAttribute])) {
  162.             throw new \InvalidArgumentException(sprintf(
  163.                 'The search attribute "%s" in product index tenant "%s" is not defined as attribute',
  164.                 $searchAttribute,
  165.                 $this->tenantName
  166.             ));
  167.         }
  169.         $this->searchAttributes[] = $searchAttribute;
  170.     }
  172.     protected function processOptions(array $options)
  173.     {
  174.         // noop - to implemented by configs supporting options
  175.     }
  177.     /**
  178.      * {@inheritdoc}
  179.      */
  180.     public function setTenantWorker(WorkerInterface $tenantWorker)
  181.     {
  182.         $this->checkTenantWorker($tenantWorker);
  183.         $this->tenantWorker = $tenantWorker;
  184.     }
  186.     /**
  187.      * Checks if tenant worker matches prerequisites (config wrapped in worker is this instance and instance has no
  188.      * worker set yet).
  189.      *
  190.      * @param WorkerInterface $tenantWorker
  191.      */
  192.     protected function checkTenantWorker(WorkerInterface $tenantWorker)
  193.     {
  194.         if (null !== $this->tenantWorker) {
  195.             throw new \LogicException(sprintf('Worker for tenant "%s" is already set', $this->tenantName));
  196.         }
  198.         // make sure the worker is the one working on this config instance
  199.         if ($tenantWorker->getTenantConfig() !== $this) {
  200.             throw new \LogicException('Worker config does not match the config the worker is about to be set to');
  201.         }
  202.     }
  204.     /**
  205.      * {@inheritdoc}
  206.      */
  207.     public function getTenantWorker()
  208.     {
  209.         // the worker is expected to call setTenantWorker as soon as possible
  210.         if (null === $this->tenantWorker) {
  211.             throw new \RuntimeException('Tenant worker is not set.');
  212.         }
  214.         return $this->tenantWorker;
  215.     }
  217.     /**
  218.      * @return string
  219.      */
  220.     public function getTenantName()
  221.     {
  222.         return $this->tenantName;
  223.     }
  225.     /**
  226.      * Returns configured attributes for product index
  227.      *
  228.      * @return Attribute[]
  229.      */
  230.     public function getAttributes(): array
  231.     {
  232.         // TODO Pimcore 10 remove as soon as attribute factory was added to the constructor.
  233.         if (null === $this->attributes) {
  234.             throw new \RuntimeException('Attributes are not built yet. Is the service properly configured to set an attribute factory?');
  235.         }
  237.         return $this->attributes;
  238.     }
  240.     /**
  241.      * Returns full text search index attribute names for product index
  242.      *
  243.      * @return array
  244.      */
  245.     public function getSearchAttributes(): array
  246.     {
  247.         // TODO Pimcore 10 remove as soon as attribute factory was added to the constructor.
  248.         if (null === $this->attributes) {
  249.             throw new \RuntimeException('Search attributes are not built yet. Is the service properly configured to set an attribute factory?');
  250.         }
  252.         return $this->searchAttributes;
  253.     }
  255.     /**
  256.      * return all supported filter types for product index
  257.      *
  258.      * @return array|null
  259.      */
  260.     public function getFilterTypeConfig()
  261.     {
  262.         return $this->filterTypeConfig;
  263.     }
  265.     /**
  266.      * @param IndexableInterface $object
  267.      *
  268.      * @return bool
  269.      */
  270.     public function isActive(IndexableInterface $object)
  271.     {
  272.         return true;
  273.     }
  275.     /**
  276.      * @param IndexableInterface $object
  277.      * @param int|null $subObjectId
  278.      *
  279.      * @return AbstractCategory[]
  280.      */
  281.     public function getCategories(IndexableInterface $object, $subObjectId = null)
  282.     {
  283.         return $object->getCategories();
  284.     }
  286.     /**
  287.      * creates an array of sub ids for the given object
  288.      * use that function, if one object should be indexed more than once (e.g. if field collections are in use)
  289.      *
  290.      * @param IndexableInterface $object
  291.      *
  292.      * @return IndexableInterface[]
  293.      */
  294.     public function createSubIdsForObject(IndexableInterface $object)
  295.     {
  296.         return [$object->getId() => $object];
  297.     }
  299.     /**
  300.      * checks if there are some zombie subIds around and returns them for cleanup
  301.      *
  302.      * @param IndexableInterface $object
  303.      * @param array $subIds
  304.      *
  305.      * @return array
  306.      */
  307.     public function getSubIdsToCleanup(IndexableInterface $object, array $subIds)
  308.     {
  309.         return [];
  310.     }
  312.     /**
  313.      * creates virtual parent id for given sub id
  314.      * default is getOSParentId
  315.      *
  316.      * @param IndexableInterface $object
  317.      * @param int $subId
  318.      *
  319.      * @return int|string|null
  320.      */
  321.     public function createVirtualParentIdForSubId(IndexableInterface $object, $subId)
  322.     {
  323.         return $object->getOSParentId();
  324.     }
  326.     /**
  327.      * Gets object by id, can consider subIds and therefore return e.g. an array of values
  328.      * always returns object itself - see also getObjectMockupById
  329.      *
  330.      * @param int $objectId
  331.      * @param bool $onlyMainObject - only returns main object
  332.      *
  333.      * @return DataObject|null
  334.      */
  335.     public function getObjectById($objectId, $onlyMainObject = false)
  336.     {
  337.         return DataObject::getById($objectId);
  338.     }
  340.     /**
  341.      * Gets object mockup by id, can consider subIds and therefore return e.g. an array of values
  342.      * always returns a object mockup if available
  343.      *
  344.      * @param int $objectId
  345.      *
  346.      * @return IndexableInterface|null
  347.      */
  348.     public function getObjectMockupById($objectId)
  349.     {
  350.         $object = $this->getObjectById($objectId);
  351.         if ($object instanceof IndexableInterface) {
  352.             return $object;
  353.         }
  355.         return null;
  356.     }
  358.     /**
  359.      * returns column type for id
  360.      *
  361.      * @param bool $isPrimary
  362.      *
  363.      * @return string
  364.      */
  365.     public function getIdColumnType($isPrimary)
  366.     {
  367.         if ($isPrimary) {
  368.             return "int(11) NOT NULL default '0'";
  369.         } else {
  370.             return 'int(11) NOT NULL';
  371.         }
  372.     }
  373. }