vendor/shopware/core/System/SalesChannel/Validation/SalesChannelValidator.php line 53

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\System\SalesChannel\Validation;
  5. use Doctrine\DBAL\Connection;
  6. use Shopware\Core\Defaults;
  7. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\DeleteCommand;
  8. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\InsertCommand;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\UpdateCommand;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\WriteCommand;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Write\Validation\PreWriteValidationEvent;
  12. use Shopware\Core\Framework\Log\Package;
  13. use Shopware\Core\Framework\Uuid\Uuid;
  14. use Shopware\Core\Framework\Validation\WriteConstraintViolationException;
  15. use Shopware\Core\System\SalesChannel\Aggregate\SalesChannelLanguage\SalesChannelLanguageDefinition;
  16. use Shopware\Core\System\SalesChannel\SalesChannelDefinition;
  17. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  18. use Symfony\Component\Validator\ConstraintViolation;
  19. use Symfony\Component\Validator\ConstraintViolationList;
  21. /**
  22.  * @internal
  23.  */
  24. #[Package('sales-channel')]
  25. class SalesChannelValidator implements EventSubscriberInterface
  26. {
  27.     private const INSERT_VALIDATION_MESSAGE = 'The sales channel with id "%s" does not have a default sales channel language id in the language list.';
  28.     private const INSERT_VALIDATION_CODE = 'SYSTEM__NO_GIVEN_DEFAULT_LANGUAGE_ID';
  30.     private const DUPLICATED_ENTRY_VALIDATION_MESSAGE = 'The sales channel language "%s" for the sales channel "%s" already exists.';
  31.     private const DUPLICATED_ENTRY_VALIDATION_CODE = 'SYSTEM__DUPLICATED_SALES_CHANNEL_LANGUAGE';
  33.     private const UPDATE_VALIDATION_MESSAGE = 'Cannot update default language id because the given id is not in the language list of sales channel with id "%s"';
  34.     private const UPDATE_VALIDATION_CODE = 'SYSTEM__CANNOT_UPDATE_DEFAULT_LANGUAGE_ID';
  36.     private const DELETE_VALIDATION_MESSAGE = 'Cannot delete default language id from language list of the sales channel with id "%s".';
  37.     private const DELETE_VALIDATION_CODE = 'SYSTEM__CANNOT_DELETE_DEFAULT_LANGUAGE_ID';
  39.     /**
  40.      * @internal
  41.      */
  42.     public function __construct(private readonly Connection $connection)
  43.     {
  44.     }
  46.     public static function getSubscribedEvents(): array
  47.     {
  48.         return [
  49.             PreWriteValidationEvent::class => 'handleSalesChannelLanguageIds',
  50.         ];
  51.     }
  53.     public function handleSalesChannelLanguageIds(PreWriteValidationEvent $event): void
  54.     {
  55.         $mapping = $this->extractMapping($event);
  57.         if (!$mapping) {
  58.             return;
  59.         }
  61.         $salesChannelIds = array_keys($mapping);
  62.         $states = $this->fetchCurrentLanguageStates($salesChannelIds);
  64.         $mapping = $this->mergeCurrentStatesWithMapping($mapping, $states);
  66.         $this->validateLanguages($mapping, $event);
  67.     }
  69.     /**
  70.      * Build a key map with the following data structure:
  71.      *
  72.      * 'sales_channel_id' => [
  73.      *     'current_default' => 'en',
  74.      *     'new_default' => 'de',
  75.      *     'inserts' => ['de', 'en'],
  76.      *     'updates' => ['de', 'de'],
  77.      *     'deletions' => ['gb'],
  78.      *     'state' => ['en', 'gb']
  79.      * ]
  80.      *
  81.      * @return array<string, array<string, list<string>>>
  82.      */
  83.     private function extractMapping(PreWriteValidationEvent $event): array
  84.     {
  85.         $mapping = [];
  86.         foreach ($event->getCommands() as $command) {
  87.             if ($command->getDefinition() instanceof SalesChannelDefinition) {
  88.                 $this->handleSalesChannelMapping($mapping, $command);
  90.                 continue;
  91.             }
  93.             if ($command->getDefinition() instanceof SalesChannelLanguageDefinition) {
  94.                 $this->handleSalesChannelLanguageMapping($mapping, $command);
  95.             }
  96.         }
  98.         return $mapping;
  99.     }
  101.     /**
  102.      * @param array<string, array<string, list<string>>> $mapping
  103.      */
  104.     private function handleSalesChannelMapping(array &$mapping, WriteCommand $command): void
  105.     {
  106.         if (!isset($command->getPayload()['language_id'])) {
  107.             return;
  108.         }
  110.         if ($command instanceof UpdateCommand) {
  111.             $id = Uuid::fromBytesToHex($command->getPrimaryKey()['id']);
  112.             $mapping[$id]['updates'] = Uuid::fromBytesToHex($command->getPayload()['language_id']);
  114.             return;
  115.         }
  117.         if (!$command instanceof InsertCommand || !$this->isSupportedSalesChannelType($command)) {
  118.             return;
  119.         }
  121.         $id = Uuid::fromBytesToHex($command->getPrimaryKey()['id']);
  122.         $mapping[$id]['new_default'] = Uuid::fromBytesToHex($command->getPayload()['language_id']);
  123.         $mapping[$id]['inserts'] = [];
  124.         $mapping[$id]['state'] = [];
  125.     }
  127.     private function isSupportedSalesChannelType(WriteCommand $command): bool
  128.     {
  129.         $typeId = Uuid::fromBytesToHex($command->getPayload()['type_id']);
  131.         return $typeId === Defaults::SALES_CHANNEL_TYPE_STOREFRONT
  132.             || $typeId === Defaults::SALES_CHANNEL_TYPE_API;
  133.     }
  135.     /**
  136.      * @param array<string, list<string>> $mapping
  137.      */
  138.     private function handleSalesChannelLanguageMapping(array &$mapping, WriteCommand $command): void
  139.     {
  140.         $language = Uuid::fromBytesToHex($command->getPrimaryKey()['language_id']);
  141.         $id = Uuid::fromBytesToHex($command->getPrimaryKey()['sales_channel_id']);
  142.         $mapping[$id]['state'] = [];
  144.         if ($command instanceof DeleteCommand) {
  145.             $mapping[$id]['deletions'][] = $language;
  147.             return;
  148.         }
  150.         if ($command instanceof InsertCommand) {
  151.             $mapping[$id]['inserts'][] = $language;
  152.         }
  153.     }
  155.     /**
  156.      * @param array<string, list<string>> $mapping
  157.      */
  158.     private function validateLanguages(array $mapping, PreWriteValidationEvent $event): void
  159.     {
  160.         $inserts = [];
  161.         $duplicates = [];
  162.         $deletions = [];
  163.         $updates = [];
  165.         foreach ($mapping as $id => $channel) {
  166.             if (isset($channel['inserts'])) {
  167.                 if (!$this->validInsertCase($channel)) {
  168.                     $inserts[$id] = $channel['new_default'];
  169.                 }
  171.                 $duplicatedIds = $this->getDuplicates($channel);
  173.                 if ($duplicatedIds) {
  174.                     $duplicates[$id] = $duplicatedIds;
  175.                 }
  176.             }
  178.             if (isset($channel['deletions']) && !$this->validDeleteCase($channel)) {
  179.                 $deletions[$id] = $channel['current_default'];
  180.             }
  182.             if (isset($channel['updates']) && !$this->validUpdateCase($channel)) {
  183.                 $updates[$id] = $channel['updates'];
  184.             }
  185.         }
  187.         $this->writeInsertViolationExceptions($inserts, $event);
  188.         $this->writeDuplicateViolationExceptions($duplicates, $event);
  189.         $this->writeDeleteViolationExceptions($deletions, $event);
  190.         $this->writeUpdateViolationExceptions($updates, $event);
  191.     }
  193.     /**
  194.      * @param array<string, mixed> $channel
  195.      */
  196.     private function validInsertCase(array $channel): bool
  197.     {
  198.         return empty($channel['new_default'])
  199.             || \in_array($channel['new_default'], $channel['inserts'], true);
  200.     }
  202.     /**
  203.      * @param array<string, mixed> $channel
  204.      */
  205.     private function validUpdateCase(array $channel): bool
  206.     {
  207.         $updateId = $channel['updates'];
  209.         return \in_array($updateId, $channel['state'], true)
  210.             || empty($channel['new_default']) && $updateId === $channel['current_default']
  211.             || isset($channel['inserts']) && \in_array($updateId, $channel['inserts'], true);
  212.     }
  214.     /**
  215.      * @param array<string, mixed> $channel
  216.      */
  217.     private function validDeleteCase(array $channel): bool
  218.     {
  219.         return !\in_array($channel['current_default'], $channel['deletions'], true);
  220.     }
  222.     /**
  223.      * @param array<string, mixed> $channel
  224.      *
  225.      * @return array<string, mixed>
  226.      */
  227.     private function getDuplicates(array $channel): array
  228.     {
  229.         return array_intersect($channel['state'], $channel['inserts']);
  230.     }
  232.     /**
  233.      * @param array<string, mixed> $inserts
  234.      */
  235.     private function writeInsertViolationExceptions(array $inserts, PreWriteValidationEvent $event): void
  236.     {
  237.         if (!$inserts) {
  238.             return;
  239.         }
  241.         $violations = new ConstraintViolationList();
  242.         $salesChannelIds = array_keys($inserts);
  244.         foreach ($salesChannelIds as $id) {
  245.             $violations->add(new ConstraintViolation(
  246.                 sprintf(self::INSERT_VALIDATION_MESSAGE, $id),
  247.                 sprintf(self::INSERT_VALIDATION_MESSAGE, '{{ salesChannelId }}'),
  248.                 ['{{ salesChannelId }}' => $id],
  249.                 null,
  250.                 '/',
  251.                 null,
  252.                 null,
  253.                 self::INSERT_VALIDATION_CODE
  254.             ));
  255.         }
  257.         $this->writeViolationException($violations, $event);
  258.     }
  260.     /**
  261.      * @param array<string, mixed> $duplicates
  262.      */
  263.     private function writeDuplicateViolationExceptions(array $duplicates, PreWriteValidationEvent $event): void
  264.     {
  265.         if (!$duplicates) {
  266.             return;
  267.         }
  269.         $violations = new ConstraintViolationList();
  271.         foreach ($duplicates as $id => $duplicateLanguages) {
  272.             foreach ($duplicateLanguages as $languageId) {
  273.                 $violations->add(new ConstraintViolation(
  274.                     sprintf(self::DUPLICATED_ENTRY_VALIDATION_MESSAGE, $languageId, $id),
  275.                     sprintf(self::DUPLICATED_ENTRY_VALIDATION_MESSAGE, '{{ languageId }}', '{{ salesChannelId }}'),
  276.                     [
  277.                         '{{ salesChannelId }}' => $id,
  278.                         '{{ languageId }}' => $languageId,
  279.                     ],
  280.                     null,
  281.                     '/',
  282.                     null,
  283.                     null,
  284.                     self::DUPLICATED_ENTRY_VALIDATION_CODE
  285.                 ));
  286.             }
  287.         }
  289.         $this->writeViolationException($violations, $event);
  290.     }
  292.     /**
  293.      * @param array<string, mixed> $deletions
  294.      */
  295.     private function writeDeleteViolationExceptions(array $deletions, PreWriteValidationEvent $event): void
  296.     {
  297.         if (!$deletions) {
  298.             return;
  299.         }
  301.         $violations = new ConstraintViolationList();
  302.         $salesChannelIds = array_keys($deletions);
  304.         foreach ($salesChannelIds as $id) {
  305.             $violations->add(new ConstraintViolation(
  306.                 sprintf(self::DELETE_VALIDATION_MESSAGE, $id),
  307.                 sprintf(self::DELETE_VALIDATION_MESSAGE, '{{ salesChannelId }}'),
  308.                 ['{{ salesChannelId }}' => $id],
  309.                 null,
  310.                 '/',
  311.                 null,
  312.                 null,
  313.                 self::DELETE_VALIDATION_CODE
  314.             ));
  315.         }
  317.         $this->writeViolationException($violations, $event);
  318.     }
  320.     /**
  321.      * @param array<string, mixed> $updates
  322.      */
  323.     private function writeUpdateViolationExceptions(array $updates, PreWriteValidationEvent $event): void
  324.     {
  325.         if (!$updates) {
  326.             return;
  327.         }
  329.         $violations = new ConstraintViolationList();
  330.         $salesChannelIds = array_keys($updates);
  332.         foreach ($salesChannelIds as $id) {
  333.             $violations->add(new ConstraintViolation(
  334.                 sprintf(self::UPDATE_VALIDATION_MESSAGE, $id),
  335.                 sprintf(self::UPDATE_VALIDATION_MESSAGE, '{{ salesChannelId }}'),
  336.                 ['{{ salesChannelId }}' => $id],
  337.                 null,
  338.                 '/',
  339.                 null,
  340.                 null,
  341.                 self::UPDATE_VALIDATION_CODE
  342.             ));
  343.         }
  345.         $this->writeViolationException($violations, $event);
  346.     }
  348.     /**
  349.      * @param array<string> $salesChannelIds
  350.      *
  351.      * @return array<string, string>
  352.      */
  353.     private function fetchCurrentLanguageStates(array $salesChannelIds): array
  354.     {
  355.         /** @var array<string, mixed> $result */
  356.         $result = $this->connection->fetchAllAssociative(
  357.             'SELECT LOWER(HEX(sales_channel.id)) AS sales_channel_id,
  358.             LOWER(HEX(sales_channel.language_id)) AS current_default,
  359.             LOWER(HEX(mapping.language_id)) AS language_id
  360.             FROM sales_channel
  361.             LEFT JOIN sales_channel_language mapping
  362.                 ON mapping.sales_channel_id = sales_channel.id
  363.                 WHERE sales_channel.id IN (:ids)',
  364.             ['ids' => Uuid::fromHexToBytesList($salesChannelIds)],
  365.             ['ids' => Connection::PARAM_STR_ARRAY]
  366.         );
  368.         return $result;
  369.     }
  371.     /**
  372.      * @param array<string, mixed> $mapping
  373.      * @param array<string, mixed> $states
  374.      *
  375.      * @return array<string, mixed>
  376.      */
  377.     private function mergeCurrentStatesWithMapping(array $mapping, array $states): array
  378.     {
  379.         foreach ($states as $record) {
  380.             $id = (string) $record['sales_channel_id'];
  381.             $mapping[$id]['current_default'] = $record['current_default'];
  382.             $mapping[$id]['state'][] = $record['language_id'];
  383.         }
  385.         return $mapping;
  386.     }
  388.     private function writeViolationException(ConstraintViolationList $violations, PreWriteValidationEvent $event): void
  389.     {
  390.         $event->getExceptions()->add(new WriteConstraintViolationException($violations));
  391.     }
  392. }