vendor/ibexa/measurement/src/bundle/EventSubscriber/Migrations/ProductAttributeConversionSubscriber.php line 46

Open in your IDE?
  1. <?php
  3. /**
  4.  * @copyright Copyright (C) Ibexa AS. All rights reserved.
  5.  * @license For full copyright and license information view LICENSE file distributed with this source code.
  6.  */
  7. declare(strict_types=1);
  9. namespace Ibexa\Bundle\Measurement\EventSubscriber\Migrations;
  11. use Ibexa\Contracts\Measurement\MeasurementServiceInterface;
  12. use Ibexa\Contracts\Measurement\Value\ValueInterface;
  13. use Ibexa\Contracts\ProductCatalog\AttributeDefinitionServiceInterface;
  14. use Ibexa\Migration\Event\FieldValueFromHashEvent;
  15. use Ibexa\Migration\Event\MigrationEvents;
  16. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  17. use Webmozart\Assert\Assert;
  19. final class ProductAttributeConversionSubscriber implements EventSubscriberInterface
  20. {
  21.     private MeasurementServiceInterface $measurementService;
  23.     private AttributeDefinitionServiceInterface $attributeDefinitionService;
  25.     public function __construct(
  26.         MeasurementServiceInterface $measurementService,
  27.         AttributeDefinitionServiceInterface $attributeDefinitionService
  28.     ) {
  29.         $this->measurementService = $measurementService;
  30.         $this->attributeDefinitionService = $attributeDefinitionService;
  31.     }
  33.     /**
  34.      * @return array<string, array{string, int}>
  35.      */
  36.     public static function getSubscribedEvents(): array
  37.     {
  38.         return [
  39.             MigrationEvents::BEFORE_FIELD_VALUE_FROM_HASH => [
  40.                 'convertScalarHashIntoObjects',
  41.                 -100,
  42.             ],
  43.         ];
  44.     }
  46.     public function convertScalarHashIntoObjects(FieldValueFromHashEvent $event): void
  47.     {
  48.         $hash = $event->getHash();
  49.         $fieldTypeIdentifier = $event->getFieldTypeIdentifier();
  51.         if ($fieldTypeIdentifier !== 'ibexa_product_specification') {
  52.             return;
  53.         }
  55.         if ($hash === null) {
  56.             return;
  57.         }
  59.         Assert::isArray($hash);
  61.         if (!isset($hash['attributes'])) {
  62.             return;
  63.         }
  65.         Assert::isArray($hash['attributes']);
  67.         foreach ($hash['attributes'] as $attributeDefinitionIdentifier => $attributeData) {
  68.             if ($attributeData instanceof ValueInterface) {
  69.                 continue;
  70.             }
  72.             if (!is_array($attributeData)) {
  73.                 continue;
  74.             }
  76.             $attributeDefinition = $this->attributeDefinitionService->getAttributeDefinition(
  77.                 (string)$attributeDefinitionIdentifier
  78.             );
  80.             $measurementTypeIdentifier = $attributeDefinition->getType()->getIdentifier();
  82.             switch ($measurementTypeIdentifier) {
  83.                 case 'measurement_range':
  85.                     Assert::keyExists($attributeData, 'measurementType');
  86.                     $measurementType = $attributeData['measurementType'];
  88.                     Assert::keyExists($attributeData, 'measurementRangeMinimumValue');
  89.                     $minimumValue = $attributeData['measurementRangeMinimumValue'];
  90.                     Assert::numeric($minimumValue);
  91.                     $minimumValue = (float)$minimumValue;
  93.                     Assert::keyExists($attributeData, 'measurementRangeMaximumValue');
  94.                     $maximumValue = $attributeData['measurementRangeMaximumValue'];
  95.                     Assert::numeric($maximumValue);
  96.                     $maximumValue = (float)$maximumValue;
  98.                     Assert::keyExists($attributeData, 'measurementUnit');
  99.                     $measurementUnit = $attributeData['measurementUnit'];
  101.                     $measurement = $this->measurementService->buildRangeValue(
  102.                         $measurementType,
  103.                         $minimumValue,
  104.                         $maximumValue,
  105.                         $measurementUnit,
  106.                     );
  108.                     $hash['attributes'][$attributeDefinitionIdentifier] = $measurement;
  110.                     break;
  111.                 case 'measurement_single':
  113.                     Assert::keyExists($attributeData, 'measurementType');
  114.                     $measurementType = $attributeData['measurementType'];
  116.                     Assert::keyExists($attributeData, 'value');
  117.                     $value = $attributeData['value'];
  118.                     Assert::numeric($value);
  119.                     $value = (float)$value;
  121.                     Assert::keyExists($attributeData, 'measurementUnit');
  122.                     $measurementUnit = $attributeData['measurementUnit'];
  124.                     $measurement = $this->measurementService->buildSimpleValue(
  125.                         $measurementType,
  126.                         $value,
  127.                         $measurementUnit,
  128.                     );
  130.                     $hash['attributes'][$attributeDefinitionIdentifier] = $measurement;
  132.                     break;
  133.             }
  134.         }
  136.         $event->setHash($hash);
  137.     }
  138. }