src/Repository/BaseRepository.php line 423

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