vendor/gedmo/doctrine-extensions/src/Translatable/Mapping/Driver/Attribute.php line 60

  1. <?php
  3. /*
  4.  * This file is part of the Doctrine Behavioral Extensions package.
  5.  * (c) Gediminas Morkevicius <gediminas.morkevicius@gmail.com> http://www.gediminasm.org
  6.  * For the full copyright and license information, please view the LICENSE
  7.  * file that was distributed with this source code.
  8.  */
  10. namespace Gedmo\Translatable\Mapping\Driver;
  12. use Gedmo\Exception\InvalidMappingException;
  13. use Gedmo\Mapping\Annotation\Language;
  14. use Gedmo\Mapping\Annotation\Locale;
  15. use Gedmo\Mapping\Annotation\Translatable;
  16. use Gedmo\Mapping\Annotation\TranslationEntity;
  17. use Gedmo\Mapping\Driver\AbstractAnnotationDriver;
  19. /**
  20.  * Mapping driver for the translatable extension which reads extended metadata from annotations on a translatable class.
  21.  *
  22.  * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
  23.  *
  24.  * @internal
  25.  */
  26. class Attribute extends AbstractAnnotationDriver
  27. {
  28.     /**
  29.      * Mapping object to configure the translation model for a translatable class.
  30.      */
  31.     public const ENTITY_CLASS = TranslationEntity::class;
  33.     /**
  34.      * Mapping object to identify a field as translatable in a translatable class.
  35.      */
  36.     public const TRANSLATABLE = Translatable::class;
  38.     /**
  39.      * Mapping object to identify the field which stores the locale or language for the translation.
  40.      *
  41.      * This object is an alias of {@see self::LANGUAGE}
  42.      */
  43.     public const LOCALE = Locale::class;
  45.     /**
  46.      * Mapping object to identify the field which stores the locale or language for the translation.
  47.      *
  48.      * This object is an alias of {@see self::LOCALE}
  49.      */
  50.     public const LANGUAGE = Language::class;
  52.     public function readExtendedMetadata($meta, array &$config)
  53.     {
  54.         $class = $this->getMetaReflectionClass($meta);
  56.         // class annotations
  57.         if ($annot = $this->reader->getClassAnnotation($class, self::ENTITY_CLASS)) {
  58.             \assert($annot instanceof TranslationEntity);
  60.             if (!$cl = $this->getRelatedClassName($meta, $annot->class)) {
  61.                 throw new InvalidMappingException("Translation class: {$annot->class} does not exist.");
  62.             }
  64.             $config['translationClass'] = $cl;
  65.         }
  67.         // property annotations
  68.         foreach ($class->getProperties() as $property) {
  69.             if ($meta->isMappedSuperclass && !$property->isPrivate()
  70.                 || $meta->isInheritedField($property->name)
  71.                 || isset($meta->associationMappings[$property->name]['inherited'])
  72.             ) {
  73.                 continue;
  74.             }
  76.             // translatable property
  77.             if ($translatable = $this->reader->getPropertyAnnotation($property, self::TRANSLATABLE)) {
  78.                 \assert($translatable instanceof Translatable);
  80.                 $field = $property->getName();
  82.                 if (!$meta->hasField($field)) {
  83.                     throw new InvalidMappingException("Unable to find translatable [{$field}] as mapped property in entity - {$meta->getName()}");
  84.                 }
  86.                 // fields cannot be overrided and throws mapping exception
  87.                 $config['fields'][] = $field;
  89.                 if (isset($translatable->fallback)) {
  90.                     $config['fallback'][$field] = $translatable->fallback;
  91.                 }
  92.             }
  94.             // locale property
  95.             if ($this->reader->getPropertyAnnotation($property, self::LOCALE)) {
  96.                 $field = $property->getName();
  98.                 if ($meta->hasField($field)) {
  99.                     throw new InvalidMappingException("Locale field [{$field}] should not be mapped as column property in entity - {$meta->getName()}, since it makes no sense");
  100.                 }
  102.                 $config['locale'] = $field;
  103.             } elseif ($this->reader->getPropertyAnnotation($property, self::LANGUAGE)) {
  104.                 $field = $property->getName();
  106.                 if ($meta->hasField($field)) {
  107.                     throw new InvalidMappingException("Language field [{$field}] should not be mapped as column property in entity - {$meta->getName()}, since it makes no sense");
  108.                 }
  110.                 $config['locale'] = $field;
  111.             }
  112.         }
  114.         // Embedded entity
  115.         if (property_exists($meta, 'embeddedClasses') && $meta->embeddedClasses) {
  116.             foreach ($meta->embeddedClasses as $propertyName => $embeddedClassInfo) {
  117.                 if ($meta->isInheritedEmbeddedClass($propertyName)) {
  118.                     continue;
  119.                 }
  121.                 $embeddedClass = new \ReflectionClass($embeddedClassInfo['class']);
  123.                 foreach ($embeddedClass->getProperties() as $embeddedProperty) {
  124.                     if ($translatable = $this->reader->getPropertyAnnotation($embeddedProperty, self::TRANSLATABLE)) {
  125.                         \assert($translatable instanceof Translatable);
  127.                         $field = $propertyName.'.'.$embeddedProperty->getName();
  129.                         $config['fields'][] = $field;
  131.                         if (isset($translatable->fallback)) {
  132.                             $config['fallback'][$field] = $translatable->fallback;
  133.                         }
  134.                     }
  135.                 }
  136.             }
  137.         }
  139.         if (!$meta->isMappedSuperclass && $config) {
  140.             if (is_array($meta->getIdentifier()) && count($meta->getIdentifier()) > 1) {
  141.                 throw new InvalidMappingException("Translatable does not support composite identifiers in class - {$meta->getName()}");
  142.             }
  143.         }
  145.         return $config;
  146.     }
  147. }