vendor/symfony/serializer/Normalizer/MimeMessageNormalizer.php line 44

Open in your IDE?
  1. <?php
  3. /*
  4. * This file is part of the Symfony package.
  5. *
  6. * (c) Fabien Potencier <fabien@symfony.com>
  7. *
  8. * For the full copyright and license information, please view the LICENSE
  9. * file that was distributed with this source code.
  10. */
  12. namespace Symfony\Component\Serializer\Normalizer;
  14. use Symfony\Component\Mime\Address;
  15. use Symfony\Component\Mime\Header\HeaderInterface;
  16. use Symfony\Component\Mime\Header\Headers;
  17. use Symfony\Component\Mime\Header\UnstructuredHeader;
  18. use Symfony\Component\Mime\Message;
  19. use Symfony\Component\Mime\Part\AbstractPart;
  20. use Symfony\Component\Mime\RawMessage;
  21. use Symfony\Component\Serializer\SerializerAwareInterface;
  22. use Symfony\Component\Serializer\SerializerInterface;
  24. /**
  25. * Normalize Mime message classes.
  26. *
  27. * It forces the use of a PropertyNormalizer instance for normalization
  28. * of all data objects composing a Message.
  29. *
  30. * Emails using resources for any parts are not serializable.
  31. */
  32. final class MimeMessageNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface, CacheableSupportsMethodInterface
  33. {
  34. private $serializer;
  35. private $normalizer;
  36. private $headerClassMap;
  37. private $headersProperty;
  39. public function __construct(PropertyNormalizer $normalizer)
  40. {
  41. $this->normalizer = $normalizer;
  42. $this->headerClassMap = (new \ReflectionClassConstant(Headers::class, 'HEADER_CLASS_MAP'))->getValue();
  43. $this->headersProperty = new \ReflectionProperty(Headers::class, 'headers');
  44. $this->headersProperty->setAccessible(true);
  45. }
  47. public function setSerializer(SerializerInterface $serializer)
  48. {
  49. $this->serializer = $serializer;
  50. $this->normalizer->setSerializer($serializer);
  51. }
  53. /**
  54. * {@inheritdoc}
  55. */
  56. public function normalize($object, ?string $format = null, array $context = [])
  57. {
  58. if ($object instanceof Headers) {
  59. $ret = [];
  60. foreach ($this->headersProperty->getValue($object) as $name => $header) {
  61. $ret[$name] = $this->serializer->normalize($header, $format, $context);
  62. }
  64. return $ret;
  65. }
  67. $ret = $this->normalizer->normalize($object, $format, $context);
  69. if ($object instanceof AbstractPart) {
  70. $ret['class'] = \get_class($object);
  71. unset($ret['seekable'], $ret['cid'], $ret['handle']);
  72. }
  74. if ($object instanceof RawMessage && \array_key_exists('message', $ret) && null === $ret['message']) {
  75. unset($ret['message']);
  76. }
  78. return $ret;
  79. }
  81. /**
  82. * {@inheritdoc}
  83. */
  84. public function denormalize($data, string $type, ?string $format = null, array $context = [])
  85. {
  86. if (Headers::class === $type) {
  87. $ret = [];
  88. foreach ($data as $headers) {
  89. foreach ($headers as $header) {
  90. $ret[] = $this->serializer->denormalize($header, $this->headerClassMap[strtolower($header['name'])] ?? UnstructuredHeader::class, $format, $context);
  91. }
  92. }
  94. return new Headers(...$ret);
  95. }
  97. if (AbstractPart::class === $type) {
  98. $type = $data['class'];
  99. unset($data['class']);
  100. $data['headers'] = $this->serializer->denormalize($data['headers'], Headers::class, $format, $context);
  101. }
  103. return $this->normalizer->denormalize($data, $type, $format, $context);
  104. }
  106. /**
  107. * {@inheritdoc}
  108. */
  109. public function supportsNormalization($data, ?string $format = null): bool
  110. {
  111. return $data instanceof Message || $data instanceof Headers || $data instanceof HeaderInterface || $data instanceof Address || $data instanceof AbstractPart;
  112. }
  114. /**
  115. * {@inheritdoc}
  116. */
  117. public function supportsDenormalization($data, string $type, ?string $format = null): bool
  118. {
  119. return is_a($type, Message::class, true) || Headers::class === $type || AbstractPart::class === $type;
  120. }
  122. /**
  123. * {@inheritdoc}
  124. */
  125. public function hasCacheableSupportsMethod(): bool
  126. {
  127. return __CLASS__ === static::class;
  128. }
  129. }