src/Hitso/Bundle/CommonBundle/Repository/ChangeLogRepository.php line 32

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Hitso\Bundle\CommonBundle\Repository;
  7. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepositoryInterface;
  8. use Doctrine\Common\Util\ClassUtils;
  9. use Doctrine\Common\Util\Debug;
  10. use Doctrine\ORM\Query;
  11. use Doctrine\ORM\Query\Expr\Join;
  12. use Doctrine\ORM\Tools\Pagination\Paginator;
  13. use Gedmo\Loggable\Entity\Repository\LogEntryRepository;
  14. use Hitso\Bundle\CommonBundle\Doctrine\Behaviours\VersionInterface;
  15. use Hitso\Bundle\CommonBundle\Entity\ChangeLog;
  16. use Hitso\Bundle\CommonBundle\Entity\EntityInterface;
  17. use Symfony\Bridge\Doctrine\RegistryInterface;
  19. /**
  20.  * Class ChangeLogRepository
  21.  *
  22.  * @package Hitso\Bundle\CommonBundle\Repository
  23.  */
  24. class ChangeLogRepository extends LogEntryRepository implements ServiceEntityRepositoryInterface
  25. {
  26.     /**
  27.      * ChangeLogRepository constructor.
  28.      *
  29.      * @param RegistryInterface $registry
  30.      * @param string            $className
  31.      */
  32.     public function __construct(RegistryInterface $registry, string $className = ChangeLog::class)
  33.     {
  34.         parent::__construct($registry->getEntityManager(), $registry->getEntityManager()->getClassMetadata($className));
  35.     }
  37.     /**
  38.      * @param object $entity
  39.      * @param int    $version
  40.      */
  41.     public function revert($entity, $version = 1)
  42.     {
  43.         if ($entity instanceof VersionInterface) {
  44.             $entity->skipVersion(true);
  46.             /** @var ChangeLog $changeLog */
  47.             $changeLog = $this->findOneBy(
  48.                 [
  49.                     'objectId'    => $entity->getId(),
  50.                     'objectClass' => ClassUtils::getClass($entity),
  51.                     'version'     => $version,
  52.                 ]
  53.             );
  55.             if ($changeLog) {
  56.                 $changeLog->setCurrent($entity->isCurrent());
  57.             }
  58.         }
  60.         parent::revert($entity, $version);
  61.     }
  63.     /**
  64.      * @param ChangeLog $logEntry
  65.      *
  66.      * @return object|null
  67.      * @throws \Doctrine\ORM\ORMException
  68.      * @throws \Doctrine\ORM\OptimisticLockException
  69.      * @throws \Doctrine\ORM\TransactionRequiredException
  70.      */
  71.     public function getVersionedEntity(ChangeLog $logEntry)
  72.     {
  73.         return $this->_em->find($logEntry->getObjectClass(), $logEntry->getObjectId());
  74.     }
  76.     /**
  77.      * @param string   $className
  78.      * @param iterable $objectIds
  79.      *
  80.      * @return array
  81.      */
  82.     public function findLatest(string $className, iterable $objectIds): array
  83.     {
  84.         return $this
  85.             ->createQueryBuilder('v', 'v.id')
  86.             ->leftJoin(ChangeLog::class, 'v2', Join::WITH, 'v.objectId = v2.objectId AND v.version < v2.version')
  87.             ->select('v')
  88.             ->andWhere('v.objectParent = :className')->orWhere('v.objectClass = :className')
  89.             ->andWhere('v2.objectId IS NULL')
  90.             ->andWhere('v.objectId IN (:objectIds)')
  91.             ->orderBy('v.version', 'DESC')
  92.             ->setParameters(['className' => $className, 'objectIds' => $objectIds])
  93.             ->getQuery()
  94.             ->getResult();
  95.     }
  97.     /**
  98.      * @param string   $className
  99.      * @param iterable $objectIds
  100.      *
  101.      * @return array
  102.      */
  103.     public function findCurrent(string $className, iterable $objectIds): array
  104.     {
  105.         return $this
  106.             ->createQueryBuilder('v', 'v.id')
  107.             ->select('v')
  108.             ->andWhere('v.objectParent = :className')->orWhere('v.objectClass = :className')
  109.             ->andWhere('v.objectId IN (:objectIds)')
  110.             ->andWhere('v.current = 1')
  111.             ->orderBy('v.version', 'DESC')
  112.             ->setParameters(['className' => $className, 'objectIds' => $objectIds])
  113.             ->getQuery()
  114.             ->getResult();
  115.     }
  117.     /**
  118.      * @return int
  119.      */
  120.     public function getTotalCount(): int
  121.     {
  122.         $queryBuilder = $this->createQueryBuilder('e');
  123.         $query        = $queryBuilder->getQuery();
  124.         $query->useQueryCache(true);
  125.         $query->useResultCache(true);
  126.         $paginator = new Paginator($query, true);
  127.         $paginator->setUseOutputWalkers(false);
  129.         return $paginator->count();
  130.     }
  132.     /**
  133.      * Get the query for loading of log entries
  134.      *
  135.      * @param object $entity
  136.      *
  137.      * @return Query
  138.      */
  139.     public function getLogEntriesQuery($entity)
  140.     {
  141.         $q = parent::getLogEntriesQuery($entity);
  143.         $q
  144.             ->useResultCache(false)
  145.             ->useQueryCache(true);
  147.         return $q;
  148.     }
  150.     /**
  151.      * @param EntityInterface $entity
  152.      * @param int             $pending
  153.      *
  154.      * @return mixed
  155.      */
  156.     public function getPendingLogByEntity(EntityInterface $entity, int $pending = 1)
  157.     {
  158.         $qb = $this->createQueryBuilder('c')
  159.             ->select()
  160.             ->andWhere('c.objectClass = :className')
  161.             ->setParameter('className', get_class($entity))
  162.             ->andWhere('c.objectId = :objectId')
  163.             ->setParameter('objectId', $entity->getId())
  164.             ->orderBy('c.id', 'DESC');
  166.         if ($pending == 1) {
  167.             $qb->andWhere('c.pending = :pending')
  168.                 ->setParameter('pending', 1);
  169.         }
  171.         return $qb->getQuery()
  172.             ->getResult();
  173.     }
  175.     /**
  176.      * @param EntityInterface $entity
  177.      * @param int             $pending
  178.      *
  179.      * @return mixed
  180.      */
  181.     public function countPendingLogByEntity(EntityInterface $entity, int $pending = 1)
  182.     {
  183.         $qb = $this->createQueryBuilder('c')
  184.             ->select('COUNT(c.id)')
  185.             ->andWhere('c.objectClass = :className')
  186.             ->setParameter('className', get_class($entity))
  187.             ->andWhere('c.objectId = :objectId')
  188.             ->setParameter('objectId', $entity->getId())
  189.             ;
  190.         if ($pending == 1) {
  191.             $qb->andWhere('c.pending = :pending')
  192.                 ->setParameter('pending', 1);
  193.         }
  195.         return (int)$qb->getQuery()->getSingleScalarResult();
  196.     }
  198.     public function getEntityLogsQuery(EntityInterface $entity)
  199.     {
  200.         return $this->createQueryBuilder('c')
  201.             ->select()
  202.             ->andWhere('c.objectClass = :className')
  203.             ->setParameter('className', get_class($entity))
  204.             ->andWhere('c.objectId = :objectId')
  205.             ->setParameter('objectId', $entity->getId())
  206.             ->orderBy('c.version', 'DESC');
  207.     }
  209.     public function getEntityLogs(EntityInterface $entity)
  210.     {
  211.         return $this->getEntityLogsQuery($entity)->getQuery()->getResult();
  212.     }
  214.     public function getPendingLogsQuery(EntityInterface $entity)
  215.     {
  216.         $qb = $this->getEntityLogsQuery($entity);
  217.         $qb->andWhere('c.pending = :pending')
  218.             ->setParameter('pending', 1);
  220.         return $qb;
  221.     }
  223.     public function getNoPendingLogsQuery(EntityInterface $entity)
  224.     {
  225.         $qb = $this->getEntityLogsQuery($entity);
  226.         $qb->andWhere('c.pending = :pending')
  227.             ->setParameter('pending', 0);
  229.         return $qb;
  230.     }
  232.     public function getNoPendingLogs(EntityInterface $entity)
  233.     {
  234.         $qb = $this->getNoPendingLogsQuery($entity);
  236.         return $qb->getQuery()
  237.             ->getResult();
  238.     }
  240.     public function getPendingLogs(EntityInterface $entity)
  241.     {
  242.         $qb = $this->getPendingLogsQuery($entity);
  244.         return $qb->getQuery()
  245.             ->getResult();
  246.     }
  248.     public function getLastLog(EntityInterface $entity)
  249.     {
  250.         $qb = $this->getEntityLogsQuery($entity);
  251.         $qb->setMaxResults(1);
  253.         return $qb->getQuery()
  254.             ->getOneOrNullResult();
  255.     }
  257.     public function getLastPendingLog(EntityInterface $entity)
  258.     {
  259.         $qb = $this->getPendingLogsQuery($entity);
  260.         $qb->setMaxResults(1);
  262.         return $qb->getQuery()
  263.             ->getOneOrNullResult();
  264.     }
  266.     public function getLastNoPendingLog(EntityInterface $entity)
  267.     {
  268.         $qb = $this->getNoPendingLogsQuery($entity);
  269.         $qb->setMaxResults(1);
  271.         return $qb->getQuery()
  272.             ->getOneOrNullResult();
  273.     }
  275.     public function setCurrentVersion(EntityInterface $entity, int $value = 0, int $version = null)
  276.     {
  277.         $queryBuilder = $this->createQueryBuilder('e')
  278.             ->update()
  279.             ->set('e.current', ':current')
  280.             ->setParameter('current', $value)
  281.             ->where("e.objectClass = :objectClass")
  282.             ->setParameter('objectClass', ClassUtils::getClass($entity))
  283.             ->andWhere('e.objectId = :objectId')
  284.             ->setParameter('objectId', $entity->getId());
  286.         if ($version) {
  287.             $queryBuilder->andWhere('e.version = :version')
  288.                 ->setParameter('version', $version);
  289.         }
  291.         $queryBuilder->getQuery()
  292.             ->getSingleScalarResult();
  293.     }
  295.     public function getLogByVersion(EntityInterface $entity, int $version = 1)
  296.     {
  297.         return $this->findOneBy(
  298.             [
  299.                 'objectId'    => $entity->getId(),
  300.                 'objectClass' => ClassUtils::getClass($entity),
  301.                 'version'     => $version,
  302.             ]
  303.         );
  304.     }
  306.     public function getCurrentVersion(EntityInterface $entity)
  307.     {
  308.         $log = $this->createQueryBuilder('c')
  309.             ->select()
  310.             ->where('c.objectClass = :className AND c.objectId = :objectId AND c.current = 1')
  311.             ->setParameter('className', ClassUtils::getClass($entity))
  312.             ->setParameter('objectId', $entity->getId())
  313.             ->setMaxResults(1)
  314.             ->getQuery()
  315.             ->getOneOrNullResult();
  317.         if ($log) {
  318.             return $log->getVersion();
  319.         }
  321.         return 1;
  322.     }
  324. }