vendor/gedmo/doctrine-extensions/src/Translatable/Mapping/Event/Adapter/ORM.php line 104

  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\Event\Adapter;
  12. use Doctrine\Common\Proxy\Proxy;
  13. use Doctrine\DBAL\Types\Type;
  14. use Doctrine\DBAL\Types\Types;
  15. use Doctrine\ORM\Mapping\ClassMetadataInfo;
  16. use Gedmo\Exception\RuntimeException;
  17. use Gedmo\Mapping\Event\Adapter\ORM as BaseAdapterORM;
  18. use Gedmo\Tool\Wrapper\AbstractWrapper;
  19. use Gedmo\Translatable\Entity\MappedSuperclass\AbstractPersonalTranslation;
  20. use Gedmo\Translatable\Entity\Translation;
  21. use Gedmo\Translatable\Mapping\Event\TranslatableAdapter;
  23. /**
  24.  * Doctrine event adapter for ORM adapted
  25.  * for Translatable behavior
  26.  *
  27.  * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
  28.  */
  29. final class ORM extends BaseAdapterORM implements TranslatableAdapter
  30. {
  31.     public function usesPersonalTranslation($translationClassName)
  32.     {
  33.         return $this
  34.             ->getObjectManager()
  35.             ->getClassMetadata($translationClassName)
  36.             ->getReflectionClass()
  37.             ->isSubclassOf(AbstractPersonalTranslation::class)
  38.         ;
  39.     }
  41.     public function getDefaultTranslationClass()
  42.     {
  43.         return Translation::class;
  44.     }
  46.     public function loadTranslations($object, $translationClass, $locale, $objectClass)
  47.     {
  48.         $em = $this->getObjectManager();
  49.         $wrapped = AbstractWrapper::wrap($object, $em);
  50.         $result = [];
  51.         if ($this->usesPersonalTranslation($translationClass)) {
  52.             // first try to load it using collection
  53.             $found = false;
  54.             $metadata = $wrapped->getMetadata();
  55.             assert($metadata instanceof ClassMetadataInfo);
  56.             foreach ($metadata->getAssociationMappings() as $assoc) {
  57.                 $isRightCollection = $assoc['targetEntity'] === $translationClass
  58.                     && 'object' === $assoc['mappedBy']
  59.                     && ClassMetadataInfo::ONE_TO_MANY === $assoc['type']
  60.                 ;
  61.                 if ($isRightCollection) {
  62.                     $collection = $wrapped->getPropertyValue($assoc['fieldName']);
  63.                     foreach ($collection as $trans) {
  64.                         if ($trans->getLocale() === $locale) {
  65.                             $result[] = [
  66.                                 'field' => $trans->getField(),
  67.                                 'content' => $trans->getContent(),
  68.                             ];
  69.                         }
  70.                     }
  71.                     $found = true;
  73.                     break;
  74.                 }
  75.             }
  76.             // if collection is not set, fetch it through relation
  77.             if (!$found) {
  78.                 $dql = 'SELECT t.content, t.field FROM '.$translationClass.' t';
  79.                 $dql .= ' WHERE t.locale = :locale';
  80.                 $dql .= ' AND t.object = :object';
  82.                 $q = $em->createQuery($dql);
  83.                 $q->setParameters([
  84.                     'object' => $object,
  85.                     'locale' => $locale,
  86.                 ]);
  87.                 $result = $q->getArrayResult();
  88.             }
  89.         } else {
  90.             // load translated content for all translatable fields
  91.             $objectId = $this->foreignKey($wrapped->getIdentifier(), $translationClass);
  92.             // construct query
  93.             $dql = 'SELECT t.content, t.field FROM '.$translationClass.' t';
  94.             $dql .= ' WHERE t.foreignKey = :objectId';
  95.             $dql .= ' AND t.locale = :locale';
  96.             $dql .= ' AND t.objectClass = :objectClass';
  97.             // fetch results
  98.             $q = $em->createQuery($dql);
  99.             $q->setParameters([
  100.                 'objectId' => $objectId,
  101.                 'locale' => $locale,
  102.                 'objectClass' => $objectClass,
  103.             ]);
  104.             $result = $q->getArrayResult();
  105.         }
  107.         return $result;
  108.     }
  110.     public function findTranslation(AbstractWrapper $wrapped, $locale, $field, $translationClass, $objectClass)
  111.     {
  112.         $em = $this->getObjectManager();
  113.         // first look in identityMap, will save one SELECT query
  114.         foreach ($em->getUnitOfWork()->getIdentityMap() as $className => $objects) {
  115.             if ($className === $translationClass) {
  116.                 foreach ($objects as $trans) {
  117.                     $isRequestedTranslation = !$trans instanceof Proxy
  118.                         && $trans->getLocale() === $locale
  119.                         && $trans->getField() === $field
  120.                     ;
  121.                     if ($isRequestedTranslation) {
  122.                         if ($this->usesPersonalTranslation($translationClass)) {
  123.                             $isRequestedTranslation = $trans->getObject() === $wrapped->getObject();
  124.                         } else {
  125.                             $objectId = $this->foreignKey($wrapped->getIdentifier(), $translationClass);
  126.                             $isRequestedTranslation = $trans->getForeignKey() === $objectId
  127.                                 && $trans->getObjectClass() === $wrapped->getMetadata()->getName()
  128.                             ;
  129.                         }
  130.                     }
  131.                     if ($isRequestedTranslation) {
  132.                         return $trans;
  133.                     }
  134.                 }
  135.             }
  136.         }
  138.         $qb = $em->createQueryBuilder();
  139.         $qb->select('trans')
  140.             ->from($translationClass, 'trans')
  141.             ->where(
  142.                 'trans.locale = :locale',
  143.                 'trans.field = :field'
  144.             )
  145.             ->setParameter('locale', $locale)
  146.             ->setParameter('field', $field)
  147.         ;
  149.         if ($this->usesPersonalTranslation($translationClass)) {
  150.             $qb->andWhere('trans.object = :object');
  151.             if ($wrapped->getIdentifier()) {
  152.                 $qb->setParameter('object', $wrapped->getObject());
  153.             } else {
  154.                 $qb->setParameter('object', null);
  155.             }
  156.         } else {
  157.             $qb->andWhere('trans.foreignKey = :objectId');
  158.             $qb->andWhere('trans.objectClass = :objectClass');
  159.             $qb->setParameter('objectId', $this->foreignKey($wrapped->getIdentifier(), $translationClass));
  160.             $qb->setParameter('objectClass', $objectClass);
  161.         }
  162.         $q = $qb->getQuery();
  163.         $q->setMaxResults(1);
  165.         return $q->getOneOrNullResult();
  166.     }
  168.     public function removeAssociatedTranslations(AbstractWrapper $wrapped, $transClass, $objectClass)
  169.     {
  170.         $qb = $this
  171.             ->getObjectManager()
  172.             ->createQueryBuilder()
  173.             ->delete($transClass, 'trans')
  174.         ;
  175.         if ($this->usesPersonalTranslation($transClass)) {
  176.             $qb->where('trans.object = :object');
  177.             $qb->setParameter('object', $wrapped->getObject());
  178.         } else {
  179.             $qb->where(
  180.                 'trans.foreignKey = :objectId',
  181.                 'trans.objectClass = :class'
  182.             );
  183.             $qb->setParameter('objectId', $this->foreignKey($wrapped->getIdentifier(), $transClass));
  184.             $qb->setParameter('class', $objectClass);
  185.         }
  187.         return $qb->getQuery()->getSingleScalarResult();
  188.     }
  190.     public function insertTranslationRecord($translation)
  191.     {
  192.         $em = $this->getObjectManager();
  193.         $meta = $em->getClassMetadata(get_class($translation));
  194.         $data = [];
  196.         foreach ($meta->getReflectionProperties() as $fieldName => $reflProp) {
  197.             if (!$meta->isIdentifier($fieldName)) {
  198.                 $data[$meta->getColumnName($fieldName)] = $reflProp->getValue($translation);
  199.             }
  200.         }
  202.         $table = $meta->getTableName();
  203.         if (!$em->getConnection()->insert($table, $data)) {
  204.             throw new RuntimeException('Failed to insert new Translation record');
  205.         }
  206.     }
  208.     public function getTranslationValue($object, $field, $value = false)
  209.     {
  210.         $em = $this->getObjectManager();
  211.         $wrapped = AbstractWrapper::wrap($object, $em);
  212.         $meta = $wrapped->getMetadata();
  213.         $type = Type::getType($meta->getTypeOfField($field));
  214.         if (false === $value) {
  215.             $value = $wrapped->getPropertyValue($field);
  216.         }
  218.         return $type->convertToDatabaseValue($value, $em->getConnection()->getDatabasePlatform());
  219.     }
  221.     public function setTranslationValue($object, $field, $value)
  222.     {
  223.         $em = $this->getObjectManager();
  224.         $wrapped = AbstractWrapper::wrap($object, $em);
  225.         $meta = $wrapped->getMetadata();
  226.         $type = Type::getType($meta->getTypeOfField($field));
  227.         $value = $type->convertToPHPValue($value, $em->getConnection()->getDatabasePlatform());
  228.         $wrapped->setPropertyValue($field, $value);
  229.     }
  231.     /**
  232.      * Transforms foreing key of translation to appropriate PHP value
  233.      * to prevent database level cast
  234.      *
  235.      * @param mixed  $key       foreign key value
  236.      * @param string $className translation class name
  237.      *
  238.      * @phpstan-param class-string $className translation class name
  239.      *
  240.      * @return int|string transformed foreign key
  241.      */
  242.     private function foreignKey($key, string $className)
  243.     {
  244.         $em = $this->getObjectManager();
  245.         $meta = $em->getClassMetadata($className);
  246.         $type = Type::getType($meta->getTypeOfField('foreignKey'));
  247.         switch ($type->getName()) {
  248.             case Types::BIGINT:
  249.             case Types::INTEGER:
  250.             case Types::SMALLINT:
  251.                 return (int) $key;
  252.             default:
  253.                 return (string) $key;
  254.         }
  255.     }
  256. }