src/Core/Framework/DataAbstractionLayer/FieldSerializer/AbstractFieldSerializer.php line 51

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\DataAbstractionLayer\FieldSerializer;
  5. use Shopware\Core\Defaults;
  6. use Shopware\Core\Framework\DataAbstractionLayer\DefinitionInstanceRegistry;
  7. use Shopware\Core\Framework\DataAbstractionLayer\EntityTranslationDefinition;
  8. use Shopware\Core\Framework\DataAbstractionLayer\Field\Field;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\AllowHtml;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Inherited;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Required;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Write\DataStack\KeyValuePair;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Write\EntityExistence;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Write\WriteParameterBag;
  15. use Shopware\Core\Framework\Log\Package;
  16. use Shopware\Core\Framework\Util\HtmlSanitizer;
  17. use Shopware\Core\Framework\Validation\WriteConstraintViolationException;
  18. use Symfony\Component\Validator\Constraint;
  19. use Symfony\Component\Validator\ConstraintViolation;
  20. use Symfony\Component\Validator\ConstraintViolationList;
  21. use Symfony\Component\Validator\Validator\ValidatorInterface;
  23. /**
  24.  * @internal
  25.  */
  26. #[Package('core')]
  27. abstract class AbstractFieldSerializer implements FieldSerializerInterface
  28. {
  29.     /**
  30.      * @var array<Constraint[]>
  31.      */
  32.     private array $cachedConstraints = [];
  34.     public function __construct(protected ValidatorInterface $validator, protected DefinitionInstanceRegistry $definitionRegistry)
  35.     {
  36.     }
  38.     public function normalize(Field $field, array $data, WriteParameterBag $parameters): array
  39.     {
  40.         return $data;
  41.     }
  43.     protected function validate(
  44.         array $constraints,
  45.         KeyValuePair $data,
  46.         string $path
  47.     ): void {
  48.         $violationList = new ConstraintViolationList();
  50.         foreach ($constraints as $constraint) {
  51.             $violations = $this->validator->validate($data->getValue(), $constraint);
  53.             /** @var ConstraintViolation $violation */
  54.             foreach ($violations as $violation) {
  55.                 $fieldName = $data->getKey();
  57.                 // correct pointer for json fields with pre-defined structure
  58.                 if ($violation->getPropertyPath()) {
  59.                     $property = str_replace('][', '/', $violation->getPropertyPath());
  60.                     $property = trim($property, '][');
  61.                     $fieldName .= '/' . $property;
  62.                 }
  64.                 $fieldName = '/' . $fieldName;
  66.                 $violationList->add(
  67.                     new ConstraintViolation(
  68.                         $violation->getMessage(),
  69.                         $violation->getMessageTemplate(),
  70.                         $violation->getParameters(),
  71.                         $violation->getRoot(),
  72.                         $fieldName,
  73.                         $violation->getInvalidValue(),
  74.                         $violation->getPlural(),
  75.                         $violation->getCode(),
  76.                         $violation->getConstraint(),
  77.                         $violation->getCause()
  78.                     )
  79.                 );
  80.             }
  81.         }
  83.         if (\count($violationList)) {
  84.             throw new WriteConstraintViolationException($violationList, $path);
  85.         }
  86.     }
  88.     protected function requiresValidation(
  89.         Field $field,
  90.         EntityExistence $existence,
  91.         $value,
  92.         WriteParameterBag $parameters
  93.     ): bool {
  94.         if ($value !== null) {
  95.             return true;
  96.         }
  98.         if ($existence->isChild() && $this->isInherited($field, $parameters)) {
  99.             return false;
  100.         }
  102.         if ($existence->hasEntityName()
  103.             && $this->definitionRegistry->getByEntityName($existence->getEntityName()) instanceof EntityTranslationDefinition
  104.             && $parameters->getCurrentWriteLanguageId() !== Defaults::LANGUAGE_SYSTEM
  105.         ) {
  106.             return false;
  107.         }
  109.         return $field->is(Required::class);
  110.     }
  112.     protected function isInherited(Field $field, WriteParameterBag $parameters): bool
  113.     {
  114.         if ($parameters->getDefinition()->isInheritanceAware()) {
  115.             return $field->is(Inherited::class);
  116.         }
  118.         if (!$parameters->getDefinition() instanceof EntityTranslationDefinition) {
  119.             return false;
  120.         }
  122.         $parent = $parameters->getDefinition()->getParentDefinition();
  124.         $field = $parent->getFields()->get($field->getPropertyName());
  126.         return $field->is(Inherited::class);
  127.     }
  129.     protected function validateIfNeeded(Field $field, EntityExistence $existence, KeyValuePair $data, WriteParameterBag $parameters): void
  130.     {
  131.         if (!$this->requiresValidation($field, $existence, $data->getValue(), $parameters)) {
  132.             return;
  133.         }
  135.         $constraints = $this->getCachedConstraints($field);
  137.         $this->validate($constraints, $data, $parameters->getPath());
  138.     }
  140.     /**
  141.      * @return Constraint[]
  142.      */
  143.     protected function getConstraints(Field $field): array
  144.     {
  145.         return [];
  146.     }
  148.     /**
  149.      * @return Constraint[]
  150.      */
  151.     protected function getCachedConstraints(Field $field): array
  152.     {
  153.         $key = $field->getPropertyName() . spl_object_id($field);
  155.         if (\array_key_exists($key, $this->cachedConstraints)) {
  156.             return $this->cachedConstraints[$key];
  157.         }
  159.         return $this->cachedConstraints[$key] = $this->getConstraints($field);
  160.     }
  162.     protected function sanitize(HtmlSanitizer $sanitizer, KeyValuePair $data, Field $field, EntityExistence $existence): ?string
  163.     {
  164.         if ($data->getValue() === null) {
  165.             return null;
  166.         }
  168.         if (!$field->is(AllowHtml::class)) {
  169.             return strip_tags((string) $data->getValue());
  170.         }
  172.         $flag = $field->getFlag(AllowHtml::class);
  174.         if ($flag instanceof AllowHtml && $flag->isSanitized()) {
  175.             $fieldKey = sprintf('%s.%s', (string) $existence->getEntityName(), $field->getPropertyName());
  177.             return $sanitizer->sanitize((string) $data->getValue(), [], false, $fieldKey);
  178.         }
  180.         return (string) $data->getValue();
  181.     }
  182. }