vendor/gedmo/doctrine-extensions/src/Translatable/Mapping/Driver/Annotation.php line 53

Open in your IDE?
  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.  * This is an annotation mapping driver for Translatable
  21.  * behavioral extension. Used for extraction of extended
  22.  * metadata from Annotations specifically for Translatable
  23.  * extension.
  24.  *
  25.  * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
  26.  *
  27.  * @internal
  28.  */
  29. class Annotation extends AbstractAnnotationDriver
  30. {
  31.     /**
  32.      * Annotation to identity translation entity to be used for translation storage
  33.      */
  34.     public const ENTITY_CLASS = TranslationEntity::class;
  36.     /**
  37.      * Annotation to identify field as translatable
  38.      */
  39.     public const TRANSLATABLE = Translatable::class;
  41.     /**
  42.      * Annotation to identify field which can store used locale or language
  43.      * alias is LANGUAGE
  44.      */
  45.     public const LOCALE = Locale::class;
  47.     /**
  48.      * Annotation to identify field which can store used locale or language
  49.      * alias is LOCALE
  50.      */
  51.     public const LANGUAGE = Language::class;
  53.     public function readExtendedMetadata($meta, array &$config)
  54.     {
  55.         $class = $this->getMetaReflectionClass($meta);
  56.         // class annotations
  57.         if ($annot = $this->reader->getClassAnnotation($class, self::ENTITY_CLASS)) {
  58.             if (!$cl = $this->getRelatedClassName($meta, $annot->class)) {
  59.                 throw new InvalidMappingException("Translation class: {$annot->class} does not exist.");
  60.             }
  61.             $config['translationClass'] = $cl;
  62.         }
  64.         // property annotations
  65.         foreach ($class->getProperties() as $property) {
  66.             if ($meta->isMappedSuperclass && !$property->isPrivate() ||
  67.                 $meta->isInheritedField($property->name) ||
  68.                 isset($meta->associationMappings[$property->name]['inherited'])
  69.             ) {
  70.                 continue;
  71.             }
  72.             // translatable property
  73.             if ($translatable = $this->reader->getPropertyAnnotation($property, self::TRANSLATABLE)) {
  74.                 $field = $property->getName();
  75.                 if (!$meta->hasField($field)) {
  76.                     throw new InvalidMappingException("Unable to find translatable [{$field}] as mapped property in entity - {$meta->getName()}");
  77.                 }
  78.                 // fields cannot be overrided and throws mapping exception
  79.                 $config['fields'][] = $field;
  80.                 if (isset($translatable->fallback)) {
  81.                     $config['fallback'][$field] = $translatable->fallback;
  82.                 }
  83.             }
  84.             // locale property
  85.             if ($this->reader->getPropertyAnnotation($property, self::LOCALE)) {
  86.                 $field = $property->getName();
  87.                 if ($meta->hasField($field)) {
  88.                     throw new InvalidMappingException("Locale field [{$field}] should not be mapped as column property in entity - {$meta->getName()}, since it makes no sense");
  89.                 }
  90.                 $config['locale'] = $field;
  91.             } elseif ($this->reader->getPropertyAnnotation($property, self::LANGUAGE)) {
  92.                 $field = $property->getName();
  93.                 if ($meta->hasField($field)) {
  94.                     throw new InvalidMappingException("Language field [{$field}] should not be mapped as column property in entity - {$meta->getName()}, since it makes no sense");
  95.                 }
  96.                 $config['locale'] = $field;
  97.             }
  98.         }
  100.         // Embedded entity
  101.         if (property_exists($meta, 'embeddedClasses') && $meta->embeddedClasses) {
  102.             foreach ($meta->embeddedClasses as $propertyName => $embeddedClassInfo) {
  103.                 if ($meta->isInheritedEmbeddedClass($propertyName)) {
  104.                     continue;
  105.                 }
  106.                 $embeddedClass = new \ReflectionClass($embeddedClassInfo['class']);
  107.                 foreach ($embeddedClass->getProperties() as $embeddedProperty) {
  108.                     if ($translatable = $this->reader->getPropertyAnnotation($embeddedProperty, self::TRANSLATABLE)) {
  109.                         $field = $propertyName.'.'.$embeddedProperty->getName();
  111.                         $config['fields'][] = $field;
  112.                         if (isset($translatable->fallback)) {
  113.                             $config['fallback'][$field] = $translatable->fallback;
  114.                         }
  115.                     }
  116.                 }
  117.             }
  118.         }
  120.         if (!$meta->isMappedSuperclass && $config) {
  121.             if (is_array($meta->getIdentifier()) && count($meta->getIdentifier()) > 1) {
  122.                 throw new InvalidMappingException("Translatable does not support composite identifiers in class - {$meta->getName()}");
  123.             }
  124.         }
  125.     }
  126. }