src/Repository/BaseRepository.php line 88

Open in your IDE?
  1. <?php
  3. namespace App\Repository;
  5. use App\Misc\CustomEntityManager;
  6. use App\Service\CommonService;
  7. use AutoMapperPlus\AutoMapperInterface;
  8. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  9. use Doctrine\ORM\EntityManagerInterface;
  10. use Doctrine\ORM\QueryBuilder;
  11. use Doctrine\ORM\Tools\Pagination\Paginator;
  12. use Doctrine\Persistence\ManagerRegistry;
  13. use Gedmo\Translatable\Query\TreeWalker\TranslationWalker;
  14. use Symfony\Component\DependencyInjection\ContainerInterface;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Contracts\Cache\CacheInterface;
  18. /**
  19.  * @property AutoMapperInterface autoMapper
  20.  */
  21. class BaseRepository extends ServiceEntityRepository
  22. {
  23.     public function __construct(
  24.         protected ManagerRegistry $registry,
  25.         public EntityManagerInterface $entityManager,
  26.         public CommonService $commonService,
  27.         public CacheInterface $appCache,
  28.         public AutoMapperInterface $autoMapper,
  29.         public ContainerInterface $container
  30.     ) {
  31.         $thisName = $this->commonService->getClassName($this, true);
  32.         if ($thisName !== 'Base') {
  33.             parent::__construct($registry, 'App\Entity\\' . $thisName);
  34.         }
  35.         $this->_em = $entityManager;
  36.     }
  38.     public function getEntityManager()
  39.     {
  40.         return $this->_em;
  41.     }
  43.     public function save($entity, $inTransaction = false)
  44.     {
  45.         $this->getEntityManager()->persist($entity);
  46.         if (!$inTransaction) {
  47.             $this->getEntityManager()->flush();
  48.         }
  49.         return $entity;
  50.     }
  52.     public function persist($entity)
  53.     {
  54.         $this->getEntityManager()->persist($entity);
  55.     }
  57.     public function flush()
  58.     {
  59.         $this->getEntityManager()->flush();
  60.     }
  62.     public function clear()
  63.     {
  64.         $this->getEntityManager()->clear();
  65.     }
  67.     public function delete($entities, $inTransaction = false)
  68.     {
  69.         if (!is_array($entities)) {
  70.             $entities = [$entities];
  71.         }
  72.         foreach ($entities as $entity) {
  73.             $this->getEntityManager()->remove($entity);
  74.         }
  75.         if (!$inTransaction) {
  76.             $this->getEntityManager()->flush();
  77.         }
  78.     }
  80.     /**
  81.      * @return \Doctrine\DBAL\Connection
  82.      */
  83.     public function getConnection()
  84.     {
  85.         return $this->getEntityManager()->getConnection();
  86.     }
  88.     public function __get($propertyName)
  89.     {
  90.         if($propertyName == '_entityName') {
  91.             return parent::__get('_entityName');
  92.         }
  93.         preg_match('/([a-zA-Z0-9]+)Service/i', $propertyName, $serviceMatches);
  94.         if (count($serviceMatches) > 0) {
  95.             return $this
  96.                 ->container
  97.                 ->get('App\Service\\' . ucfirst($serviceMatches[1]) . 'Service');
  98.         }
  100.         preg_match('/([a-zA-Z0-9]+)Repo/i', $propertyName, $repositoryMatches);
  101.         if (count($repositoryMatches) > 0) {
  102.             return $this
  103.                 ->container
  104.                 ->get('App\Service\\' . ucfirst($repositoryMatches[1]) . 'Service')
  105.                 ->repository;
  106.         }
  108.         $entityName = $this->commonService->getClassName($this, true);
  109.         $cacheKey = 'Const.' . $entityName . '.' . $propertyName;
  110.         $cachedConstantItem = $this->appCache->getItem($cacheKey);
  112.         if ($cachedConstantItem->isHit()) {
  113.             return $cachedConstantItem->get();
  114.         }
  115.         if($propertyName !== '_entityName') {
  116.             $constant = null;
  117.             if(defined('App\Entity\\' . $entityName . '::' . $propertyName)) {
  118.                 $constant = constant('App\Entity\\' . $entityName . '::' . $propertyName);
  119.             }
  120.             if (!is_null($constant)) {
  121.                 $cachedConstantItem->set($constant);
  122.                 $this->appCache->save($cachedConstantItem);
  123.                 return $constant;
  124.             }
  125.         }
  126.         
  128.         $metas = $this->_em->getMetadataFactory()->getAllMetadata();
  129.         foreach ($metas as $meta) {
  130.             $classPath = $meta->getName();
  131.             $name = strtoupper($this->commonService->toSnakeCase(str_replace('App\Entity\\', '', $classPath)));
  132.             preg_match('/(' . $name . ')_(.+)/i', $propertyName, $matches);
  133.             if (count($matches) > 0) {
  134.                 $prop = $matches[2];
  135.                 if(defined($classPath . '::' . $prop)) {
  136.                     $constant = @constant($classPath . '::' . $prop);
  137.                 }
  138.                 if (!is_null($constant)) {
  139.                     $cachedConstantItem->set($constant);
  140.                     $this->appCache->save($cachedConstantItem);
  141.                     return $constant;
  142.                 }
  143.             }
  144.         }
  146.         trigger_error('Could not found property ' . $propertyName . ' in ' . $this->commonService->getClassName($this), E_USER_ERROR);
  147.     }
  149.     public function getPagingData($queryBuilder, $paging = null, $DTO = null, $fetchJoinCollection = true)
  150.     {
  151.         if (is_null($paging)) {
  152.             $paging = [
  153.                 'page' => 1,
  154.                 'limit' => 50
  155.             ];
  156.         }
  157.         if (!isset($paging['page'])) {
  158.             $paging['page'] = 1;
  159.         }
  160.         if (!isset($paging['limit'])) {
  161.             $paging['limit'] = 50;
  162.         } else if (((int)$paging['limit']) <= 0) {
  163.             $paging['limit'] = pow(10, 12);
  164.         }
  165.         $queryBuilder
  166.             ->setFirstResult(($paging['page'] - 1) * $paging['limit'])
  167.             ->setMaxResults($paging['limit']);
  169.         $paginator = new Paginator($queryBuilder, $fetchJoinCollection);
  171.         $paginatorQuery = $paginator->getQuery();
  173.         $this->addTranslationWalkerToQuery($paginatorQuery);
  175.         $total = count($paginator);
  176.         $list = [];
  177.         foreach ($paginator as $entity) {
  178.             if (is_null($DTO)) {
  179.                 $outputDTO = 'App\DTO\\' . $this->getEntityName() . '\\' . $this->getEntityName() . 'Output';
  180.                 if (class_exists($outputDTO)) {
  181.                     $DTO = $outputDTO;
  182.                 }
  183.             }
  184.             if (is_null($DTO) || $DTO === 'ENTITY') {
  185.                 $list[] = $entity;
  186.             } else {
  187.                 $array = (array)$this->autoMapper->map($entity, $DTO);
  188.                 foreach ($array as $key => $value) {
  189.                     if (is_string($value)) {
  190.                         $array[$key] = mb_convert_encoding($value, "UTF-8");
  191.                     }
  192.                 }
  193.                 $list[] = $array;
  194.             }
  195.         }
  196.         return [
  197.             'total' => $total,
  198.             'totalPages' => ceil($total / $paging['limit']),
  199.             'list' => $list,
  200.             'currentPage' => 1 * $paging['page']
  201.         ];
  202.     }
  204.     public function setFilter(QueryBuilder $queryBuilder, $requestData)
  205.     {
  206.         foreach ($requestData as $key => $value) {
  207.             if ($value === '') {
  208.                 continue;
  209.             }
  210.             if (strpos($key, 'filter_') === 0) {
  211.                 $filter = str_replace('filter_', '', $key);
  212.                 if (strpos($filter, '_like') !== false) {
  213.                     $filter = str_replace('_like', '', $filter);
  214.                     if ($filter === 'namefull') {
  215.                         $queryBuilder
  216.                             ->andWhere(
  217.                                 $queryBuilder
  218.                                     ->expr()
  219.                                     ->orX(
  220.                                         $queryBuilder
  221.                                             ->expr()
  222.                                             ->like($this->getEntityName() . '.firstName', ':firstName'),
  223.                                         $queryBuilder
  224.                                             ->expr()
  225.                                             ->like($this->getEntityName() . '.lastName', ':lastName')
  226.                                     )
  227.                             )
  228.                             ->setParameter(':firstName', $value)
  229.                             ->setParameter(':lastName', $value);
  230.                     } else {
  231.                         // or like
  232.                         if (strpos($filter, '_or_') !== -1) {
  233.                             $orx = $queryBuilder->expr()->orX();
  234.                             foreach (explode('_or_', $filter) as $orFilter) {
  235.                                 $orx->add(
  236.                                     $queryBuilder
  237.                                         ->expr()
  238.                                         ->like($this->getEntityName() . '.' . $orFilter, ':' . $orFilter)
  239.                                 );
  240.                                 $queryBuilder->setParameter($orFilter, '%' . $value . '%');
  241.                             }
  242.                             $queryBuilder->andWhere($orx);
  243.                         } else {
  244.                             $fieldName = $this->getEntityName() . '.' . $filter;
  245.                             $queryBuilder->andWhere(
  246.                                 $queryBuilder
  247.                                     ->expr()
  248.                                     ->like($fieldName, ':' . $filter)
  249.                             );
  250.                             $queryBuilder->setParameter($filter, '%' . $value . '%');
  251.                         }
  252.                     }
  253.                 } else {
  254.                     $fieldName = $this->getEntityName() . '.' . $filter;
  255.                     if (is_array($value)) {
  256.                         $queryBuilder
  257.                             ->andWhere(
  258.                                 $queryBuilder
  259.                                     ->expr()
  260.                                     ->in($fieldName, ':in' . $filter)
  261.                             )
  262.                             ->setParameter(
  263.                                 'in' . $filter,
  264.                                 $value,
  265.                                 \Doctrine\DBAL\Connection::PARAM_INT_ARRAY
  266.                             );
  267.                     } else if ($value === 'falseOrNull') {
  268.                         $queryBuilder->andWhere($fieldName . ' = 0 or ' . $fieldName . ' is NULL');
  269.                     } else if ($value === 'isNull') {
  270.                         $queryBuilder->andWhere($fieldName . ' is NULL');
  271.                     } else if ($value === 'true' || $value === 'false') {
  272.                         $queryBuilder->andWhere(
  273.                             $queryBuilder->expr()->eq($fieldName, ':' . $filter)
  274.                         );
  275.                         $queryBuilder->setParameter($filter, $value === 'true');
  276.                     } else if ($value === 'notNull') {
  277.                         $queryBuilder->andWhere(
  278.                             $queryBuilder->expr()->isNotNull($fieldName)
  279.                         );
  280.                     } else {
  281.                         $queryBuilder->andWhere(
  282.                             $queryBuilder->expr()->eq($fieldName, ':' . $filter)
  283.                         );
  284.                         $queryBuilder->setParameter($filter, $value);
  285.                     }
  286.                 }
  287.             } else if (strpos($key, 'except_') === 0) {
  288.                 $except = str_replace('except_', '', $key);
  289.                 $isInt = is_int(explode(',', $value)[0]);
  290.                 if ($isInt) {
  291.                     $value = array_map('intval', explode(',', $value));
  292.                 } else {
  293.                     $value = array_map('strval', explode(',', $value));
  294.                 }
  295.                 $fieldName = $this->getEntityName() . '.' . $except;
  297.                 $queryBuilder
  298.                     ->andWhere(
  299.                         $queryBuilder
  300.                             ->expr()
  301.                             ->orX(
  302.                                 $queryBuilder->expr()->isNull($fieldName),
  303.                                 $queryBuilder
  304.                                     ->expr()
  305.                                     ->notIn($fieldName, ':notIn' . $except)
  306.                             )
  307.                     )
  308.                     ->setParameter(
  309.                         'notIn' . $except,
  310.                         $value,
  311.                         $isInt
  312.                             ? \Doctrine\DBAL\Connection::PARAM_INT_ARRAY
  313.                             : \Doctrine\DBAL\Connection::PARAM_STR_ARRAY
  314.                     );
  315.             } else if (strpos($key, 'has_') === 0) {
  316.                 $paramName = 'p' . bin2hex(random_bytes(5));
  317.                 $has = str_replace('has_', '', $key);
  318.                 $relationName = explode('_', $has)[0];
  319.                 $relationProperty = explode('_', $has)[1];
  320.                 $fieldName = $this->getEntityName() . '.' . $relationName;
  321.                 $queryBuilder
  322.                     ->leftJoin($fieldName, $paramName)
  323.                     ->andWhere($paramName . '.' . $relationProperty . ' = :' . $paramName)
  324.                     ->setParameter($paramName, $value);
  325.             } else if (strpos($key, 'hasAny_') === 0) {
  326.                 $paramName = 'p' . bin2hex(random_bytes(5));
  327.                 $has = str_replace('hasAny_', '', $key);
  328.                 $relationName = explode('_', $has)[0];
  329.                 $relationProperty = explode('_', $has)[1];
  330.                 $fieldName = $this->getEntityName() . '.' . $relationName;
  331.                 $queryBuilder
  332.                     ->leftJoin($fieldName, $paramName)
  333.                     ->andWhere($paramName . '.' . $relationProperty . ' = :' . $paramName)
  334.                     ->setParameter($paramName, $value);
  335.             } else if (strpos($key, 'hasAny2_') === 0) {
  336.                 $paramName = 'p' . bin2hex(random_bytes(5));
  337.                 $has = str_replace('hasAny2_', '', $key);
  338.                 $relationName = explode('_', $has)[0];
  339.                 $relationProperty = explode('_', $has)[1];
  340.                 $fieldName = $this->getEntityName() . '.' . $relationName;
  341.                 $queryBuilder
  342.                     ->leftJoin($fieldName, $paramName)
  343.                     ->andWhere(':' . $paramName . ' member of ' . $paramName . '.' . $relationProperty)
  344.                     ->setParameter($paramName, $value);
  345.             } else if (strpos($key, 'memberOf_') === 0) {
  346.                 $relationName = str_replace('memberOf_', '', $key);
  347.                 $fieldName = $this->getEntityName() . '.' . $relationName;
  349.                 if ($value === 'isNull') {
  350.                     $queryBuilder->andWhere($fieldName . ' IS EMPTY');
  351.                 } elseif ($value === 'notNull') {
  352.                     $queryBuilder->andWhere($fieldName . ' IS NOT EMPTY');
  353.                 } else {
  354.                     // xử lý array luôn
  355.                     if (is_array($value)) {
  356.                         $orX = $queryBuilder->expr()->orX();
  358.                         foreach ($value as $k => $v) {
  359.                             $paramName = 'p' . $k . bin2hex(random_bytes(3));
  360.                             $orX->add(':' . $paramName . ' MEMBER OF ' . $fieldName);
  361.                             $queryBuilder->setParameter($paramName, $v);
  362.                         }
  364.                         $queryBuilder->andWhere($orX);
  365.                     } else {
  366.                         $paramName = 'p' . bin2hex(random_bytes(5));
  367.                         $queryBuilder
  368.                             ->andWhere(':' . $paramName . ' MEMBER OF ' . $fieldName)
  369.                             ->setParameter($paramName, $value);
  370.                     }
  371.                 }
  372.             } else if (strpos($key, 'hasLike_') === 0) {
  373.                 $paramName = 'p' . bin2hex(random_bytes(5));
  374.                 $has = str_replace('hasLike_', '', $key);
  375.                 $relationName = explode('_', $has)[0];
  376.                 $relationProperty = explode('_', $has)[1];
  377.                 $fieldName = $this->getEntityName() . '.' . $relationName;
  378.                 $queryBuilder
  379.                     ->leftJoin($fieldName, $paramName)
  380.                     ->andWhere($paramName . '.' . $relationProperty . ' LIKE :' . $paramName)
  381.                     ->setParameter($paramName, '%' . $value . '%');
  382.             }
  383.         }
  384.     }
  386.     public function setSort(QueryBuilder $queryBuilder, $requestData)
  387.     {
  388.         foreach ($requestData as $key => $value) {
  389.             if (strpos($key, 'sort_') === false) {
  390.                 continue;
  391.             }
  393.             $direction = strpos($key, '_asc') !== false ? 'ASC' : 'DESC';
  394.             $value = str_replace('Text', '', $value);
  395.             $isRelation = strpos($value, 'Relation') !== false;
  396.             if ($isRelation) {
  397.                 $value = str_replace('Relation', '', $value);
  398.                 @list($rel1, $rel2, $rel3) = explode('.', $value);
  399.                 if (empty($rel3)) {
  400.                     $rel1Table = $this->getEntityName() . '.' . $rel1;
  401.                     $queryBuilder->leftJoin($rel1Table, $rel1);
  402.                     $queryBuilder->addOrderBy($value, $direction);
  403.                 } else {
  404.                     $rel1Table = $this->getEntityName() . '.' . $rel1;
  405.                     $queryBuilder->leftJoin($rel1Table, $rel1);
  406.                     $rel2Table = $rel1 . '.' . $rel2;
  407.                     $queryBuilder->leftJoin($rel2Table, $rel2);
  408.                     $queryBuilder->addOrderBy($rel2 . '.' . $rel3, $direction);
  409.                 }
  410.             } else {
  411.                 $fieldName = $this->getEntityName() . '.' . $value;
  412.                 $queryBuilder->addOrderBy($fieldName, $direction);
  413.             }
  414.         }
  415.     }
  417.     public function getList($requestData, $DTO = null, callable $extraFilter = null, $fetchJoinCollection = true)
  418.     {
  419.         if ($requestData instanceof Request) {
  420.             $requestData = $requestData->query->all();
  421.         }
  422.         $queryBuilder = $this->createQueryBuilder($this->getEntityName());
  423.         if (!is_null($extraFilter)) {
  424.             $extraFilter($queryBuilder);
  425.         }
  426.         $this->setFilter($queryBuilder, $requestData);
  427.         $this->setSort($queryBuilder, $requestData);
  428.         // dd($queryBuilder->getDQL());
  429.         return $this->getPagingData($queryBuilder, $requestData, $DTO, $fetchJoinCollection);
  430.     }
  432.     public function getAll($requestData, $DTO = null, callable $extraFilter = null, $returnQuery = false)
  433.     {
  434.         if ($requestData instanceof Request) {
  435.             $requestData = $requestData->query->all();
  436.         }
  437.         $queryBuilder = $this->createQueryBuilder($this->getEntityName());
  438.         if (!is_null($extraFilter)) {
  439.             $extraFilter($queryBuilder);
  440.         }
  441.         $this->setFilter($queryBuilder, $requestData);
  442.         $this->setSort($queryBuilder, $requestData);
  443.         if ($returnQuery) {
  444.             return $queryBuilder;
  445.         }
  446.         $entities = $queryBuilder->getQuery()->execute();
  448.         $list = [];
  449.         foreach ($entities as $entity) {
  450.             if (is_null($DTO)) {
  451.                 $outputDTO = 'App\DTO\\' . $this->getEntityName() . '\\' . $this->getEntityName() . 'Output';
  452.                 if (class_exists($outputDTO)) {
  453.                     $DTO = $outputDTO;
  454.                 }
  455.             }
  456.             if (is_null($DTO) || $DTO === 'ENTITY') {
  457.                 $list[] = $entity;
  458.             } else {
  459.                 $array = (array)$this->autoMapper->map($entity, $DTO);
  460.                 foreach ($array as $key => $value) {
  461.                     if (is_string($value)) {
  462.                         $array[$key] = mb_convert_encoding($value, "UTF-8");
  463.                     }
  464.                 }
  465.                 $list[] = $array;
  466.             }
  467.         }
  469.         return $list;
  470.     }
  472.     public function getDistinctAttributeOfList($requestData, $DTO = null, callable $extraFilter = null)
  473.     {
  474.         $entityName = $this->getEntityName();
  475.         if ($requestData instanceof Request) {
  476.             $requestData = $requestData->query->all();
  477.         }
  478.         if (isset($requestData['distinct_attribute'])) {
  479.             $attributeType = 'attribute';
  480.         } else if (isset($requestData['distinct_relation'])) {
  481.             $attributeType = 'relation';
  482.         } else return [];
  484.         $queryBuilder = $this->createQueryBuilder($entityName);
  485.         if (!is_null($extraFilter)) {
  486.             $extraFilter($queryBuilder);
  487.         }
  488.         $this->setFilter($queryBuilder, $requestData);
  489.         $this->setSort($queryBuilder, $requestData);
  491.         if ($attributeType == 'attribute') {
  492.             $queryBuilder
  493.                 ->select($entityName . '.' . $requestData['distinct_attribute'])
  494.                 ->groupBy($entityName . '.' . $requestData['distinct_attribute']);
  495.         } else if ($attributeType == 'relation') {
  496.             $queryBuilder
  497.                 ->join($entityName . '.' . $requestData['distinct_relation'], $requestData['distinct_relation'])
  498.                 ->addSelect($requestData['distinct_relation'])
  499.                 ->addSelect('COUNT(' . $entityName . ') as count')
  500.                 ->groupBy($requestData['distinct_relation']);
  501.         }
  502.         $result = $queryBuilder->getQuery()->getResult();
  503.         $attributeList = [];
  504.         foreach ($result as $entity) {
  505.             $attributeName = $requestData[$attributeType == 'attribute' ? 'distinct_attribute' : 'distinct_relation'];
  506.             $attribute = $entity[0]->{'get' . $attributeName}();
  507.             if ($attributeType == 'attribute') {
  508.                 $attributeList[] = [
  509.                     'value' => $attribute,
  510.                     'count' => (int)$entity['count'],
  511.                 ];
  512.             } else if ($attributeType == 'relation') {
  513.                 $array = !is_null($DTO)
  514.                     ? (array)$this->autoMapper->map($attribute, $DTO)
  515.                     : (array)$attribute;
  516.                 foreach ($array as $key => $value) {
  517.                     if (is_string($value)) {
  518.                         $array[$key] = mb_convert_encoding($value, "UTF-8");
  519.                     }
  520.                 }
  521.                 $array['count'] = (int)$entity['count'];
  522.                 $attributeList[] = $array;
  523.             }
  524.         }
  525.         return $attributeList;
  526.     }
  528.     public function entityToDtoArray($entity, $DTO = null)
  529.     {
  530.         $array = (array)$this->autoMapper->map($entity, $DTO);
  531.         foreach ($array as $key => $value) {
  532.             if (is_string($value)) {
  533.                 $array[$key] = mb_convert_encoding($value, "UTF-8");
  534.             }
  535.         }
  537.         return $array;
  538.     }
  540.     public function getEntityName()
  541.     {
  542.         return $this->commonService->getClassName($this, true);
  543.     }
  545.     public function checkExistSlug($entity, $value)
  546.     {
  547.         $id = $entity->getId();
  549.         $conn = $this->getEntityManager()->getConnection();
  550.         $stmt = $conn->executeQuery(
  551.             'select count(id) as id from news where id != :id and slug = :slug',
  552.             [
  553.                 'id' => $id,
  554.                 'slug' => $value
  555.             ]
  556.         );
  557.         $result = $stmt->fetchOne();
  558.         return (int) $result;
  559.     }
  561.     public function findOneBy(array $criteria, array $orderBy = null)
  562.     {
  563.         $qb = $this->createQueryBuilder('o');
  564.         foreach ($criteria as $criterion => $value) {
  565.             $qb
  566.                 ->andWhere('o.' . $criterion . ' = :' . $criterion)
  567.                 ->setParameter($criterion, $value);
  568.         }
  569.         $qb->setMaxResults(1);
  570.         $query = $qb->getQuery();
  572.         $this->addTranslationWalkerToQuery($query);
  574.         return $query->getOneOrNullResult();
  575.     }
  577.     public function addTranslationWalkerToQuery($query)
  578.     {
  579.         // News, Program
  580.         $translatableEntities = [];
  581.         if (!in_array($this->getEntityName(), $translatableEntities)) return;
  583.         $config = $this->_em->getConfiguration();
  584.         if ($config->getCustomHydrationMode(TranslationWalker::HYDRATE_OBJECT_TRANSLATION) === null) {
  585.             $config->addCustomHydrationMode(
  586.                 TranslationWalker::HYDRATE_OBJECT_TRANSLATION,
  587.                 'Gedmo\\Translatable\\Hydrator\\ORM\\ObjectHydrator'
  588.             );
  589.         }
  591.         $query->setHint(
  592.             \Doctrine\ORM\Query::HINT_CUSTOM_OUTPUT_WALKER,
  593.             'Gedmo\\Translatable\\Query\\TreeWalker\\TranslationWalker'
  594.         );
  595.         $query->setHint(
  596.             \Gedmo\Translatable\TranslatableListener::HINT_TRANSLATABLE_LOCALE,
  597.             $this->container->get('gedmo.listener.translatable')->getListenerLocale() // take locale from session or request etc.
  598.         );
  599.         $query->setHydrationMode(TranslationWalker::HYDRATE_OBJECT_TRANSLATION);
  600.         $query->setHint(\Doctrine\ORM\Query::HINT_REFRESH, true);
  601.     }
  602. }