vendor/shopware/core/Checkout/Shipping/Validator/ShippingMethodValidator.php line 45

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Checkout\Shipping\Validator;
  5. use Doctrine\DBAL\Connection;
  6. use Shopware\Core\Checkout\Shipping\ShippingMethodDefinition;
  7. use Shopware\Core\Checkout\Shipping\ShippingMethodEntity;
  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\Validation\PreWriteValidationEvent;
  11. use Shopware\Core\Framework\Log\Package;
  12. use Shopware\Core\Framework\Validation\WriteConstraintViolationException;
  13. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  14. use Symfony\Component\Validator\ConstraintViolation;
  15. use Symfony\Component\Validator\ConstraintViolationInterface;
  16. use Symfony\Component\Validator\ConstraintViolationList;
  18. /**
  19.  * @internal
  20.  */
  21. #[Package('checkout')]
  22. class ShippingMethodValidator implements EventSubscriberInterface
  23. {
  24.     final public const VIOLATION_TAX_TYPE_INVALID = 'tax_type_invalid';
  26.     final public const VIOLATION_TAX_ID_REQUIRED = 'c1051bb4-d103-4f74-8988-acbcafc7fdc3';
  28.     /**
  29.      * @internal
  30.      */
  31.     public function __construct(private readonly Connection $connection)
  32.     {
  33.     }
  35.     /**
  36.      * @return array<string, string|array{0: string, 1: int}|list<array{0: string, 1?: int}>>
  37.      */
  38.     public static function getSubscribedEvents(): array
  39.     {
  40.         return [
  41.             PreWriteValidationEvent::class => 'preValidate',
  42.         ];
  43.     }
  45.     public function preValidate(PreWriteValidationEvent $event): void
  46.     {
  47.         $allowTypes = [
  48.             ShippingMethodEntity::TAX_TYPE_FIXED,
  49.             ShippingMethodEntity::TAX_TYPE_AUTO,
  50.             ShippingMethodEntity::TAX_TYPE_HIGHEST,
  51.         ];
  53.         $writeCommands = $event->getCommands();
  55.         foreach ($writeCommands as $command) {
  56.             $violations = new ConstraintViolationList();
  58.             if (!$command instanceof InsertCommand && !$command instanceof UpdateCommand) {
  59.                 continue;
  60.             }
  62.             if ($command->getDefinition()->getClass() !== ShippingMethodDefinition::class) {
  63.                 continue;
  64.             }
  66.             $shippingMethod = $this->findShippingMethod($command->getPrimaryKey()['id']);
  68.             $payload = $command->getPayload();
  70.             /** @var string|null $taxType */
  71.             $taxType = $this->getValue($payload, 'tax_type', $shippingMethod);
  73.             /** @var string|null $taxId */
  74.             $taxId = $this->getValue($payload, 'tax_id', $shippingMethod);
  76.             if ($taxType && !\in_array($taxType, $allowTypes, true)) {
  77.                 $violations->add(
  78.                     $this->buildViolation(
  79.                         'The selected tax type {{ type }} is invalid.',
  80.                         ['{{ type }}' => $taxType],
  81.                         '/taxType',
  82.                         $taxType,
  83.                         self::VIOLATION_TAX_TYPE_INVALID
  84.                     )
  85.                 );
  86.             }
  88.             if ($taxType === ShippingMethodEntity::TAX_TYPE_FIXED && !$taxId) {
  89.                 $violations->add(
  90.                     $this->buildViolation(
  91.                         'The defined tax rate is required when fixed tax present',
  92.                         ['{{ taxId }}' => null],
  93.                         '/taxId',
  94.                         $taxType,
  95.                         self::VIOLATION_TAX_ID_REQUIRED
  96.                     )
  97.                 );
  98.             }
  100.             if ($violations->count() > 0) {
  101.                 $event->getExceptions()->add(new WriteConstraintViolationException($violations, $command->getPath()));
  102.             }
  103.         }
  104.     }
  106.     /**
  107.      * @return array<string, mixed>
  108.      */
  109.     private function findShippingMethod(string $shippingMethodId): array
  110.     {
  111.         $shippingMethod = $this->connection->executeQuery(
  112.             'SELECT `tax_type`, `tax_id` FROM `shipping_method` WHERE `id` = :id',
  113.             ['id' => $shippingMethodId]
  114.         );
  116.         return $shippingMethod->fetchAssociative() ?: [];
  117.     }
  119.     /**
  120.      * @param array<string, mixed> $parameters
  121.      */
  122.     private function buildViolation(
  123.         string $messageTemplate,
  124.         array $parameters,
  125.         string $propertyPath,
  126.         string $invalidValue,
  127.         string $code
  128.     ): ConstraintViolationInterface {
  129.         return new ConstraintViolation(
  130.             str_replace(array_keys($parameters), array_values($parameters), $messageTemplate),
  131.             $messageTemplate,
  132.             $parameters,
  133.             null,
  134.             $propertyPath,
  135.             $invalidValue,
  136.             null,
  137.             $code
  138.         );
  139.     }
  141.     /**
  142.      * Gets a value from an array. It also does clean checks if
  143.      * the key is set, and also provides the option for default values.
  144.      *
  145.      * @param array<string, mixed> $data  the data array
  146.      * @param string               $key   the requested key in the array
  147.      * @param array<string, mixed> $dbRow the db row of from the database
  148.      *
  149.      * @return mixed the object found in the key, or the default value
  150.      */
  151.     private function getValue(array $data, string $key, array $dbRow)
  152.     {
  153.         // try in our actual data set
  154.         if (isset($data[$key])) {
  155.             return $data[$key];
  156.         }
  158.         // try in our db row fallback
  159.         if (isset($dbRow[$key])) {
  160.             return $dbRow[$key];
  161.         }
  163.         // use default
  164.         return null;
  165.     }
  166. }