Commit adfd43aa authored by David Surville's avatar David Surville
Browse files

[Tac] Factorisation de certaines méthodes des services dans une classe abstraite CommonService

parent 0364a982
Loading
Loading
Loading
Loading
Loading
+3 −8
Changes for config/merged/role.config.php: 3 added lines, 8 removed lines.
Original line number Diff line number Diff line
<?php

use UnicaenPrivilege\Guard\PrivilegeController;
use UnicaenUtilisateur\Controller\RoleController;
use UnicaenUtilisateur\Controller\RoleControllerFactory;
use UnicaenUtilisateur\Form\Role\RoleForm;
use UnicaenUtilisateur\Form\Role\RoleFormFactory;
use UnicaenUtilisateur\Form\Role\RoleHydrator;
use UnicaenUtilisateur\Form\Role\RoleHydratorFactory;
use UnicaenUtilisateur\Service\Role\RoleService;
use UnicaenUtilisateur\Service\Role\RoleServiceFactory;
use UnicaenUtilisateur\Provider\Privilege\RolePrivileges;
use UnicaenUtilisateur\Provider\Role\Config;
use UnicaenUtilisateur\Provider\Role\ConfigServiceFactory;
@@ -15,7 +14,8 @@ use UnicaenUtilisateur\Provider\Role\DbRole;
use UnicaenUtilisateur\Provider\Role\DbRoleServiceFactory;
use UnicaenUtilisateur\Provider\Role\Username;
use UnicaenUtilisateur\Provider\Role\UsernameServiceFactory;
use UnicaenPrivilege\Guard\PrivilegeController;
use UnicaenUtilisateur\Service\Role\RoleService;
use UnicaenUtilisateur\Service\Role\RoleServiceFactory;
use Zend\Router\Http\Literal;
use Zend\Router\Http\Segment;

@@ -132,9 +132,4 @@ return [
            RoleForm::class => RoleFormFactory::class,
        ],
    ],
    'hydrators' => [
        'factories' => [
            RoleHydrator::class => RoleHydratorFactory::class,
        ],
    ],
];
+103 −0
Changes for src/UnicaenUtilisateur/Service/CommonService.php: 103 added lines, 0 removed lines.
Original line number Diff line number Diff line
<?php

namespace UnicaenUtilisateur\Service;

use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\NonUniqueResultException;
use Doctrine\ORM\NoResultException;
use UnicaenApp\Service\EntityManagerAwareTrait;

abstract class CommonService
{
    use EntityManagerAwareTrait;

    /**
     * @var string
     */
    protected $entityClass;

    /**
     * Injecte la classe de l'entité liée au service
     *
     * @param string $entityClass
     * @return void
     */
    abstract public function setEntityClass(string $entityClass);

    /**
     * Retourne le nom de la classe de l'entité liée au service
     *
     * @return string
     */
    public function getEntityClass()
    {
        return $this->entityClass;
    }

    /**
     * Retourne une nouvelle instance de l'entité liée au service
     *
     * @return mixed
     */
    public function getEntityInstance()
    {
        return new $this->entityClass;
    }

    /**
     * Retourne le dépôt de l'entité liée au service
     *
     * @return EntityRepository
     */
    public function getRepo()
    {
        return $this->getEntityManager()->getRepository($this->entityClass);
    }

    /**
     * @param mixed $id
     * @return object|null
     */
    public function find($id)
    {
        return $this->getRepo()->find($id);
    }

    /**
     * Retourne une liste d'entités sous forme d'un tableau associatif dont les clés
     * sont les id des entités et les valeurs correspondent au champ choisi
     *
     * @param array $entities liste des entités
     * @param string $key attribut utilisé comme clé
     * @param string $value attribut utilisé pour les valeurs
     * @param string $entityClass classe de l'entité
     * @return array
     */
    public function getListForSelect($entities, $key = 'id', $value = 'libelle', $entityClass = null)
    {
        $entityClass = $entityClass ?: $this->getEntityClass();

        foreach ($entities as $entity) {
            if ($entity instanceof $entityClass
                && method_exists($entity, $kgetter = 'get' . ucfirst($key))
                && method_exists($entity, $vgetter = 'get' . ucfirst($value))) {
                $result[$entity->$kgetter()] = $entity->$vgetter();
            }
        }

        return (array)$result;
    }

