src/Security/UserProvider.php line 53

Open in your IDE?
  1. <?php
  3. namespace App\Security;
  5. use App\Entity\Client;
  6. use App\Services\CallApiServices;
  7. use App\Services\QuestionMailService;
  8. use Symfony\Component\Security\Core\User\UserInterface;
  9. use Symfony\Component\Security\Core\User\UserProviderInterface;
  10. use Symfony\Component\Security\Core\User\PasswordUpgraderInterface;
  11. use Symfony\Component\Security\Core\Exception\UserNotFoundException;
  12. use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
  13. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  14. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  16. class UserProvider implements UserProviderInterface, PasswordUpgraderInterface
  17. {
  18.     private $callApiServices;
  19.     private $encoder;
  20.     private $questionMailService;
  22.     public function __construct(CallApiServices $callApiServices, UserPasswordHasherInterface $encoder, QuestionMailService $questionMailService)
  23.     {
  24.         $this->encoder = $encoder;
  25.         $this->callApiServices = $callApiServices;
  26.         $this->questionMailService = $questionMailService;
  27.     }
  28.     /**
  29.      * Symfony calls this method if you use features like switch_user
  30.      * or remember_me.
  31.      *
  32.      * If you're not using these features, you do not need to implement
  33.      * this method.
  34.      *
  35.      * @throws UserNotFoundException
  36.      * 
  37.      * 
  38.      *  not found
  39.      */
  40.     public function loadUserByIdentifier($identifier): UserInterface
  41.     {
  42.         $password = $_REQUEST['password'];
  43.         $email = $identifier;
  44.       
  46.         // $token = $this->callApiServices->authApi($email, $password);
  47.         // $user = $this->callApiServices->getUserDetails($token['token']);
  49.         $user = $this->callApiServices->clientAuthentification($email, $password, 1033);
  50.       
  51.         if (isset($user['responseCode'])){
  52.             $error404 = $user['message'];
  53.             throw new UserNotFoundException("Error Processing Request", 1); 
  54.         }else{
  55.             $client = new Client();
  56.             $client->setApiToken($user['apiToken']);
  57.             $client->setEmail($user['username']);
  58.             $client->setApiToken($user['apiToken']);
  59.             $client->setLimitToken($user['limitToken']);
  60.             $client->setFirstName($user['prenom']);
  61.             $client->setLastName($user['nom']);
  62.             $client->setClientId($user['clientId']);
  63.             $client->setServiceId($user['serviceId']);
  64.             $client->setGenre($user['genre']);
  65.             $client->setSolde($user['solde']);
  66.             $client->setCredit($user['credit']);
  67.             $client->setCode($user['code']);
  68.             $client->setAddressIP($user['clientIp']);
  69.             // $client->setRoles($user['roles']);
  70.             $passHash = $this->encoder->hashPassword($client, $password);
  71.             $client->setPassword($passHash);
  72.             $client = $this->questionMailService->getEmail($this->callApiServices, $client);
  73.         }
  76.      
  77.       
  79.         // Load a User object from your data source or throw UserNotFoundException.
  80.         // The $identifier argument may not actually be a username:
  81.         // it is whatever value is being returned by the getUserIdentifier()
  82.         // method in your User class.
  83.         // throw new \Exception('TODO: fill in loadUserByIdentifier() inside ' . __FILE__);
  84.         return $client;
  85.     }
  87.     /**
  88.      * @deprecated since Symfony 5.3, loadUserByIdentifier() is used instead
  89.      */
  90.     public function loadUserByUsername($username): UserInterface
  91.     {
  92.         return $this->loadUserByIdentifier($username);
  93.     }
  95.     /**
  96.      * Refreshes the user after being reloaded from the session.
  97.      *
  98.      * When a user is logged in, at the beginning of each request, the
  99.      * User object is loaded from the session and then this method is
  100.      * called. Your job is to make sure the user's data is still fresh by,
  101.      * for example, re-querying for fresh User data.
  102.      *
  103.      * If your firewall is "stateless: true" (for a pure API), this
  104.      * method is not called.
  105.      */
  106.     public function refreshUser(UserInterface $user): UserInterface
  107.     {
  108.         if (!$user instanceof Client) {
  109.             throw new UnsupportedUserException(sprintf('Invalid user class "%s".', get_class($user)));
  110.         }
  112.         // Return a User object after making sure its data is "fresh".
  113.         // Or throw a UsernameNotFoundException if the user no longer exists.
  114.         return $user;
  115.     }
  117.     /**
  118.      * Tells Symfony to use this provider for this User class.
  119.      */
  120.     public function supportsClass($class): bool
  121.     {
  122.         return Client::class === $class || is_subclass_of($class, Client::class);
  123.     }
  125.     /**
  126.      * Upgrades the hashed password of a user, typically for using a better hash algorithm.
  127.      */
  128.     public function upgradePassword(PasswordAuthenticatedUserInterface $user, string $newHashedPassword): void
  129.     {
  130.         // TODO: when hashed passwords are in use, this method should:
  131.         // 1. persist the new password in the user storage
  132.         // 2. update the $user object with $user->setPassword($newHashedPassword);
  133.     }
  134. }