vendor/shopware/core/Framework/DataAbstractionLayer/FieldSerializer/JsonFieldSerializer.php line 37

  1. <?php
  2. declare(strict_types=1);
  4. namespace Shopware\Core\Framework\DataAbstractionLayer\FieldSerializer;
  6. use Shopware\Core\Defaults;
  7. use Shopware\Core\Framework\DataAbstractionLayer\Exception\InvalidSerializerFieldException;
  8. use Shopware\Core\Framework\DataAbstractionLayer\Field\DateField;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Field\Field;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Required;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Field\JsonField;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Write\DataStack\DataStack;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Write\DataStack\KeyValuePair;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Write\EntityExistence;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Write\FieldException\UnexpectedFieldException;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Write\FieldException\WriteFieldException;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Write\WriteParameterBag;
  18. use Shopware\Core\Framework\Feature;
  19. use Shopware\Core\Framework\Log\Package;
  20. use Shopware\Core\Framework\Util\Json;
  21. use Symfony\Component\Validator\Constraints\NotNull;
  22. use Symfony\Component\Validator\Constraints\Type;
  24. /**
  25.  * @internal
  26.  */
  27. #[Package('core')]
  28. class JsonFieldSerializer extends AbstractFieldSerializer
  29. {
  30.     /**
  31.      * @deprecated tag:v6.6.0 - Will be removed, use \Shopware\Core\Framework\Util\Json::encode instead
  32.      */
  33.     public static function encodeJson(mixed $value, int $options = \JSON_UNESCAPED_UNICODE | \JSON_PRESERVE_ZERO_FRACTION | \JSON_THROW_ON_ERROR | \JSON_INVALID_UTF8_IGNORE): string
  34.     {
  35.         Feature::triggerDeprecationOrThrow(
  36.             'v6.6.0.0',
  37.             Feature::deprecatedMethodMessage(self::class, __METHOD__, 'v6.6.0.0', Json::class . '::encode')
  38.         );
  40.         return (string) json_encode($value, $options);
  41.     }
  43.     public function encode(
  44.         Field $field,
  45.         EntityExistence $existence,
  46.         KeyValuePair $data,
  47.         WriteParameterBag $parameters
  48.     ): \Generator {
  49.         if (!$field instanceof JsonField) {
  50.             throw new InvalidSerializerFieldException(JsonField::class, $field);
  51.         }
  53.         $this->validateIfNeeded($field, $existence, $data, $parameters);
  55.         $value = $data->getValue() ?? $field->getDefault();
  57.         if ($value !== null && !empty($field->getPropertyMapping())) {
  58.             $value = $this->validateMapping($field, $value, $parameters);
  59.         }
  61.         if ($value !== null) {
  62.             $value = Json::encode($value);
  63.         }
  65.         yield $field->getStorageName() => $value;
  66.     }
  68.     public function decode(Field $field, mixed $value): mixed
  69.     {
  70.         if (!$field instanceof JsonField) {
  71.             throw new InvalidSerializerFieldException(JsonField::class, $field);
  72.         }
  74.         if ($value === null) {
  75.             return $field->getDefault();
  76.         }
  78.         $raw = json_decode((string) $value, true);
  79.         $decoded = $raw;
  80.         if (empty($field->getPropertyMapping())) {
  81.             return $raw;
  82.         }
  84.         foreach ($field->getPropertyMapping() as $embedded) {
  85.             $key = $embedded->getPropertyName();
  86.             if (!isset($raw[$key])) {
  87.                 continue;
  88.             }
  89.             $value = $embedded instanceof JsonField
  90.                 ? Json::encode($raw[$key])
  91.                 : $raw[$key];
  93.             $embedded->compile($this->definitionRegistry);
  94.             $decodedValue = $embedded->getSerializer()->decode($embedded, $value);
  95.             if ($decodedValue instanceof \DateTimeInterface) {
  96.                 $format = $embedded instanceof DateField ? Defaults::STORAGE_DATE_FORMAT : \DATE_ATOM;
  97.                 $decodedValue = $decodedValue->format($format);
  98.             }
  100.             $decoded[$key] = $decodedValue;
  101.         }
  103.         return $decoded;
  104.     }
  106.     protected function getConstraints(Field $field): array
  107.     {
  108.         return [
  109.             new Type('array'),
  110.             new NotNull(),
  111.         ];
  112.     }
  114.     protected function validateMapping(
  115.         JsonField $field,
  116.         array $data,
  117.         WriteParameterBag $parameters
  118.     ): array {
  119.         if (\array_key_exists('_class', $data)) {
  120.             unset($data['_class']);
  121.         }
  123.         $stack = new DataStack($data);
  124.         $existence = new EntityExistence(null, [], false, false, false, []);
  125.         $fieldPath = $parameters->getPath() . '/' . $field->getPropertyName();
  127.         $propertyKeys = array_map(fn (Field $field) => $field->getPropertyName(), $field->getPropertyMapping());
  129.         // If a mapping is defined, you should not send properties that are undefined.
  130.         // Sending undefined fields will throw an UnexpectedFieldException
  131.         $keyDiff = array_diff(array_keys($data), $propertyKeys);
  132.         if (\count($keyDiff)) {
  133.             foreach ($keyDiff as $fieldName) {
  134.                 $parameters->getContext()->getExceptions()->add(
  135.                     new UnexpectedFieldException($fieldPath . '/' . $fieldName, (string) $fieldName)
  136.                 );
  137.             }
  138.         }
  140.         foreach ($field->getPropertyMapping() as $nestedField) {
  141.             $kvPair = $stack->pop($nestedField->getPropertyName());
  143.             if ($kvPair === null) {
  144.                 // The writer updates the whole field, so there is no possibility to update
  145.                 // "some" fields. To enable a merge, we have to respect the $existence state
  146.                 // for correct constraint validation. In addition the writer has to be rewritten
  147.                 // in order to handle merges.
  148.                 if (!$nestedField->is(Required::class)) {
  149.                     continue;
  150.                 }
  152.                 $kvPair = new KeyValuePair($nestedField->getPropertyName(), null, true);
  153.             }
  155.             $nestedParams = new WriteParameterBag(
  156.                 $parameters->getDefinition(),
  157.                 $parameters->getContext(),
  158.                 $parameters->getPath() . '/' . $field->getPropertyName(),
  159.                 $parameters->getCommandQueue()
  160.             );
  162.             /*
  163.              * Don't call `encode()` or `validateIfNeeded()` on nested JsonFields if they are not typed.
  164.              * This also allows directly storing non-array values like strings.
  165.              */
  166.             if ($nestedField instanceof JsonField && empty($nestedField->getPropertyMapping())) {
  167.                 // Validate required flag manually
  168.                 if ($nestedField->is(Required::class)) {
  169.                     $this->validate([new NotNull()], $kvPair, $nestedParams->getPath());
  170.                 }
  171.                 $stack->update($kvPair->getKey(), $kvPair->getValue());
  173.                 continue;
  174.             }
  176.             try {
  177.                 $nestedField->compile($this->definitionRegistry);
  178.                 $encoded = $nestedField->getSerializer()->encode($nestedField, $existence, $kvPair, $nestedParams);
  180.                 foreach ($encoded as $fieldKey => $fieldValue) {
  181.                     if ($nestedField instanceof JsonField && $fieldValue !== null) {
  182.                         $fieldValue = json_decode((string) $fieldValue, true, 512, \JSON_THROW_ON_ERROR);
  183.                     }
  185.                     $stack->update($fieldKey, $fieldValue);
  186.                 }
  187.             } catch (WriteFieldException $exception) {
  188.                 $parameters->getContext()->getExceptions()->add($exception);
  189.             }
  190.         }
  192.         return $stack->getResultAsArray();
  193.     }
  194. }