    /**
     * @return float|int|mixed|string
     * @throws NonUniqueResultException
     * @throws NoResultException
     */
    public function getMaxOrdre()
    {
        $qb = $this->getRepo()->createQueryBuilder('e');
        $qb->select($qb->expr()->max('e.ordre'));

        return $qb->getQuery()->getSingleScalarResult();
    }
}
 No newline at end of file
+4 −46
Changes for src/UnicaenUtilisateur/Service/Role/RoleService.php: 4 added lines, 46 removed lines.
Original line number Diff line number Diff line
@@ -10,64 +10,22 @@ use UnicaenApp\Service\EntityManagerAwareTrait;
use UnicaenUtilisateur\Entity\Db\AbstractRole;
use UnicaenUtilisateur\Entity\Db\RoleInterface;
use UnicaenUtilisateur\Exception\RuntimeException;
use UnicaenUtilisateur\Service\CommonService;
use Zend\Mvc\Controller\AbstractActionController;

class RoleService
class RoleService extends CommonService
{
    use EntityManagerAwareTrait;

    /**
     * @var string
     */
    private $roleEntityClass;


    /**
     * @param string $roleEntityClass
     * @return void
     */
    public function setRoleEntityClass($roleEntityClass)
    public function setEntityClass($roleEntityClass)
    {
        if (! class_exists($roleEntityClass) || ! in_array(RoleInterface::class, class_implements($roleEntityClass))) {
            throw new InvalidArgumentException("L'entité associée aux rôles doit implémenter " . RoleInterface::class);
        }

        $this->roleEntityClass = $roleEntityClass;
    }

    /**
     * @return string
     */
    public function getEntityClass()
    {
        return $this->roleEntityClass;
    }

    /**
     * Retourne une nouvelle instance de l'entité lié au service
     *
     * @return RoleInterface
     */
    public function getEntityInstance()
    {
        return new $this->roleEntityClass;
    }

    /**
     * @return EntityRepository
     */
    public function getRepo()
    {
        return $this->getEntityManager()->getRepository($this->roleEntityClass);
    }

    /**
     * @param mixed $id
     * @return RoleInterface|null
     */
    public function find($id)
    {
        return $this->getRepo()->find($id);
        $this->entityClass = $roleEntityClass;
    }

    /**
+1 −1
Changes for src/UnicaenUtilisateur/Service/Role/RoleServiceFactory.php: 1 added line, 1 removed line.
Original line number Diff line number Diff line
@@ -26,7 +26,7 @@ class RoleServiceFactory

        $service = new RoleService();
        $service->setEntityManager($entityManager);
        $service->setRoleEntityClass($config['unicaen-auth']['role_entity_class'] ?? Role::class);
        $service->setEntityClass($config['unicaen-auth']['role_entity_class'] ?? Role::class);

        return $service;
    }
+4 −181
Changes for src/UnicaenUtilisateur/Service/User/UserService.php: 4 added lines, 181 removed lines.
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ use UnicaenAuthentification\Service\Traits\UserContextServiceAwareTrait;
use UnicaenUtilisateur\Entity\Db\RoleInterface;
use UnicaenUtilisateur\Entity\Db\UserInterface;
use UnicaenUtilisateur\Exception\RuntimeException;
use UnicaenUtilisateur\Service\CommonService;
use UnicaenUtilisateur\Service\RechercheIndividu\RechercheIndividuResultatInterface;
use UnicaenUtilisateur\Service\RechercheIndividu\RechercheIndividuServiceInterface;
use UnicaenUtilisateur\Service\Role\RoleServiceAwareTrait;
@@ -19,78 +20,19 @@ use Zend\Authentication\AuthenticationService;
use Zend\Crypt\Password\Bcrypt;
use Zend\Mvc\Controller\AbstractActionController;

class UserService implements RechercheIndividuServiceInterface
class UserService extends CommonService implements RechercheIndividuServiceInterface
{
    use EntityManagerAwareTrait;
    use UserContextServiceAwareTrait;
    use RoleServiceAwareTrait;

    /**
     * @var string
     */
    private $userEntityClass;

    /**
     * @var AuthenticationService
     */
    private $authenticationService;


    /**
     * @param string $userEntityClass
     * @return void
     */
    public function setUserEntityClass($userEntityClass)
    public function setEntityClass($userEntityClass)
    {
        if (! class_exists($userEntityClass) || ! in_array(UserInterface::class, class_implements($userEntityClass))) {
            throw new InvalidArgumentException("L'entité associée aux utilisateurs doit implémenter " . UserInterface::class);
        }

        $this->userEntityClass = $userEntityClass;
    }

