Import attribute and option translations from Akeneo (#192)

docs/architecture_and_customization.md

@@ -180,12 +180,21 @@ importer** (`Webgriffe\SyliusAkeneoPlugin\ProductAssociations\Importer`). This i
 associations to the corresponding Sylius products associations. The association types must already exist on Sylius with
 the same code they have on Akeneo.
 
+### Attribute importer
+
+Another provided importer is the **attribute importer** (`\Webgriffe\SyliusAkeneoPlugin\Attribute\Importer`). This
+importer imports the Akeneo attribute translations into Sylius attribute and option translations.
+The attributes and options must already exist on Sylius with the same code they have on Akeneo to be imported.
+
 ### Attribute options importer
 
-Another provided importer is the **attribute options
-importer** (`\Webgriffe\SyliusAkeneoPlugin\AttributeOptions\Importer`). This importer imports the Akeneo simple select
-and multi select attributes options into Sylius select attributes. The select attributes must already exist on Sylius
-with the same code they have on Akeneo.
+Another provided importer is the **attribute options importer**
+(`\Webgriffe\SyliusAkeneoPlugin\AttributeOptions\Importer`). This importer imports the Akeneo simple select
+and multi select attributes options into Sylius select attributes. It imports also all attribute options that are used
+on Sylius as product options. If the attribute has metrical type the values will not be imported because they could be
+any value, it will be created by the ProductOptionValueResolver during product variant import.
+The select attributes and the product options must already exist on Sylius
+with the same code they have on Akeneo to be imported.
 
 ## Customize which Akeneo products to import
 

docs/upgrade/upgrade-2.*.md

@@ -5,6 +5,16 @@ nav_order: 0
 parent: Upgrade
 ---
 
+# Upgrade from `v2.7.0` to `v2.8.0`
+
+The v2.8.0 version introduces the Attribute importer.
+If you want to import attribute and options translations from Akeneo you have to add the `--importer="Attribute"` option to the command that imports once a hour:
+
+```diff
+- 0   *   *  *  *  /path/to/sylius/bin/console -e prod -q webgriffe:akeneo:import --all --importer="AttributeOptions"
++ 0   *   *  *  *  /path/to/sylius/bin/console -e prod -q webgriffe:akeneo:import --all --importer="Attribute" --importer="AttributeOptions"
+```
+
 # Upgrade from `v2.4.0` to `v2.5.0`
 
 The v2.5.0 version now allow you to choose which product and product model to import through webhook entry point.
@@ -15,7 +25,7 @@ Take a look at the [customization documentation](../architecture_and_customizati
 The v2.4.0 version introduces the Product Model importer. If you are using the webhook no changes are requested as it will be automatically enqueued on every update.
 If you are using the cronjob, you have to add the `--importer="ProductModel"` option to the command that imports every minute:
 
-```git
+```diff
 - *   *   *  *  *  /path/to/sylius/bin/console -e prod -q webgriffe:akeneo:import --since-file=/path/to/sylius/var/storage/akeneo-import-sincefile.txt --importer="Product" --importer="ProductAssociations"
 + *   *   *  *  *  /path/to/sylius/bin/console -e prod -q webgriffe:akeneo:import --since-file=/path/to/sylius/var/storage/akeneo-import-sincefile.txt --importer="Product" --importer="ProductModel" --importer="ProductAssociations"
 ```

docs/usage.md

@@ -459,15 +459,15 @@ It could be useful to add also this command to your scheduler to run automatical
 To make all importers and other plugin features work automatically the following is the suggested crontab:
 
 ```
-0   *   *  *  *  /path/to/sylius/bin/console -e prod -q webgriffe:akeneo:import --all --importer="AttributeOptions"
+0   *   *  *  *  /path/to/sylius/bin/console -e prod -q webgriffe:akeneo:import --all --importer="Attribute" --importer="AttributeOptions"
 *   *   *  *  *  /path/to/sylius/bin/console -e prod -q webgriffe:akeneo:import --since-file=/path/to/sylius/var/storage/akeneo-import-sincefile.txt --importer="Product" --importer="ProductModel" --importer="ProductAssociations"
 0   */6 *  *  *  /path/to/sylius/bin/console -e prod -q webgriffe:akeneo:reconcile
 0   0   *  *  *  /path/to/sylius/bin/console -e prod -q webgriffe:akeneo:cleanup-item-import-results
 ```
 
 This will:
 
-* Import the update of all attribute options every hour
+* Import the attribute/option translations and import all attribute/option values every hour
 * Import, every minute, all products and product models that have been modified since the last execution, along with their associations
 * Reconcile Akeneo deleted products every 6 hours
 

src/Attribute/Importer.php

@@ -0,0 +1,154 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Webgriffe\SyliusAkeneoPlugin\Attribute;
+
+use Akeneo\Pim\ApiClient\AkeneoPimClientInterface;
+use Akeneo\Pim\ApiClient\Pagination\ResourceCursorInterface;
+use Akeneo\Pim\ApiClient\Search\SearchBuilder;
+use DateTime;
+use Sylius\Component\Product\Model\ProductAttributeInterface;
+use Sylius\Component\Product\Model\ProductAttributeTranslationInterface;
+use Sylius\Component\Product\Model\ProductOptionInterface;
+use Sylius\Component\Product\Model\ProductOptionTranslationInterface;
+use Sylius\Component\Product\Repository\ProductOptionRepositoryInterface;
+use Sylius\Component\Resource\Factory\FactoryInterface;
+use Sylius\Component\Resource\Repository\RepositoryInterface;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Webgriffe\SyliusAkeneoPlugin\Event\IdentifiersModifiedSinceSearchBuilderBuiltEvent;
+use Webgriffe\SyliusAkeneoPlugin\ImporterInterface;
+use Webgriffe\SyliusAkeneoPlugin\ProductOptionHelperTrait;
+use Webgriffe\SyliusAkeneoPlugin\SyliusProductAttributeHelperTrait;
+
+/**
+ * @psalm-type AkeneoAttribute array{code: string, type: string, labels: array<string, ?string>}
+ */
+final class Importer implements ImporterInterface
+{
+    public const SIMPLESELECT_TYPE = 'pim_catalog_simpleselect';
+
+    public const MULTISELECT_TYPE = 'pim_catalog_multiselect';
+
+    public const BOOLEAN_TYPE = 'pim_catalog_boolean';
+
+    public const METRIC_TYPE = 'pim_catalog_metric';
+
+    public const AKENEO_ENTITY = 'Attribute';
+
+    use ProductOptionHelperTrait, SyliusProductAttributeHelperTrait;
+
+    /**
+     * @param FactoryInterface<ProductOptionTranslationInterface> $productOptionTranslationFactory
+     * @param RepositoryInterface<ProductAttributeInterface> $productAttributeRepository
+     * @param FactoryInterface<ProductAttributeTranslationInterface> $productAttributeTranslationFactory
+     */
+    public function __construct(
+        private EventDispatcherInterface $eventDispatcher,
+        private AkeneoPimClientInterface $apiClient,
+        private ProductOptionRepositoryInterface $productOptionRepository,
+        private FactoryInterface $productOptionTranslationFactory,
+        private RepositoryInterface $productAttributeRepository,
+        private FactoryInterface $productAttributeTranslationFactory,
+    ) {
+    }
+
+    public function getAkeneoEntity(): string
+    {
+        return self::AKENEO_ENTITY;
+    }
+
+    public function getIdentifiersModifiedSince(DateTime $sinceDate): array
+    {
+        $searchBuilder = new SearchBuilder();
+        $this->eventDispatcher->dispatch(
+            new IdentifiersModifiedSinceSearchBuilderBuiltEvent($this, $searchBuilder, $sinceDate),
+        );
+        /**
+         * @psalm-suppress TooManyTemplateParams
+         *
+         * @var ResourceCursorInterface<array-key, AkeneoAttribute> $akeneoAttributes
+         */
+        $akeneoAttributes = $this->apiClient->getAttributeApi()->all(50, ['search' => $searchBuilder->getFilters()]);
+
+        return array_merge(
+            $this->filterBySyliusAttributeCodes($akeneoAttributes),
+            $this->filterSyliusOptionCodes($akeneoAttributes),
+        );
+    }
+
+    public function import(string $identifier): void
+    {
+        /** @var AkeneoAttribute $akeneoAttribute */
+        $akeneoAttribute = $this->apiClient->getAttributeApi()->get($identifier);
+
+        $syliusProductAttribute = $this->productAttributeRepository->findOneBy(['code' => $identifier]);
+        if ($syliusProductAttribute instanceof ProductAttributeInterface) {
+            $this->importAttributeData($akeneoAttribute, $syliusProductAttribute);
+        }
+
+        $syliusProductOption = $this->productOptionRepository->findOneBy(['code' => $identifier]);
+        if ($syliusProductOption instanceof ProductOptionInterface) {
+            $this->importOptionData($akeneoAttribute, $syliusProductOption);
+        }
+    }
+
+    /**
+     * @return FactoryInterface<ProductOptionTranslationInterface>
+     */
+    private function getProductOptionTranslationFactory(): FactoryInterface
+    {
+        return $this->productOptionTranslationFactory;
+    }
+
+    private function getProductOptionRepository(): ProductOptionRepositoryInterface
+    {
+        return $this->productOptionRepository;
+    }
+
+    /**
+     * @return RepositoryInterface<ProductAttributeInterface>
+     */
+    private function getProductAttributeRepository(): RepositoryInterface
+    {
+        return $this->productAttributeRepository;
+    }
+
+    /**
+     * @param AkeneoAttribute $akeneoAttribute
+     */
+    private function importAttributeData(array $akeneoAttribute, ProductAttributeInterface $syliusProductAttribute): void
+    {
+        $this->importProductAttributeTranslations($akeneoAttribute, $syliusProductAttribute);
+        $this->productAttributeRepository->add($syliusProductAttribute);
+    }
+
+    /**
+     * @param AkeneoAttribute $akeneoAttribute
+     */
+    private function importOptionData(array $akeneoAttribute, ProductOptionInterface $syliusProductOption): void
+    {
+        $this->importProductOptionTranslations($akeneoAttribute, $syliusProductOption);
+        $this->productOptionRepository->add($syliusProductOption);
+        // TODO: Update also the position of the option? The problem is that this position is on family variant entity!
+    }
+
+    /**
+     * @param AkeneoAttribute $akeneoAttribute
+     */
+    private function importProductAttributeTranslations(array $akeneoAttribute, ProductAttributeInterface $syliusProductAttribute): void
+    {
+        foreach ($akeneoAttribute['labels'] as $locale => $label) {
+            $productAttributeTranslation = $syliusProductAttribute->getTranslation($locale);
+            if ($productAttributeTranslation->getLocale() === $locale) {
+                $productAttributeTranslation->setName($label);
+
+                continue;
+            }
+            $newProductAttributeTranslation = $this->productAttributeTranslationFactory->createNew();
+            $newProductAttributeTranslation->setLocale($locale);
+            $newProductAttributeTranslation->setName($label);
+            $syliusProductAttribute->addTranslation($newProductAttributeTranslation);
+        }
+    }
+}

src/AttributeOptions/Importer.php

@@ -20,11 +20,13 @@
 use Sylius\Component\Resource\Translation\Provider\TranslationLocaleProviderInterface;
 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Contracts\Translation\TranslatorInterface;
+use Webgriffe\SyliusAkeneoPlugin\Attribute\Importer as AttributeImporter;
 use Webgriffe\SyliusAkeneoPlugin\Event\IdentifiersModifiedSinceSearchBuilderBuiltEvent;
 use Webgriffe\SyliusAkeneoPlugin\ImporterInterface;
 use Webgriffe\SyliusAkeneoPlugin\ProductAttributeHelperTrait;
 use Webgriffe\SyliusAkeneoPlugin\ProductOptionHelperTrait;
 use Webgriffe\SyliusAkeneoPlugin\ProductOptionValueHelperTrait;
+use Webgriffe\SyliusAkeneoPlugin\SyliusProductAttributeHelperTrait;
 use Webmozart\Assert\Assert;
 
 /**
@@ -33,15 +35,10 @@
  */
 final class Importer implements ImporterInterface
 {
-    use ProductOptionHelperTrait, ProductOptionValueHelperTrait, ProductAttributeHelperTrait;
-
-    private const SIMPLESELECT_TYPE = 'pim_catalog_simpleselect';
-
-    private const MULTISELECT_TYPE = 'pim_catalog_multiselect';
-
-    private const BOOLEAN_TYPE = 'pim_catalog_boolean';
-
-    private const METRIC_TYPE = 'pim_catalog_metric';
+    use ProductOptionHelperTrait,
+        ProductOptionValueHelperTrait,
+        ProductAttributeHelperTrait,
+        SyliusProductAttributeHelperTrait;
 
     /**
      * @param RepositoryInterface<ProductAttributeInterface> $attributeRepository
@@ -146,89 +143,25 @@ public function getIdentifiersModifiedSince(DateTime $sinceDate): array
         $akeneoAttributes = $this->apiClient->getAttributeApi()->all(50, ['search' => $searchBuilder->getFilters()]);
 
         return array_merge(
-            $this->filterBySyliusAttributeCodes($akeneoAttributes),
+            $this->filterBySyliusSelectAttributeCodes($akeneoAttributes),
             $this->filterSyliusOptionCodes($akeneoAttributes),
         );
     }
 
-    /**
-     * Return the list of Akeneo attribute codes whose code is used as a code for a Sylius attribute
-     *
-     * @psalm-suppress TooManyTemplateParams
-     *
-     * @param ResourceCursorInterface<array-key, AkeneoAttribute> $akeneoAttributes
-     *
-     * @return string[]
-     */
-    private function filterBySyliusAttributeCodes(ResourceCursorInterface $akeneoAttributes): array
-    {
-        $syliusSelectAttributes = $this->attributeRepository->findBy(['type' => SelectAttributeType::TYPE]);
-        $syliusSelectAttributes = array_filter(
-            array_map(
-                static fn (ProductAttributeInterface $attribute): ?string => $attribute->getCode(),
-                $syliusSelectAttributes,
-            ),
-        );
-        $attributeCodes = [];
-        /** @var AkeneoAttribute $akeneoAttribute */
-        foreach ($akeneoAttributes as $akeneoAttribute) {
-            if (!in_array($akeneoAttribute['code'], $syliusSelectAttributes, true)) {
-                continue;
-            }
-            if ($akeneoAttribute['type'] !== self::SIMPLESELECT_TYPE && $akeneoAttribute['type'] !== self::MULTISELECT_TYPE) {
-                continue;
-            }
-            $attributeCodes[] = $akeneoAttribute['code'];
-        }
-
-        return $attributeCodes;
-    }
-
-    /**
-     * Return the list of Akeneo attribute codes whose code is used as a code for a Sylius attribute
-     *
-     * @psalm-suppress TooManyTemplateParams
-     *
-     * @param ResourceCursorInterface<array-key, AkeneoAttribute> $akeneoAttributes
-     *
-     * @return string[]
-     */
-    private function filterSyliusOptionCodes(ResourceCursorInterface $akeneoAttributes): array
-    {
-        $productOptionRepository = $this->optionRepository;
-        if (!$productOptionRepository instanceof ProductOptionRepositoryInterface) {
-            return [];
-        }
-        $akeneoAttributeCodes = [];
-        /** @var AkeneoAttribute $akeneoAttribute */
-        foreach ($akeneoAttributes as $akeneoAttribute) {
-            if (!in_array($akeneoAttribute['type'], [self::SIMPLESELECT_TYPE, self::MULTISELECT_TYPE, self::BOOLEAN_TYPE, self::METRIC_TYPE], true)) {
-                continue;
-            }
-            $akeneoAttributeCodes[] = $akeneoAttribute['code'];
-        }
-        $syliusOptions = $productOptionRepository->findByCodes($akeneoAttributeCodes);
-
-        return array_map(
-            static fn (ProductOptionInterface $option): string => (string) $option->getCode(),
-            $syliusOptions,
-        );
-    }
-
     /**
      * @param AkeneoAttribute $akeneoAttribute
      */
     private function importOptionValues(array $akeneoAttribute, ProductOptionInterface $option): void
     {
-        if ($akeneoAttribute['type'] !== self::SIMPLESELECT_TYPE &&
-            $akeneoAttribute['type'] !== self::MULTISELECT_TYPE &&
-            $akeneoAttribute['type'] !== self::BOOLEAN_TYPE
+        if ($akeneoAttribute['type'] !== AttributeImporter::SIMPLESELECT_TYPE &&
+            $akeneoAttribute['type'] !== AttributeImporter::MULTISELECT_TYPE &&
+            $akeneoAttribute['type'] !== AttributeImporter::BOOLEAN_TYPE
         ) {
             return;
         }
         $attributeCode = $akeneoAttribute['code'];
 
-        if ($akeneoAttribute['type'] === self::BOOLEAN_TYPE) {
+        if ($akeneoAttribute['type'] === AttributeImporter::BOOLEAN_TYPE) {
             foreach ([true, false] as $booleanValue) {
                 $optionValueCode = $this->getSyliusProductOptionValueCode($attributeCode, (string) $booleanValue);
                 $productOptionValue = $this->getProductOptionValueFromOption($option, $optionValueCode);
@@ -338,4 +271,17 @@ private function getAkeneoPimClient(): AkeneoPimClientInterface
     {
         return $this->apiClient;
     }
+
+    private function getProductOptionRepository(): ?ProductOptionRepositoryInterface
+    {
+        return $this->optionRepository;
+    }
+
+    /**
+     * @return RepositoryInterface<ProductAttributeInterface>
+     */
+    private function getProductAttributeRepository(): RepositoryInterface
+    {
+        return $this->attributeRepository;
+    }
 }

src/Product/ProductOptionsResolver.php

@@ -122,4 +122,9 @@ private function getProductOptionTranslationFactory(): FactoryInterface
     {
         return $this->productOptionTranslationFactory;
     }
+
+    private function getProductOptionRepository(): ProductOptionRepositoryInterface
+    {
+        return $this->productOptionRepository;
+    }
 }

src/ProductAttributeHelperTrait.php

@@ -9,6 +9,8 @@
 use Sylius\Component\Product\Model\ProductAttributeInterface;
 
 /**
+ * @TODO Rename to something more Akeneo-specific, like AkeneoAttributeHelperTrait
+ *
  * @psalm-type AkeneoAttributeOption array{_links: array, code: string, attribute: string, sort_order: int, labels: array<string, ?string>}
  */
 trait ProductAttributeHelperTrait