Refactor PersonSearch and create PersonACLAwareRepository

The search api delegates the query to a person acl aware "repository"
(although this does not implements ObjectRepository interface).

src/Bundle/ChillMainBundle/ChillMainBundle.php

@@ -3,6 +3,7 @@
 namespace Chill\MainBundle;
 
 use Chill\MainBundle\Routing\LocalMenuBuilderInterface;
+use Chill\MainBundle\Search\SearchInterface;
 use Chill\MainBundle\Security\Resolver\CenterResolverInterface;
 use Symfony\Component\HttpKernel\Bundle\Bundle;
 use Symfony\Component\DependencyInjection\ContainerBuilder;

src/Bundle/ChillMainBundle/Search/SearchInterface.php

@@ -31,7 +31,6 @@ namespace Chill\MainBundle\Search;
  */
 interface SearchInterface
 {
-
     const SEARCH_PREVIEW_OPTION = '_search_preview';
 
     /**

src/Bundle/ChillPersonBundle/Repository/PersonACLAwareRepository.php

@@ -0,0 +1,272 @@
+<?php
+
+namespace Chill\PersonBundle\Repository;
+
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Repository\CountryRepository;
+use Chill\MainBundle\Search\ParsingException;
+use Chill\MainBundle\Security\Authorization\AuthorizationHelper;
+use Chill\PersonBundle\Entity\Person;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\NonUniqueResultException;
+use Doctrine\ORM\NoResultException;
+use Doctrine\ORM\Query;
+use Doctrine\ORM\QueryBuilder;
+use Symfony\Component\Security\Core\Role\Role;
+use Symfony\Component\Security\Core\Security;
+
+
+final class PersonACLAwareRepository implements PersonACLAwareRepositoryInterface
+{
+    private Security $security;
+
+    private EntityManagerInterface $em;
+
+    private CountryRepository $countryRepository;
+
+    private AuthorizationHelper $authorizationHelper;
+
+    public function __construct(
+        Security $security,
+        EntityManagerInterface $em,
+        CountryRepository $countryRepository,
+        AuthorizationHelper $authorizationHelper
+    ) {
+        $this->security = $security;
+        $this->em = $em;
+        $this->countryRepository = $countryRepository;
+        $this->authorizationHelper = $authorizationHelper;
+    }
+
+    /**
+     * @return array|Person[]
+     * @throws NonUniqueResultException
+     * @throws ParsingException
+     */
+    public function findBySearchCriteria(
+        int $start,
+        int $limit,
+        bool $simplify = false,
+        string $default = null,
+        string $firstname = null,
+        string $lastname = null,
+        ?\DateTime $birthdate = null,
+        ?\DateTime $birthdateBefore = null,
+        ?\DateTime $birthdateAfter = null,
+        string $gender = null,
+        string $countryCode = null
+    ): array {
+        $qb = $this->createSearchQuery($default, $firstname, $lastname,
+            $birthdate, $birthdateBefore, $birthdateAfter, $gender,
+            $countryCode);
+        $this->addACLClauses($qb, 'p');
+
+        if ($simplify) {
+            $qb->select(
+                'p.id',
+                $qb->expr()->concat(
+                    'p.firstName',
+                    $qb->expr()->literal(' '),
+                    'p.lastName'
+                ).'AS text'
+            );
+        } else {
+            $qb->select('p');
+        }
+
+        $qb
+            ->setMaxResults($limit)
+            ->setFirstResult($start);
+
+        //order by firstname, lastname
+        $qb
+            ->orderBy('p.firstName')
+            ->addOrderBy('p.lastName');
+
+        if ($simplify) {
+            return $qb->getQuery()->getResult(Query::HYDRATE_ARRAY);
+        } else {
+            return $qb->getQuery()->getResult();
+        }
+    }
+
+    public function countBySearchCriteria(
+        string $default = null,
+        string $firstname = null,
+        string $lastname = null,
+        ?\DateTime $birthdate = null,
+        ?\DateTime $birthdateBefore = null,
+        ?\DateTime $birthdateAfter = null,
+        string $gender = null,
+        string $countryCode = null
+    ): int {
+        $qb = $this->createSearchQuery($default, $firstname, $lastname,
+            $birthdate, $birthdateBefore, $birthdateAfter, $gender,
+            $countryCode);
+        $this->addACLClauses($qb, 'p');
+
+        $qb->select('COUNT(p.id)');
+
+        return $qb->getQuery()->getSingleScalarResult();
+    }
+
+    public function findBySimilaritySearch(string $pattern, int $firstResult,
+        int $maxResult, bool $simplify = false)
+    {
+        $qb = $this->createSimilarityQuery($pattern);
+        $this->addACLClauses($qb, 'sp');
+
+        if ($simplify) {
+            $qb->select(
+                'sp.id',
+                $qb->expr()->concat(
+                    'sp.firstName',
+                    $qb->expr()->literal(' '),
+                    'sp.lastName'
+                ).'AS text'
+            );
+        } else {
+            $qb->select('p');
+        }
+
+        $qb
+            ->setMaxResults($maxResult)
+            ->setFirstResult($firstResult);
+
+        //order by firstname, lastname
+        $qb
+            ->orderBy('sp.firstName')
+            ->addOrderBy('sp.lastName');
+
+        if ($simplify) {
+            return $qb->getQuery()->getResult(Query::HYDRATE_ARRAY);
+        } else {
+            return $qb->getQuery()->getResult();
+        }
+    }
+
+    public function countBySimilaritySearch(string $pattern)
+    {
+        $qb = $this->createSimilarityQuery($pattern);
+        $this->addACLClauses($qb, 'sp');
+
+        $qb->select('COUNT(sp.id)');
+
+        return $qb->getQuery()->getSingleScalarResult();
+    }
+
+    private function createSearchQuery(
+        string $default = null,
+        string $firstname = null,
+        string $lastname = null,
+        ?\DateTime $birthdate = null,
+        ?\DateTime $birthdateBefore = null,
+        ?\DateTime $birthdateAfter = null,
+        string $gender = null,
+        string $countryCode = null
+    ): QueryBuilder {
+
+        if (!$this->security->getUser() instanceof User) {
+            throw new \RuntimeException("Search must be performed by a valid user");
+        }
+        $qb = $this->em->createQueryBuilder();
+        $qb->from(Person::class, 'p');
+
+        if (NULL !== $firstname) {
+            $qb->andWhere($qb->expr()->like('UNACCENT(LOWER(p.firstName))', ':firstname'))
+                ->setParameter('firstname', '%'.$firstname.'%');
+        }
+
+        if (NULL !== $lastname) {
+            $qb->andWhere($qb->expr()->like('UNACCENT(LOWER(p.lastName))', ':lastname'))
+                ->setParameter('lastname', '%'.$lastname.'%');
+        }
+
+        if (NULL !== $birthdate) {
+            $qb->andWhere($qb->expr()->eq('s.birthdate', ':birthdate'))
+                ->setParameter('birthdate', $birthdate);
+        }
+
+        if (NULL !== $birthdateAfter) {
+            $qb->andWhere($qb->expr()->gt('p.birthdate', ':birthdateafter'))
+                ->setParameter('birthdateafter', $birthdateAfter);
+        }
+
+        if (NULL !== $birthdateBefore) {
+            $qb->andWhere($qb->expr()->lt('p.birthdate', ':birthdatebefore'))
+                ->setParameter('birthdatebefore', $birthdateBefore);
+        }
+
+        if (NULL !== $gender) {
+            $qb->andWhere($qb->expr()->eq('p.gender', ':gender'))
+                ->setParameter('gender', $gender);
+        }
+
+        if (NULL !== $countryCode) {
+            try {
+                $country = $this->countryRepository->findOneBy(['countryCode' => $countryCode]);
+            } catch (NoResultException $ex)  {
+                throw new ParsingException('The country code "'.$countryCode.'" '
+                    . ', used in nationality, is unknow', 0, $ex);
+            } catch (NonUniqueResultException $e) {
+                throw $e;
+            }
+
+            $qb->andWhere($qb->expr()->eq('p.nationality', ':nationality'))
+                ->setParameter('nationality', $country);
+        }
+
+        if (NULL !== $default) {
+            $grams = explode(' ', $default);
+
+            foreach($grams as $key => $gram) {
+                $qb->andWhere($qb->expr()
+                    ->like('p.fullnameCanonical', 'UNACCENT(LOWER(:default_'.$key.'))'))
+                    ->setParameter('default_'.$key, '%'.$gram.'%');
+            }
+        }
+
+        return $qb;
+    }
+
+    private function addACLClauses(QueryBuilder $qb, string $personAlias): void
+    {
+        // restrict center for security
+        $reachableCenters = $this->authorizationHelper
+            ->getReachableCenters($this->security->getUser(), 'CHILL_PERSON_SEE');
+        $qb->andWhere(
+            $qb->expr()->orX(
+                $qb->expr()
+                    ->in($personAlias.'.center', ':centers'),
+                $qb->expr()
+                    ->isNull($personAlias.'.center')
+            )
+        );
+        $qb->setParameter('centers', $reachableCenters);
+    }
+
+    private function createSimilarityQuery($pattern): QueryBuilder
+    {
+        $qb = $this->em->createQueryBuilder();
+
+        $qb->from(Person::class, 'sp');
+
+        $grams = explode(' ', $pattern);
+
+        foreach($grams as $key => $gram) {
+            $qb->andWhere('SIMILARITY(sp.fullnameCanonical, UNACCENT(LOWER(:default_'.$key.')) ) >= 0.15')
+                ->setParameter('default_'.$key, '%'.$gram.'%');
+        }
+
+        $qb->andWhere($qb->expr()
+            ->notIn(
+                'sp.id',
+                $this->createSearchQuery($pattern)
+                    ->addSelect('p.id')
+                    ->getDQL()
+            )
+        );
+
+        return $qb;
+    }
+}

