src/Domain/Repository/UserRepository.php line 20

Open in your IDE?
  1. <?php
  3. declare(strict_types = 1);
  5. namespace App\Domain\Repository;
  7. use App\Domain\Entity\User;
  8. use App\Domain\Repository\Interfaces\UserRepositoryInterface;
  9. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  10. use Doctrine\ORM\NonUniqueResultException;
  11. use Doctrine\ORM\OptimisticLockException;
  12. use Doctrine\ORM\ORMException;
  13. use Doctrine\Persistence\ManagerRegistry;
  14. use Symfony\Bridge\Doctrine\Security\User\UserLoaderInterface;
  16. class UserRepository extends ServiceEntityRepository implements UserLoaderInterface, UserRepositoryInterface
  17. {
  18.     public function __construct(ManagerRegistry $registry)
  19.     {
  20.         parent::__construct($registry, User::class);
  21.     }
  23.     /**
  24.      * @param string $username
  25.      *
  26.      * @return User|null
  27.      *
  28.      * @throws NonUniqueResultException
  29.      */
  30.     public function getUserByUsername(string $username): ?User
  31.     {
  32.         return $this->createQueryBuilder('user')
  33.             ->where('user.username = :username')
  34.             ->setParameter('username', $username)
  35.             ->setCacheable(true)
  36.             ->getQuery()
  37.             ->getOneOrNullResult();
  38.     }
  40.     /**
  41.      * @param string $mail
  42.      *
  43.      * @return User|null
  44.      *
  45.      * @throws NonUniqueResultException
  46.      */
  47.     public function getUserByEmail($mail): ?User
  48.     {
  49.         return $this->createQueryBuilder('user')
  50.             ->where('user.email = :email')
  51.             ->setParameter('email', $mail)
  52.             ->setCacheable(true)
  53.             ->getQuery()
  54.             ->getOneOrNullResult();
  55.     }
  57.     /**
  58.      * @param string $username
  59.      * @param string $mail
  60.      *
  61.      * @return mixed
  62.      *
  63.      * @throws NonUniqueResultException
  64.      */
  65.     public function getUserByUsernameAndEmail(string $username, string $mail)
  66.     {
  67.         return $this->createQueryBuilder('user')
  68.             ->where('user.username = :username AND user.email = :email')
  69.             ->setParameter('username', $username)
  70.             ->setParameter('email', $mail)
  71.             ->getQuery()
  72.             ->getOneOrNullResult();
  73.     }
  75.     /**
  76.      * @return int|mixed|string
  77.      */
  78.     public function getAllUser()
  79.     {
  80.         return $this->createQueryBuilder('u')
  81.             ->orderBy('u.createdAt', 'DESC')
  82.             ->getQuery()
  83.             ->getResult()
  84.             ;
  85.     }
  87.     /**
  88.      * @param $role
  89.      * @return mixed
  90.      */
  91.     public function getAllUserByRoles($role)
  92.     {
  93.         return $this->createQueryBuilder('user')
  94.             ->where('user.role LIKE :role')
  95.             ->setParameter('role', '%"'.$role.'"%')
  96.             ->orderBy('user.createdAt', 'DESC')
  97.             ->getQuery()
  98.             ->getResult()
  99.             ;
  100.     }
  102.     /**
  103.      * @param string $token
  104.      *
  105.      * @return mixed
  106.      *
  107.      * @throws NonUniqueResultException
  108.      */
  109.     public function getUserByToken(string $token)
  110.     {
  111.         return $this->createQueryBuilder('user')
  112.             ->where('user.token = :token')
  113.             ->setParameter('token', $token)
  114.             ->getQuery()
  115.             ->getOneOrNullResult();
  116.     }
  118.     /**
  119.      * @param string $id
  120.      *
  121.      * @return mixed
  122.      *
  123.      * @throws NonUniqueResultException
  124.      */
  125.     public function getUserById(string $id): ?User
  126.     {
  127.         return$this->createQueryBuilder('u')
  128.             ->where('u.id = :id')
  129.             ->setParameter('id', $id)
  130.             ->setCacheable(true)
  131.             ->getQuery()
  132.             ->getOneOrNullResult()
  133.             ;
  134.     }
  136.     /**
  137.      * @param string $username
  138.      *
  139.      * @return mixed
  140.      *
  141.      * @throws NonUniqueResultException
  142.      */
  143.     public function loadUserByUsername(string $username)
  144.     {
  145.         return $this->createQueryBuilder('user')
  146.             ->where('user.username = :username')
  147.             ->setParameter('username', $username)
  148.             ->setCacheable(true)
  149.             ->getQuery()
  150.             ->getOneOrNullResult();
  151.     }
  153.     /**
  154.      * @param string $id
  155.      * @param bool $value
  156.      * @return \Doctrine\ORM\Query
  157.      */
  158.     public function disableUserById(string $id, bool $value)
  159.     {
  160.         return $this->createQueryBuilder('user')
  161.             ->update('App:User', 'u')
  162.             ->set('u.status', '?1')
  163.             ->where('u.id = ?2')
  164.             ->setParameter(1, $value)
  165.             ->setParameter(2, $id)
  166.             ->getQuery()
  167.             ->execute();
  168.     }
  171.     /**
  172.      * @param $user
  173.      *
  174.      * @throws ORMException
  175.      *
  176.      * @throws OptimisticLockException
  177.      */
  178.     public function save($user)
  179.     {
  180.         $this->getEntityManager()->persist($user);
  181.         $this->getEntityManager()->flush();
  182.     }
  184.     /**
  185.      * @throws ORMException
  186.      * @throws OptimisticLockException
  187.      */
  188.     public function flush()
  189.     {
  190.         $this->getEntityManager()->flush();
  191.     }
  193.     /**
  194.      * @return void
  195.      *
  196.      * @throws ORMException
  197.      * @throws OptimisticLockException
  198.      */
  199.     public function update(): void
  200.     {
  201.         $this->getEntityManager()->flush();
  202.     }
  204.     /**
  205.      * @param $user
  206.      * @return void
  207.      *
  208.      * @throws ORMException
  209.      * @throws OptimisticLockException
  210.      */
  211.     public function updateUser($user): void
  212.     {
  213.         $this->getEntityManager()->flush();
  214.     }
  216.     /**
  217.      * @param string $id
  218.      *
  219.      * @throws NonUniqueResultException
  220.      * @throws ORMException
  221.      * @throws OptimisticLockException
  222.      */
  223.     public function deleteUser(string $id)
  224.     {
  225.         $user = $this->getUserById($id);
  226.         $this->getEntityManager()->remove($user);
  227.         $this->getEntityManager()->flush();
  228.     }
  229. }