src/Security/WebUser.php line 46

  1. <?php
  3. namespace App\Security;
  5. use App\Entity\User;
  6. use Doctrine\ORM\EntityManager;
  7. use Doctrine\ORM\OptimisticLockException;
  8. //use Doctrine\ORM\ORMException;
  9. use Doctrine\ORM\ORMException;
  10. use Symfony\Component\Ldap\Entry;
  11. use Symfony\Component\Ldap\Exception\ConnectionException;
  12. use Symfony\Component\Ldap\LdapInterface;
  13. use Symfony\Component\Security\Core\Exception\InvalidArgumentException;
  14. use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
  15. use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
  16. //use AppBundle\Entity\User;
  17. //use Symfony\Component\Security\Core\Exception\UserNotFoundException;
  18. use Symfony\Component\Security\Core\User\UserInterface;
  19. use Symfony\Component\Security\Core\User\UserProviderInterface;
  20. //use AppBundle\Security\LdapUserProvider;
  22. class WebUser implements UserProviderInterface
  23. {
  24.     private LdapInterface $ldap;
  25.     private string $baseDn;
  26.     private $searchDn;
  27.     private $searchPassword;
  28.     private array $defaultRoles;
  29.     private string|array $defaultSearch;
  30.     private $filterAdmin;
  31.     private $passwordAttribute;
  32.     private EntityManager $em;
  34.     /**
  35.      * @param LdapInterface $ldap
  36.      * @param string $baseDn
  37.      * @param null $searchDn
  38.      * @param null $searchPassword
  39.      * @param array $defaultRoles
  40.      * @param string $uidKey
  41.      * @param EntityManager $em
  42.      * @param string $filterAdmin
  43.      * @param string $filter
  44.      * @param null $passwordAttribute
  45.      */
  46.     public function __construct(
  47.         LdapInterface $ldap,
  48.         $baseDn,
  49.         $searchDn = null,
  50.         $searchPassword = null,
  51.         array $defaultRoles = array(),
  52.         $uidKey = 'sAMAccountName',
  53.         EntityManager $em,
  54.         $filterAdmin = '(memberUid={username})',
  55.         $filter = '({uid_key}={username})',
  56.         $passwordAttribute = null
  57.     ) {
  58.         $this->ldap = $ldap;
  59.         $this->baseDn = $baseDn;
  60.         $this->searchDn = $searchDn;
  61.         $this->searchPassword = $searchPassword;
  62.         $this->defaultRoles = $defaultRoles;
  63.         $this->em = $em;
  64.         $this->defaultSearch = str_replace('{uid_key}', $uidKey, $filter);
  65.         $this->filterAdmin = $filterAdmin;
  66.         $this->passwordAttribute = $passwordAttribute;
  67.     }
  69.     /**
  70.      * @throws OptimisticLockException
  71.      */
  72.     public function loadUserByUsername($username)
  73.     {
  74.         try {
  75.             $this->ldap->bind($this->searchDn, $this->searchPassword);
  76.             $username = $this->ldap->escape($username, '', LdapInterface::ESCAPE_FILTER);
  77.             $query = str_replace('{username}', $username, $this->defaultSearch);
  78.             $search = $this->ldap->query($this->baseDn, $query);
  79.         } catch (ConnectionException $e) {
  80.             throw new UsernameNotFoundException(sprintf('User "%s" not found.', $username), 0, $e);
  81.         }
  83.         $entries = $search->execute();
  84.         $count = count($entries);
  86.         if (!$count) {
  87.             throw new UsernameNotFoundException(sprintf('User "%s" not found.', $username));
  88.         }
  90.         if ($count > 1) {
  91.             throw new UsernameNotFoundException('More than one user found');
  92.         }
  94.         // Lorsque nous avons vérifier que l'utilisateur existe bien dans le LDAP on peut le loader/créer son compte utilisateur
  95.         return $this->loadUser($username, $entries[0]);
  96.     }
  98.     /**
  99.      * {@inheritdoc}
  100.      */
  101.     public function refreshUser(UserInterface $user)
  102.     {
  103.         if (!$user instanceof User) {
  104.             throw new UnsupportedUserException(sprintf('Instances of "%s" are not supported.', get_class($user)));
  105.         }
  107.         $userRepository = $this->em->getRepository("AppBundle:User");
  108.         $user = $userRepository->findOneBy(array("username" => $user->getUsername()));
  110.         if ($user === null) {
  111.             throw new UnsupportedUserException(sprintf('Instances of "%s" are not supported.', get_class($user)));
  112.         }
  114.         return $user;
  115.     }
  117.     /**
  118.      * {@inheritdoc}
  119.      */
  120.     public function supportsClass($class): bool
  121.     {
  122.         return $class === User::class;
  123.     }
  125.     /**
  126.      * Loads a user from an LDAP entry.
  127.      * @param string $username
  128.      * @param Entry $entry
  129.      * @return User
  130.      * @throws OptimisticLockException|ORMException
  131.      */
  132.     protected function loadUser(string $username, Entry $entry): User
  133.     {
  134.         $userRepository = $this->em->getRepository("AppBundle:User");
  135.         $user = $userRepository->findOneBy(array("username" => $username));
  137.         if ($user === null) {
  138.             $user = new User();
  139.             $user->setFirstname($entry->getAttribute("givenName")[0]);
  140.             $user->setLastname($entry->getAttribute("sn")[0]);
  141.             $user->setEmail($entry->getAttribute("mail")[0]);
  142.             $user->setUsername($entry->getAttribute("uid")[0]);
  143.             $user->setRoles($this->defaultRoles);
  145.             $this->em->persist($user);
  146.         }
  147.         $this->em->flush();
  149.         return $user;
  150.     }
  152.     /**
  153.      * Fetches the password from an LDAP entry.
  154.      *
  155.      * @param Entry $entry
  156.      * @return mixed|void
  157.      */
  158.     private function getPassword(Entry $entry)
  159.     {
  160.         if (null === $this->passwordAttribute) {
  161.             return;
  162.         }
  164.         if (!$entry->hasAttribute($this->passwordAttribute)) {
  165.             throw new InvalidArgumentException(sprintf('Missing attribute "%s" for user "%s".', $this->passwordAttribute, $entry->getDn()));
  166.         }
  168.         $values = $entry->getAttribute($this->passwordAttribute);
  170.         if (1 !== count($values)) {
  171.             throw new InvalidArgumentException(sprintf('Attribute "%s" has multiple values.', $this->passwordAttribute));
  172.         }
  174.         return $values[0];
  175.     }
  177.     public function loadUserByIdentifier(string $identifier): UserInterface
  178.     {
  179.         // TODO: Implement loadUserByIdentifier() method.
  180.     }
  181. }