src/Bundle/ChillPersonBundle/Repository/PersonACLAwareRepositoryInterface.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Chill\PersonBundle\Repository;
+
+use Chill\MainBundle\Search\ParsingException;
+use Chill\PersonBundle\Entity\Person;
+use Doctrine\ORM\NonUniqueResultException;
+
+interface PersonACLAwareRepositoryInterface
+{
+
+    /**
+     * @return array|Person[]
+     * @throws NonUniqueResultException
+     * @throws ParsingException
+     */
+    public function findBySearchCriteria(
+        int $start,
+        int $limit,
+        bool $simplify = false,
+        string $default = null,
+        string $firstname = null,
+        string $lastname = null,
+        ?\DateTime $birthdate = null,
+        ?\DateTime $birthdateBefore = null,
+        ?\DateTime $birthdateAfter = null,
+        string $gender = null,
+        string $countryCode = null
+    ): array;
+
+    public function countBySearchCriteria(
+        string $default = null,
+        string $firstname = null,
+        string $lastname = null,
+        ?\DateTime $birthdate = null,
+        ?\DateTime $birthdateBefore = null,
+        ?\DateTime $birthdateAfter = null,
+        string $gender = null,
+        string $countryCode = null
+    );
+
+    public function findBySimilaritySearch(
+        string $pattern,
+        int $firstResult,
+        int $maxResult,
+        bool $simplify = false
+    );
+
+    public function countBySimilaritySearch(string $pattern);
+}