    /**
     * @return string
     */
    public function getEntityClass()
    {
        return $this->userEntityClass;
    }

    /**
     * Retourne une nouvelle instance de l'entité lié au service
     *
     * @return UserInterface
     */
    public function getEntityInstance()
    {
        return new $this->userEntityClass;
    }

    /**
     * @param AuthenticationService $authenticationService
     * @return void
     */
    public function setAuthenticationService(AuthenticationService $authenticationService)
    {
        $this->authenticationService = $authenticationService;
    }

    /**
     * @return EntityRepository
     */
    public function getRepo()
    {
        return $this->getEntityManager()->getRepository($this->userEntityClass);
    }

    /**
     * @param mixed $id
     * @return UserInterface|null
     */
    public function find($id)
    {
        return $this->getRepo()->find($id);
        $this->entityClass = $userEntityClass;
    }

    /**
@@ -140,27 +82,6 @@ class UserService implements RechercheIndividuServiceInterface
        return $utilisateurs;
    }

    /**
     * @param string $texte
     * @param string $roleId
     * @return UserInterface[]
     */
    public function findByTermAndRole(string $texte, string $roleId)
    {
        $texte = strtolower($texte);
        $qb = $this->getRepo()->createQueryBuilder("u")
            ->andWhere("LOWER(u.displayName) LIKE :critere")
            ->setParameter("critere", '%'.strtolower($texte).'%')
            ->addSelect('r')->join('u.roles', 'r')
            ->andWhere('r.roleId = :role')
            ->setParameter("role", $roleId)
            ->orderBy("u.displayName");

        $utilisateurs = $qb->getQuery()->getResult();

        return $utilisateurs;
    }

    /**
     * @param RechercheIndividuResultatInterface $individu
     * @param string $source
@@ -301,103 +222,5 @@ class UserService implements RechercheIndividuServiceInterface
            throw new RuntimeException("Un problème est survenu lors de la suppression de l'utilisateur " . $utilisateur->getUsername() . ".", null, $e);
        }
    }

    /**
     * @param RoleInterface $role
     * @return UserInterface[]
     */
    public function findByRole(RoleInterface $role)
    {
        $qb = $this->getRepo()->createQueryBuilder('u')
            ->addSelect('r')->join('u.roles', 'r')
            ->andWhere('r.roleId = :role')
            ->setParameter('role', $role->getRoleId());

        return $qb->getQuery()->getResult();
    }

    /**
     * @return UserInterface
     */
    public function getConnectedUser()
    {
        $identity = $this->authenticationService->getIdentity();

        if ($identity) {
            $username = null;
            if (isset($identity['ldap'])) {
                /** @var People $userIdentity */
                $userIdentity = $identity['ldap'];
                $username = $userIdentity->getSupannAliasLogin();
                $user = $this->findByUsername($username);

                return $user;
            }
            if (isset($identity['shib'])) {
                /** @var People $userIdentity */
                $userIdentity = $identity['shib'];
                $username = $userIdentity->getUsername();
                $user = $this->findByUsername($username);

                return $user;
            }
            if (isset($identity['db'])) {
                return $identity['db'];
            }
        }

        return null;
    }

    /**
     * @return \Zend\Permissions\Acl\Role\RoleInterface|null
     */
    public function getConnectedRole()
    {
        $identity = $this->authenticationService->getIdentity();
        $dbRole = $this->serviceUserContext->getSelectedIdentityRole();

        return $dbRole;
    }

    /**
     * @param $string
     * @return array
     */
    public function getUtilisateursByRoleIdAsOptions($string)
    {
        $role = $this->roleService->findByRoleId($string);
        $users = $this->findByRole($role);

        $array = [];
        foreach ($users as $user) {
            $array[$user->getId()] = $user->getDisplayName();
        }

        return $array;
    }

    /**
     * @param UserInterface[] $users
     * @return array
     */
    public function formatUserJSON($users)
    {
        $result = [];

        /** @var User[] $responsables */
        foreach ($users as $user) {
            $result[] = array(
                'id'    => $user->getId(),
                'label' => $user->getDisplayName(),
                'extra' => "<span class='badge' style='background-color: slategray;'>".$user->getEmail()."</span>",
            );
        }
        usort($result, function($a, $b) {
            return strcmp($a['label'], $b['label']);
        });

        return $result;
    }
}
Loading