vendor/gedmo/doctrine-extensions/src/Loggable/Mapping/Driver/Annotation.php line 52

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\Loggable\Mapping\Driver;
  12. use Doctrine\ODM\MongoDB\Mapping\ClassMetadata as ClassMetadataODM;
  13. use Doctrine\Persistence\Mapping\ClassMetadata;
  14. use Gedmo\Exception\InvalidMappingException;
  15. use Gedmo\Mapping\Annotation\Loggable;
  16. use Gedmo\Mapping\Annotation\Versioned;
  17. use Gedmo\Mapping\Driver\AbstractAnnotationDriver;
  19. /**
  20.  * This is an annotation mapping driver for Loggable
  21.  * behavioral extension. Used for extraction of extended
  22.  * metadata from Annotations specifically for Loggable
  23.  * extension.
  24.  *
  25.  * @author Boussekeyt Jules <jules.boussekeyt@gmail.com>
  26.  * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
  27.  *
  28.  * @internal
  29.  */
  30. class Annotation extends AbstractAnnotationDriver
  31. {
  32.     /**
  33.      * Annotation to define that this object is loggable
  34.      */
  35.     public const LOGGABLE = Loggable::class;
  37.     /**
  38.      * Annotation to define that this property is versioned
  39.      */
  40.     public const VERSIONED = Versioned::class;
  42.     public function validateFullMetadata(ClassMetadata $meta, array $config)
  43.     {
  44.         if ($config && $meta instanceof ClassMetadataODM && is_array($meta->getIdentifier()) && count($meta->getIdentifier()) > 1) {
  45.             throw new InvalidMappingException("Loggable does not support composite identifiers in class - {$meta->getName()}");
  46.         }
  47.         if (isset($config['versioned']) && !isset($config['loggable'])) {
  48.             throw new InvalidMappingException("Class must be annotated with Loggable annotation in order to track versioned fields in class - {$meta->getName()}");
  49.         }
  50.     }
  52.     public function readExtendedMetadata($meta, array &$config)
  53.     {
  54.         $class = $this->getMetaReflectionClass($meta);
  55.         // class annotations
  56.         if ($annot = $this->reader->getClassAnnotation($class, self::LOGGABLE)) {
  57.             $config['loggable'] = true;
  58.             if ($annot->logEntryClass) {
  59.                 if (!$cl = $this->getRelatedClassName($meta, $annot->logEntryClass)) {
  60.                     throw new InvalidMappingException("LogEntry class: {$annot->logEntryClass} does not exist.");
  61.                 }
  62.                 $config['logEntryClass'] = $cl;
  63.             }
  64.         }
  66.         // property annotations
  67.         foreach ($class->getProperties() as $property) {
  68.             $field = $property->getName();
  69.             if ($meta->isMappedSuperclass && !$property->isPrivate()) {
  70.                 continue;
  71.             }
  73.             // versioned property
  74.             if ($this->reader->getPropertyAnnotation($property, self::VERSIONED)) {
  75.                 if (!$this->isMappingValid($meta, $field)) {
  76.                     throw new InvalidMappingException("Cannot apply versioning to field [{$field}] as it is collection in object - {$meta->getName()}");
  77.                 }
  78.                 if (isset($meta->embeddedClasses[$field])) {
  79.                     $this->inspectEmbeddedForVersioned($field, $config, $meta);
  81.                     continue;
  82.                 }
  83.                 // fields cannot be overrided and throws mapping exception
  84.                 if (!in_array($field, $config['versioned'] ?? [], true)) {
  85.                     $config['versioned'][] = $field;
  86.                 }
  87.             }
  88.         }
  90.         if (!$meta->isMappedSuperclass && $config) {
  91.             if ($meta instanceof ClassMetadataODM && is_array($meta->getIdentifier()) && count($meta->getIdentifier()) > 1) {
  92.                 throw new InvalidMappingException("Loggable does not support composite identifiers in class - {$meta->getName()}");
  93.             }
  94.             if ($this->isClassAnnotationInValid($meta, $config)) {
  95.                 throw new InvalidMappingException("Class must be annotated with Loggable annotation in order to track versioned fields in class - {$meta->getName()}");
  96.             }
  97.         }
  99.         return $config;
  100.     }
  102.     /**
  103.      * @param string $field
  104.      *
  105.      * @return bool
  106.      */
  107.     protected function isMappingValid(ClassMetadata $meta, $field)
  108.     {
  109.         return false == $meta->isCollectionValuedAssociation($field);
  110.     }
  112.     /**
  113.      * @param array<string, mixed> $config
  114.      *
  115.      * @return bool
  116.      */
  117.     protected function isClassAnnotationInValid(ClassMetadata $meta, array &$config)
  118.     {
  119.         return isset($config['versioned']) && !isset($config['loggable']) && (!isset($meta->isEmbeddedClass) || !$meta->isEmbeddedClass);
  120.     }
  122.     /**
  123.      * Searches properties of embedded object for versioned fields
  124.      *
  125.      * @param array<string, mixed> $config
  126.      */
  127.     private function inspectEmbeddedForVersioned(string $field, array &$config, \Doctrine\ORM\Mapping\ClassMetadata $meta): void
  128.     {
  129.         $class = new \ReflectionClass($meta->embeddedClasses[$field]['class']);
  131.         // property annotations
  132.         foreach ($class->getProperties() as $property) {
  133.             // versioned property
  134.             if ($this->reader->getPropertyAnnotation($property, self::VERSIONED)) {
  135.                 $embeddedField = $field.'.'.$property->getName();
  136.                 $config['versioned'][] = $embeddedField;
  138.                 if (isset($meta->embeddedClasses[$embeddedField])) {
  139.                     $this->inspectEmbeddedForVersioned($embeddedField, $config, $meta);
  140.                 }
  141.             }
  142.         }
  143.     }
  144. }