src/Bundle/ChillPersonBundle/Repository/PersonRepository.php

@@ -23,9 +23,11 @@ use Chill\PersonBundle\Entity\Person;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\EntityRepository;
 use Doctrine\ORM\QueryBuilder;
+use Doctrine\Persistence\ObjectRepository;
+use UnexpectedValueException;
 
 
-final class PersonRepository
+final class PersonRepository implements ObjectRepository
 {
     private EntityRepository $repository;
 
@@ -44,6 +46,26 @@ final class PersonRepository
         return $this->repository->findBy(['id' => $ids]);
     }
 
+    public function findAll()
+    {
+        return $this->repository->findAll();
+    }
+
+    public function findBy(array $criteria, ?array $orderBy = null, $limit = null, $offset = null)
+    {
+        return $this->repository->findBy($criteria, $orderBy, $limit, $offset);
+    }
+
+    public function findOneBy(array $criteria)
+    {
+        return $this->repository->findOneBy($criteria);
+    }
+
+    public function getClassName()
+    {
+        return Person::class;
+    }
+
     /**
      * @param $centers
      * @param $firstResult

src/Bundle/ChillPersonBundle/Search/PersonSearch.php

@@ -20,71 +20,39 @@
 namespace Chill\PersonBundle\Search;
 
 use Chill\MainBundle\Search\AbstractSearch;
-use Doctrine\ORM\EntityManagerInterface;
+use Chill\PersonBundle\Repository\PersonACLAwareRepositoryInterface;
 use Chill\PersonBundle\Entity\Person;
 use Chill\MainBundle\Search\SearchInterface;
-use Symfony\Component\DependencyInjection\ContainerAwareInterface;
-use Symfony\Component\DependencyInjection\ContainerAwareTrait;
 use Chill\MainBundle\Search\ParsingException;
-use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
-use Chill\MainBundle\Security\Authorization\AuthorizationHelper;
-use Symfony\Component\Security\Core\Role\Role;
 use Chill\MainBundle\Pagination\PaginatorFactory;
 use Symfony\Component\Form\Extension\Core\Type\TextType;
 use Chill\MainBundle\Form\Type\ChillDateType;
 use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
 use Symfony\Component\Form\FormBuilderInterface;
 use Chill\MainBundle\Search\HasAdvancedSearchFormInterface;
-use Doctrine\ORM\Query;
+use Symfony\Component\Templating\EngineInterface;
 
-class PersonSearch extends AbstractSearch implements ContainerAwareInterface,
+class PersonSearch extends AbstractSearch implements HasAdvancedSearchFormInterface
-    HasAdvancedSearchFormInterface
 {
-    use ContainerAwareTrait;
+    protected EngineInterface $templating;
-
+    protected PaginatorFactory $paginatorFactory;
-    /**
+    protected PersonACLAwareRepositoryInterface $personACLAwareRepository;
-     *
-     * @var EntityManagerInterface
-     */
-    private $em;
-
-    /**
-     *
-     * @var \Chill\MainBundle\Entity\User
-     */
-    private $user;
-
-    /**
-     *
-     * @var AuthorizationHelper
-     */
-    private $helper;
-
-    /**
-     *
-     * @var PaginatorFactory
-     */
-    protected $paginatorFactory;
 
     const NAME = "person_regular";
 
+    private const POSSIBLE_KEYS = [
+        '_default', 'firstname', 'lastname', 'birthdate', 'birthdate-before',
+        'birthdate-after', 'gender', 'nationality'
+    ];
 
     public function __construct(
-          EntityManagerInterface $em,
+        EngineInterface $templating,
-          TokenStorageInterface $tokenStorage,
+        PaginatorFactory $paginatorFactory,
-          AuthorizationHelper $helper,
+        PersonACLAwareRepositoryInterface $personACLAwareRepository
-          PaginatorFactory $paginatorFactory)
+    ) {
-    {
+        $this->templating = $templating;
-        $this->em = $em;
-        $this->user = $tokenStorage->getToken()->getUser();
-        $this->helper = $helper;
         $this->paginatorFactory = $paginatorFactory;
-
+        $this->personACLAwareRepository = $personACLAwareRepository;
-        // throw an error if user is not a valid user
-        if (!$this->user instanceof \Chill\MainBundle\Entity\User) {
-            throw new \LogicException('The user provided must be an instance'
-                  . ' of Chill\MainBundle\Entity\User');
-        }
     }
 
     /*
@@ -120,12 +88,14 @@ class PersonSearch extends AbstractSearch implements ContainerAwareInterface,
         $paginator = $this->paginatorFactory->create($total);
 
         if ($format === 'html') {
-            return $this->container->get('templating')->render('@ChillPerson/Person/list_with_period.html.twig',
+            return $this->templating->render('@ChillPerson/Person/list_with_period.html.twig',
                     array(
                         'persons' => $this->search($terms, $start, $limit, $options),
-                        'pattern' => $this->recomposePattern($terms, array('nationality',
+                        'pattern' => $this->recomposePattern(
-                            'firstname', 'lastname', 'birthdate', 'gender',
+                            $terms,
-                            'birthdate-before','birthdate-after'), $terms['_domain']),
+                            \array_filter(self::POSSIBLE_KEYS, fn($item) => $item !== '_default'),
+                            $terms['_domain']
+                        ),
                         'total' => $total,
                         'start' => $start,
                         'search_name' => self::NAME,
@@ -152,158 +122,81 @@ class PersonSearch extends AbstractSearch implements ContainerAwareInterface,
      */
     protected function search(array $terms, $start, $limit, array $options = array())
     {
-        $qb = $this->createQuery($terms, 'search');
+        [
+            '_default' => $default,
+            'firstname' => $firstname,
+            'lastname' => $lastname,
+            'birthdate' => $birthdate,
+            'birthdate-before' => $birthdateBefore,
+            'birthdate-after' => $birthdateAfter,
+            'gender' => $gender,
+            'nationality' => $countryCode,
 
-        if ($options['simplify'] ?? false) {
+        ] = $terms + \array_fill_keys(self::POSSIBLE_KEYS, null);
-            $qb->select(
-                    'p.id',
-                    $qb->expr()->concat(
-                        'p.firstName',
-                        $qb->expr()->literal(' '),
-                        'p.lastName'
-                        ).'AS text'
-                );
-        } else {
-            $qb->select('p');
-        }
 
-        $qb
+        foreach (['birthdateBefore', 'birthdateAfter', 'birthdate'] as $v) {
-            ->setMaxResults($limit)
+            if (NULL !== ${$v}) {
-            ->setFirstResult($start);
-
-        //order by firstname, lastname
-
-        $qb
-            ->orderBy('p.firstName')
-            ->addOrderBy('p.lastName');
-
-        if ($options['simplify'] ?? false) {
-            return $qb->getQuery()->getResult(Query::HYDRATE_ARRAY);
-        } else {
-            return $qb->getQuery()->getResult();
-        }
-    }
-
-    protected function count(array $terms)
-    {
-        $qb = $this->createQuery($terms);
-
-        $qb->select('COUNT(p.id)');
-
-        return $qb->getQuery()->getSingleScalarResult();
-    }
-
-
-    private $_cacheQuery = array();
-
-    /**
-     *
-     * @param array $terms
-     * @return \Doctrine\ORM\QueryBuilder
-     */
-    public function createQuery(array $terms)
-    {
-        //get from cache
-        $cacheKey = md5(serialize($terms));
-        if (array_key_exists($cacheKey, $this->_cacheQuery)) {
-            return clone $this->_cacheQuery[$cacheKey];
-        }
-
-        $qb = $this->em->createQueryBuilder();
-
-        $qb->from('ChillPersonBundle:Person', 'p');
-
-        if (array_key_exists('firstname', $terms)) {
-            $qb->andWhere($qb->expr()->like('UNACCENT(LOWER(p.firstName))', ':firstname'))
-                  ->setParameter('firstname', '%'.$terms['firstname'].'%');
-        }
-
-        if (array_key_exists('lastname', $terms)) {
-            $qb->andWhere($qb->expr()->like('UNACCENT(LOWER(p.lastName))', ':lastname'))
-                  ->setParameter('lastname', '%'.$terms['lastname'].'%');
-        }
-
-        foreach (['birthdate', 'birthdate-before', 'birthdate-after'] as $key)
-        if (array_key_exists($key, $terms)) {
                 try {
-                $date = new \DateTime($terms[$key]);
+                    ${$v} = new \DateTime(${$v});
-            } catch (\Exception $ex) {
+                } catch (\Exception $e) {
                     throw new ParsingException('The date is '
-                      . 'not parsable', 0, $ex);
+                          . 'not parsable', 0, $e);
                 }
-
-            switch($key) {
-                case 'birthdate':
-                    $qb->andWhere($qb->expr()->eq('p.birthdate', ':birthdate'))
-                        ->setParameter('birthdate', $date);
-                    break;
-                case 'birthdate-before':
-                    $qb->andWhere($qb->expr()->lt('p.birthdate', ':birthdatebefore'))
-                        ->setParameter('birthdatebefore', $date);
-                    break;
-                case 'birthdate-after':
-                    $qb->andWhere($qb->expr()->gt('p.birthdate', ':birthdateafter'))
-                        ->setParameter('birthdateafter', $date);
-                    break;
-                default:
-                    throw new \LogicException("this case $key should not exists");
-            }
-
-        }
-
-        if (array_key_exists('gender', $terms)) {
-            if (!in_array($terms['gender'], array(Person::MALE_GENDER, Person::FEMALE_GENDER))) {
-                throw new ParsingException('The gender '
-                      .$terms['gender'].' is not accepted. Should be "'.Person::MALE_GENDER
-                      .'" or "'.Person::FEMALE_GENDER.'"');
-            }
-
-            $qb->andWhere($qb->expr()->eq('p.gender', ':gender'))
-              ->setParameter('gender', $terms['gender']);
-        }
-
-        if (array_key_exists('nationality', $terms)) {
-            try {
-                $country = $this->em->createQuery('SELECT c FROM '
-                      . 'ChillMainBundle:Country c WHERE '
-                      . 'LOWER(c.countryCode) LIKE :code')
-                      ->setParameter('code', $terms['nationality'])
-                      ->getSingleResult();
-            } catch (\Doctrine\ORM\NoResultException $ex)  {
-                throw new ParsingException('The country code "'.$terms['nationality'].'" '
-                      . ', used in nationality, is unknow', 0, $ex);
-            }
-
-            $qb->andWhere($qb->expr()->eq('p.nationality', ':nationality'))
-                  ->setParameter('nationality', $country);
-        }
-
-        if ($terms['_default'] !== '') {
-            $grams = explode(' ', $terms['_default']);
-
-            foreach($grams as $key => $gram) {
-                $qb->andWhere($qb->expr()
-                      ->like('p.fullnameCanonical', 'UNACCENT(LOWER(:default_'.$key.'))'))
-                      ->setParameter('default_'.$key, '%'.$gram.'%');
             }
         }
 
-        //restraint center for security
+        return $this->personACLAwareRepository
-        $reachableCenters = $this->helper->getReachableCenters($this->user,
+            ->findBySearchCriteria(
-                new Role('CHILL_PERSON_SEE'));
+                $start,
-        $qb->andWhere(
+                $limit,
-            $qb->expr()->orX(
+                $options['simplify'] ?? false,
-                $qb->expr()
+                $default,
-                    ->in('p.center', ':centers'),
+                $firstname,
-                $qb->expr()
+                $lastname,
-                    ->isNull('p.center')
+                $birthdate,
-            )
+                $birthdateBefore,
+                $birthdateAfter,
+                $gender,
+                $countryCode,
             );
-        $qb->setParameter('centers', $reachableCenters);
+    }
 
-        $this->_cacheQuery[$cacheKey] = $qb;
+    protected function count(array $terms): int
+    {
+        [
+            '_default' => $default,
+            'firstname' => $firstname,
+            'lastname' => $lastname,
+            'birthdate' => $birthdate,
+            'birthdate-before' => $birthdateBefore,
+            'birthdate-after' => $birthdateAfter,
+            'gender' => $gender,
+            'nationality' => $countryCode,
 
-        return clone $qb;
+        ] = $terms + \array_fill_keys(self::POSSIBLE_KEYS, null);
+
+        foreach (['birthdateBefore', 'birthdateAfter', 'birthdate'] as $v) {
+            if (NULL !== ${$v}) {
+                try {
+                    ${$v} = new \DateTime(${$v});
+                } catch (\Exception $e) {
+                    throw new ParsingException('The date is '
+                        . 'not parsable', 0, $e);
+                }
+            }
+        }
+
+        return $this->personACLAwareRepository
+            ->countBySearchCriteria(
+                $default,
+                $firstname,
+                $lastname,
+                $birthdate,
+                $birthdateBefore,
+                $birthdateAfter,
+                $gender,
+                $countryCode,
+            );
     }
 
     public function buildForm(FormBuilderInterface $builder)
@@ -396,4 +289,10 @@ class PersonSearch extends AbstractSearch implements ContainerAwareInterface,
         return 'Search within persons';
     }
 
+    public static function getAlias(): string
+    {
+        return self::NAME;
+    }
+
+
 }

src/Bundle/ChillPersonBundle/Search/SimilarityPersonSearch.php

@@ -2,88 +2,30 @@
 
 namespace Chill\PersonBundle\Search;
 
-
 use Chill\MainBundle\Pagination\PaginatorFactory;
 use Chill\MainBundle\Search\AbstractSearch;
 use Chill\MainBundle\Search\SearchInterface;
-use Chill\MainBundle\Security\Authorization\AuthorizationHelper;
+use Chill\PersonBundle\Repository\PersonACLAwareRepositoryInterface;
-use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\Templating\EngineInterface;
-use Symfony\Component\DependencyInjection\ContainerAwareInterface;
-use Symfony\Component\DependencyInjection\ContainerAwareTrait;
-use Symfony\Component\Form\FormBuilderInterface;
-use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
-use Symfony\Component\Security\Core\Role\Role;
 
-/**
- * Class SimilarityPersonSearch
- *
- * @package Chill\PersonBundle\Search
- */
 class SimilarityPersonSearch extends AbstractSearch
 {
+    protected PaginatorFactory $paginatorFactory;
 
-    use ContainerAwareTrait;
+    private PersonACLAwareRepositoryInterface $personACLAwareRepository;
 
-    /**
+    private EngineInterface $templating;
-     *
-     * @var EntityManagerInterface
-     */
-    private $em;
-    
-    /**
-     *
-     * @var \Chill\MainBundle\Entity\User
-     */
-    private $user;
-    
-    /**
-     *
-     * @var AuthorizationHelper
-     */
-    private $helper;
-    
-    /**
-     *
-     * @var PaginatorFactory
-     */
-    protected $paginatorFactory;
 
     const NAME = "person_similarity";
 
-    /**
-     *
-     * @var PersonSearch
-     */
-    private $personSearch;
-    
-    
-    /**
-     * SimilarityPersonSearch constructor.
-     *
-     * @param EntityManagerInterface $em
-     * @param TokenStorageInterface $tokenStorage
-     * @param AuthorizationHelper $helper
-     * @param PaginatorFactory $paginatorFactory
-     * @param PersonSearch $personSearch
-     */
     public function __construct(
-        EntityManagerInterface $em,
-        TokenStorageInterface $tokenStorage,
-        AuthorizationHelper $helper,
         PaginatorFactory $paginatorFactory,
-        PersonSearch $personSearch)
+        PersonACLAwareRepositoryInterface $personACLAwareRepository,
-    {
+        EngineInterface $templating
-        $this->em = $em;
+    ) {
-        $this->user = $tokenStorage->getToken()->getUser();
-        $this->helper = $helper;
         $this->paginatorFactory = $paginatorFactory;
-        $this->personSearch = $personSearch;
+        $this->personACLAwareRepository = $personACLAwareRepository;
-        
+        $this->templating = $templating;
-        // throw an error if user is not a valid user
-        if (!$this->user instanceof \Chill\MainBundle\Entity\User) {
-            throw new \LogicException('The user provided must be an instance'
-                . ' of Chill\MainBundle\Entity\User');
-        }
     }
 
     /*
@@ -115,18 +57,15 @@ class SimilarityPersonSearch extends AbstractSearch
      * @param int $limit
      * @param array $options
      * @param string $format
-     * @return array
      */
     public function renderResult(array $terms, $start = 0, $limit = 50, array $options = array(), $format = 'html')
     {
         $total = $this->count($terms);
         $paginator = $this->paginatorFactory->create($total);
 
-        if ($format === 'html')
+        if ($format === 'html') {
-        {
+            if ($total !== 0) {
-            if ($total !== 0)
+                return $this->templating->render('ChillPersonBundle:Person:list.html.twig',
-            {
-                return $this->container->get('templating')->render('ChillPersonBundle:Person:list.html.twig',
                     array(
                         'persons' => $this->search($terms, $start, $limit, $options),
                         'pattern' => $this->recomposePattern($terms, array('nationality',
@@ -144,8 +83,7 @@ class SimilarityPersonSearch extends AbstractSearch
                 return null;
             }
 
-        } elseif ($format === 'json')
+        } elseif ($format === 'json') {
-        {
             return [
                 'results' => $this->search($terms, $start, $limit, \array_merge($options, [ 'simplify' => true ])),
                 'pagination' => [
@@ -155,7 +93,6 @@ class SimilarityPersonSearch extends AbstractSearch
         }
     }
 
-    
     /**
      *
      * @param string $pattern
@@ -166,101 +103,12 @@ class SimilarityPersonSearch extends AbstractSearch
      */
     protected function search(array $terms, $start, $limit, array $options = array())
     {
-        $qb = $this->createQuery($terms, 'search');
+        return $this->personACLAwareRepository
-        
+            ->findBySimilaritySearch($terms['_default']);
-        
-        if ($options['simplify'] ?? false) {
-            $qb->select(
-                'sp.id',
-                $qb->expr()->concat(
-                    'sp.firstName',
-                    $qb->expr()->literal(' '),
-                    'sp.lastName'
-                ).'AS text'
-            );
-        } else {
-            $qb->select('sp');
     }
 
-        $qb
-            ->setMaxResults($limit)
-            ->setFirstResult($start);
-        
-        //order by firstname, lastname
-        
-        $qb
-            ->orderBy('sp.firstName')
-            ->addOrderBy('sp.lastName');
-        
-        if ($options['simplify'] ?? false) {
-            return $qb->getQuery()->getResult(Query::HYDRATE_ARRAY);
-        } else {
-            return $qb->getQuery()->getResult();
-        }
-    }
-    
-    
     protected function count(array $terms)
     {
-        $qb = $this->createQuery($terms);
+        return $this->personACLAwareRepository->countBySimilaritySearch($terms['_default']);
-
-        
-        $qb->select('COUNT(sp.id)');
-        
-        return $qb->getQuery()->getSingleScalarResult();
     }
-    
-    
-    private $_cacheQuery = array();
-    
-    /**
-     *
-     * @param array $terms
-     * @return \Doctrine\ORM\QueryBuilder
-     */
-    protected function createQuery(array $terms)
-    {
-        //get from cache
-        $cacheKey = md5(serialize($terms));
-        if (array_key_exists($cacheKey, $this->_cacheQuery)) {
-            return clone $this->_cacheQuery[$cacheKey];
-        }
-        
-        $qb = $this->em->createQueryBuilder();
-        
-        $qb ->select('sp')
-            ->from('ChillPersonBundle:Person', 'sp');
-        
-        if ($terms['_default'] !== '') {
-            $grams = explode(' ', $terms['_default']);
-            
-            foreach($grams as $key => $gram) {
-                $qb->andWhere('SIMILARITY(sp.fullnameCanonical, UNACCENT(LOWER(:default_'.$key.')) ) >= 0.15')
-                    ->setParameter('default_'.$key, '%'.$gram.'%');
-            }
-            
-            $qb->andWhere($qb->expr()
-                ->notIn(
-                    'sp.id',
-                    $this->personSearch
-                        ->createQuery($terms)
-                        ->addSelect('p.id')
-                        ->getDQL()
-                )
-            );
-        }
-        
-        //restraint center for security
-        $reachableCenters = $this->helper->getReachableCenters($this->user,
-            new Role('CHILL_PERSON_SEE'));
-        $qb->andWhere($qb->expr()
-            ->in('sp.center', ':centers'))
-            ->setParameter('centers', $reachableCenters)
-        ;
-        
-        $this->_cacheQuery[$cacheKey] = $qb;
-        
-        return clone $qb;
-    }
-    
 }

src/Bundle/ChillPersonBundle/config/services.yaml

@@ -70,7 +70,6 @@ services:
         autowire: true
         autoconfigure: true
         resource: '../Repository/'
-        tags: ['doctrine.repository_service']
 
     Chill\PersonBundle\Controller\:
         autowire: true

src/Bundle/ChillPersonBundle/config/services/repository.yaml

@@ -1,6 +1,11 @@
 services:
+    # note: the services.yaml file define some autoloading
+
     chill.person.repository.person:
         class: Chill\PersonBundle\Repository\PersonRepository
         autowire: true
         autoconfigure: true
     Chill\PersonBundle\Repository\PersonRepository: '@chill.person.repository.person'
+
+    Chill\PersonBundle\Repository\PersonACLAwareRepositoryInterface: '@Chill\PersonBundle\Repository\PersonACLAwareRepository'
+

src/Bundle/ChillPersonBundle/config/services/search.yaml

@@ -1,25 +1,11 @@
 services:
-    chill.person.search_person:
+    Chill\PersonBundle\Search\PersonSearch:
-        class: Chill\PersonBundle\Search\PersonSearch
+        autowire: true
-        arguments:
-            - "@doctrine.orm.entity_manager"
-            - "@security.token_storage"
-            - "@chill.main.security.authorization.helper"
-            - "@chill_main.paginator_factory"
-        calls:
-            - ['setContainer', ["@service_container"]]
         tags:
             - { name: chill.search, alias: 'person_regular' }
 
     Chill\PersonBundle\Search\SimilarityPersonSearch:
-        arguments:
+        autowire: true
-            - "@doctrine.orm.entity_manager"
-            - "@security.token_storage"
-            - "@chill.main.security.authorization.helper"
-            - "@chill_main.paginator_factory"
-            - '@chill.person.search_person'
-        calls:
-            - ['setContainer', ["@service_container"]]
         tags:
             - { name: chill.search, alias: 'person_similarity' }