Rename providerKey to firewallName for more consistent naming

wouterj · wouterj · commit 9a34d0602271 · 2020-04-20T14:20:56.000+02:00
diff --git a/Authentication/AuthenticatorManager.php b/Authentication/AuthenticatorManager.php
@@ -47,17 +47,17 @@ class AuthenticatorManager implements AuthenticatorManagerInterface, UserAuthent
     private $eventDispatcher;
     private $eraseCredentials;
     private $logger;
-    private $providerKey;
+    private $firewallName;
 
     /**
-     * @param AuthenticatorInterface[] $authenticators The authenticators, with their unique providerKey as key
+     * @param AuthenticatorInterface[] $authenticators
      */
-    public function __construct(iterable $authenticators, TokenStorageInterface $tokenStorage, EventDispatcherInterface $eventDispatcher, string $providerKey, ?LoggerInterface $logger = null, bool $eraseCredentials = true)
+    public function __construct(iterable $authenticators, TokenStorageInterface $tokenStorage, EventDispatcherInterface $eventDispatcher, string $firewallName, ?LoggerInterface $logger = null, bool $eraseCredentials = true)
     {
         $this->authenticators = $authenticators;
         $this->tokenStorage = $tokenStorage;
         $this->eventDispatcher = $eventDispatcher;
-        $this->providerKey = $providerKey;
+        $this->firewallName = $firewallName;
         $this->logger = $logger;
         $this->eraseCredentials = $eraseCredentials;
     }
@@ -68,7 +68,7 @@ public function __construct(iterable $authenticators, TokenStorageInterface $tok
     public function authenticateUser(UserInterface $user, AuthenticatorInterface $authenticator, Request $request, array $badges = []): ?Response
     {
         // create an authenticated token for the User
-        $token = $authenticator->createAuthenticatedToken($passport = new SelfValidatingPassport($user, $badges), $this->providerKey);
+        $token = $authenticator->createAuthenticatedToken($passport = new SelfValidatingPassport($user, $badges), $this->firewallName);
 
         // authenticate this in the system
         return $this->handleAuthenticationSuccess($token, $passport, $request, $authenticator);
@@ -77,43 +77,43 @@ public function authenticateUser(UserInterface $user, AuthenticatorInterface $au
     public function supports(Request $request): ?bool
     {
         if (null !== $this->logger) {
-            $context = ['firewall_key' => $this->providerKey];
+            $context = ['firewall_key' => $this->firewallName];
 
             if ($this->authenticators instanceof \Countable || \is_array($this->authenticators)) {
                 $context['authenticators'] = \count($this->authenticators);
             }
 
-            $this->logger->debug('Checking for guard authentication credentials.', $context);
+            $this->logger->debug('Checking for authenticator support.', $context);
         }
 
         $authenticators = [];
         $lazy = true;
-        foreach ($this->authenticators as $key => $authenticator) {
+        foreach ($this->authenticators as $authenticator) {
             if (null !== $this->logger) {
-                $this->logger->debug('Checking support on authenticator.', ['firewall_key' => $this->providerKey, 'authenticator' => \get_class($authenticator)]);
+                $this->logger->debug('Checking support on authenticator.', ['firewall_key' => $this->firewallName, 'authenticator' => \get_class($authenticator)]);
             }
 
             if (false !== $supports = $authenticator->supports($request)) {
-                $authenticators[$key] = $authenticator;
+                $authenticators[] = $authenticator;
                 $lazy = $lazy && null === $supports;
             } elseif (null !== $this->logger) {
-                $this->logger->debug('Authenticator does not support the request.', ['firewall_key' => $this->providerKey, 'authenticator' => \get_class($authenticator)]);
+                $this->logger->debug('Authenticator does not support the request.', ['firewall_key' => $this->firewallName, 'authenticator' => \get_class($authenticator)]);
             }
         }
 
         if (!$authenticators) {
             return false;
         }
 
-        $request->attributes->set('_guard_authenticators', $authenticators);
+        $request->attributes->set('_security_authenticators', $authenticators);
 
         return $lazy ? null : true;
     }
 
     public function authenticateRequest(Request $request): ?Response
     {
-        $authenticators = $request->attributes->get('_guard_authenticators');
-        $request->attributes->remove('_guard_authenticators');
+        $authenticators = $request->attributes->get('_security_authenticators');
+        $request->attributes->remove('_security_authenticators');
         if (!$authenticators) {
             return null;
         }
@@ -126,15 +126,16 @@ public function authenticateRequest(Request $request): ?Response
      */
     private function executeAuthenticators(array $authenticators, Request $request): ?Response
     {
-        foreach ($authenticators as $key => $authenticator) {
-            // recheck if the authenticator still supports the listener. support() is called
+        foreach ($authenticators as $authenticator) {
+            // recheck if the authenticator still supports the listener. supports() is called
             // eagerly (before token storage is initialized), whereas authenticate() is called
             // lazily (after initialization). This is important for e.g. the AnonymousAuthenticator
             // as its support is relying on the (initialized) token in the TokenStorage.
             if (false === $authenticator->supports($request)) {
                 if (null !== $this->logger) {
                     $this->logger->debug('Skipping the "{authenticator}" authenticator as it did not support the request.', ['authenticator' => \get_class($authenticator)]);
                 }
+
                 continue;
             }
 
@@ -165,7 +166,7 @@ private function executeAuthenticator(AuthenticatorInterface $authenticator, Req
             $passport->checkIfCompletelyResolved();
 
             // create the authenticated token
-            $authenticatedToken = $authenticator->createAuthenticatedToken($passport, $this->providerKey);
+            $authenticatedToken = $authenticator->createAuthenticatedToken($passport, $this->firewallName);
             if (true === $this->eraseCredentials) {
                 $authenticatedToken->eraseCredentials();
             }
@@ -204,7 +205,7 @@ private function handleAuthenticationSuccess(TokenInterface $authenticatedToken,
     {
         $this->tokenStorage->setToken($authenticatedToken);
 
-        $response = $authenticator->onAuthenticationSuccess($request, $authenticatedToken, $this->providerKey);
+        $response = $authenticator->onAuthenticationSuccess($request, $authenticatedToken, $this->firewallName);
         if ($authenticator instanceof InteractiveAuthenticatorInterface && $authenticator->isInteractive()) {
             $loginEvent = new InteractiveLoginEvent($request, $authenticatedToken);
             $this->eventDispatcher->dispatch($loginEvent, SecurityEvents::INTERACTIVE_LOGIN);
@@ -233,7 +234,7 @@ private function handleAuthenticationFailure(AuthenticationException $authentica
             $this->logger->debug('The "{authenticator}" authenticator set the failure response.', ['authenticator' => \get_class($authenticator)]);
         }
 
-        $this->eventDispatcher->dispatch($loginFailureEvent = new LoginFailureEvent($authenticationException, $authenticator, $request, $response, $this->providerKey));
+        $this->eventDispatcher->dispatch($loginFailureEvent = new LoginFailureEvent($authenticationException, $authenticator, $request, $response, $this->firewallName));
 
         // returning null is ok, it means they want the request to continue
         return $loginFailureEvent->getResponse();
diff --git a/Authenticator/AbstractAuthenticator.php b/Authenticator/AbstractAuthenticator.php
@@ -32,12 +32,12 @@ abstract class AbstractAuthenticator implements AuthenticatorInterface
      *
      * @return PostAuthenticationToken
      */
-    public function createAuthenticatedToken(PassportInterface $passport, string $providerKey): TokenInterface
+    public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface
     {
         if (!$passport instanceof UserPassportInterface) {
             throw new LogicException(sprintf('Passport does not contain a user, overwrite "createAuthenticatedToken()" in "%s" to create a custom authenticated token.', \get_class($this)));
         }
 
-        return new PostAuthenticationToken($passport->getUser(), $providerKey, $passport->getUser()->getRoles());
+        return new PostAuthenticationToken($passport->getUser(), $firewallName, $passport->getUser()->getRoles());
     }
 }
diff --git a/Authenticator/AbstractPreAuthenticatedAuthenticator.php b/Authenticator/AbstractPreAuthenticatedAuthenticator.php
@@ -92,12 +92,12 @@ public function authenticate(Request $request): PassportInterface
         return new SelfValidatingPassport($user, [new PreAuthenticatedUserBadge()]);
     }
 
-    public function createAuthenticatedToken(PassportInterface $passport, string $providerKey): TokenInterface
+    public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface
     {
-        return new PreAuthenticatedToken($passport->getUser(), null, $providerKey, $passport->getUser()->getRoles());
+        return new PreAuthenticatedToken($passport->getUser(), null, $firewallName, $passport->getUser()->getRoles());
     }
 
-    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $providerKey): ?Response
+    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response
     {
         return null; // let the original request continue
     }
diff --git a/Authenticator/AnonymousAuthenticator.php b/Authenticator/AnonymousAuthenticator.php
@@ -50,12 +50,12 @@ public function authenticate(Request $request): PassportInterface
         return new AnonymousPassport();
     }
 
-    public function createAuthenticatedToken(PassportInterface $passport, string $providerKey): TokenInterface
+    public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface
     {
         return new AnonymousToken($this->secret, 'anon.', []);
     }
 
-    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $providerKey): ?Response
+    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response
     {
         return null; // let the original request continue
     }
diff --git a/Authenticator/AuthenticatorInterface.php b/Authenticator/AuthenticatorInterface.php
@@ -63,7 +63,7 @@ public function authenticate(Request $request): PassportInterface;
      *
      * @param PassportInterface $passport The passport returned from authenticate()
      */
-    public function createAuthenticatedToken(PassportInterface $passport, string $providerKey): TokenInterface;
+    public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface;
 
     /**
      * Called when authentication executed and was successful!
@@ -74,7 +74,7 @@ public function createAuthenticatedToken(PassportInterface $passport, string $pr
      * If you return null, the current request will continue, and the user
      * will be authenticated. This makes sense, for example, with an API.
      */
-    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $providerKey): ?Response;
+    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response;
 
     /**
      * Called when authentication executed, but failed (e.g. wrong username password).
diff --git a/Authenticator/FormLoginAuthenticator.php b/Authenticator/FormLoginAuthenticator.php
@@ -100,12 +100,12 @@ public function authenticate(Request $request): PassportInterface
     /**
      * @param Passport $passport
      */
-    public function createAuthenticatedToken(PassportInterface $passport, $providerKey): TokenInterface
+    public function createAuthenticatedToken(PassportInterface $passport, $firewallName): TokenInterface
     {
-        return new UsernamePasswordToken($passport->getUser(), null, $providerKey, $passport->getUser()->getRoles());
+        return new UsernamePasswordToken($passport->getUser(), null, $firewallName, $passport->getUser()->getRoles());
     }
 
-    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $providerKey): ?Response
+    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response
     {
         return $this->successHandler->onAuthenticationSuccess($request, $token);
     }
diff --git a/Authenticator/HttpBasicAuthenticator.php b/Authenticator/HttpBasicAuthenticator.php
@@ -82,12 +82,12 @@ public function authenticate(Request $request): PassportInterface
     /**
      * @param Passport $passport
      */
-    public function createAuthenticatedToken(PassportInterface $passport, $providerKey): TokenInterface
+    public function createAuthenticatedToken(PassportInterface $passport, $firewallName): TokenInterface
     {
-        return new UsernamePasswordToken($passport->getUser(), null, $providerKey, $passport->getUser()->getRoles());
+        return new UsernamePasswordToken($passport->getUser(), null, $firewallName, $passport->getUser()->getRoles());
     }
 
-    public function onAuthenticationSuccess(Request $request, TokenInterface $token, $providerKey): ?Response
+    public function onAuthenticationSuccess(Request $request, TokenInterface $token, $firewallName): ?Response
     {
         return null;
     }
diff --git a/Authenticator/JsonLoginAuthenticator.php b/Authenticator/JsonLoginAuthenticator.php
@@ -93,12 +93,12 @@ public function authenticate(Request $request): PassportInterface
         return $passport;
     }
 
-    public function createAuthenticatedToken(PassportInterface $passport, string $providerKey): TokenInterface
+    public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface
     {
-        return new UsernamePasswordToken($passport->getUser(), null, $providerKey, $passport->getUser()->getRoles());
+        return new UsernamePasswordToken($passport->getUser(), null, $firewallName, $passport->getUser()->getRoles());
     }
 
-    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $providerKey): ?Response
+    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response
     {
         if (null === $this->successHandler) {
             return null; // let the original request continue
diff --git a/Authenticator/RememberMeAuthenticator.php b/Authenticator/RememberMeAuthenticator.php
@@ -76,12 +76,12 @@ public function authenticate(Request $request): PassportInterface
         return new SelfValidatingPassport($token->getUser());
     }
 
-    public function createAuthenticatedToken(PassportInterface $passport, string $providerKey): TokenInterface
+    public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface
     {
-        return new RememberMeToken($passport->getUser(), $providerKey, $this->secret);
+        return new RememberMeToken($passport->getUser(), $firewallName, $this->secret);
     }
 
-    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $providerKey): ?Response
+    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response
     {
         return null; // let the original request continue
     }
diff --git a/Authenticator/Token/PostAuthenticationToken.php b/Authenticator/Token/PostAuthenticationToken.php
@@ -7,24 +7,23 @@
 
 class PostAuthenticationToken extends AbstractToken
 {
-    private $providerKey;
+    private $firewallName;
 
     /**
-     * @param string   $providerKey The provider (firewall) key
-     * @param string[] $roles       An array of roles
+     * @param string[] $roles An array of roles
      *
      * @throws \InvalidArgumentException
      */
-    public function __construct(UserInterface $user, string $providerKey, array $roles)
+    public function __construct(UserInterface $user, string $firewallName, array $roles)
     {
         parent::__construct($roles);
 
-        if (empty($providerKey)) {
-            throw new \InvalidArgumentException('$providerKey (i.e. firewall key) must not be empty.');
+        if (empty($firewallName)) {
+            throw new \InvalidArgumentException('$firewallName must not be empty.');
         }
 
         $this->setUser($user);
-        $this->providerKey = $providerKey;
+        $this->firewallName = $firewallName;
 
         // this token is meant to be used after authentication success, so it is always authenticated
         // you could set it as non authenticated later if you need to
@@ -42,30 +41,25 @@ public function getCredentials()
         return [];
     }
 
-    /**
-     * Returns the provider (firewall) key.
-     *
-     * @return string
-     */
-    public function getProviderKey()
+    public function getFirewallName(): string
     {
-        return $this->providerKey;
+        return $this->firewallName;
     }
 
     /**
      * {@inheritdoc}
      */
     public function __serialize(): array
     {
-        return [$this->providerKey, parent::__serialize()];
+        return [$this->firewallName, parent::__serialize()];
     }
 
     /**
      * {@inheritdoc}
      */
     public function __unserialize(array $data): void
     {
-        [$this->providerKey, $parentData] = $data;
+        [$this->firewallName, $parentData] = $data;
         parent::__unserialize($parentData);
     }
 }
diff --git a/Event/LoginFailureEvent.php b/Event/LoginFailureEvent.php
@@ -22,15 +22,15 @@ class LoginFailureEvent extends Event
     private $authenticator;
     private $request;
     private $response;
-    private $providerKey;
+    private $firewallName;
 
-    public function __construct(AuthenticationException $exception, AuthenticatorInterface $authenticator, Request $request, ?Response $response, string $providerKey)
+    public function __construct(AuthenticationException $exception, AuthenticatorInterface $authenticator, Request $request, ?Response $response, string $firewallName)
     {
         $this->exception = $exception;
         $this->authenticator = $authenticator;
         $this->request = $request;
         $this->response = $response;
-        $this->providerKey = $providerKey;
+        $this->firewallName = $firewallName;
     }
 
     public function getException(): AuthenticationException
@@ -43,9 +43,9 @@ public function getAuthenticator(): AuthenticatorInterface
         return $this->authenticator;
     }
 
-    public function getProviderKey(): string
+    public function getFirewallName(): string
     {
-        return $this->providerKey;
+        return $this->firewallName;
     }
 
     public function getRequest(): Request
diff --git a/Event/LoginSuccessEvent.php b/Event/LoginSuccessEvent.php
@@ -31,14 +31,14 @@ class LoginSuccessEvent extends Event
     private $response;
     private $providerKey;
 
-    public function __construct(AuthenticatorInterface $authenticator, PassportInterface $passport, TokenInterface $authenticatedToken, Request $request, ?Response $response, string $providerKey)
+    public function __construct(AuthenticatorInterface $authenticator, PassportInterface $passport, TokenInterface $authenticatedToken, Request $request, ?Response $response, string $firewallName)
     {
         $this->authenticator = $authenticator;
         $this->passport = $passport;
         $this->authenticatedToken = $authenticatedToken;
         $this->request = $request;
         $this->response = $response;
-        $this->providerKey = $providerKey;
+        $this->providerKey = $firewallName;
     }
 
     public function getAuthenticator(): AuthenticatorInterface
@@ -70,7 +70,7 @@ public function getRequest(): Request
         return $this->request;
     }
 
-    public function getProviderKey(): string
+    public function getFirewallName(): string
     {
         return $this->providerKey;
     }
diff --git a/Tests/Authentication/AuthenticatorManagerTest.php b/Tests/Authentication/AuthenticatorManagerTest.php

Original file line number	Diff line number	Diff line change
`@@ -32,12 +32,12 @@ abstract class AbstractAuthenticator implements AuthenticatorInterface`
`32`	`32`	`*`
`33`	`33`	`* @return PostAuthenticationToken`
`34`	`34`	`*/`
`35`		`- public function createAuthenticatedToken(PassportInterface $passport, string $providerKey): TokenInterface`
	`35`	`+ public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface`
`36`	`36`	`{`
`37`	`37`	`if (!$passport instanceof UserPassportInterface) {`
`38`	`38`	`throw new LogicException(sprintf('Passport does not contain a user, overwrite "createAuthenticatedToken()" in "%s" to create a custom authenticated token.', \get_class($this)));`
`39`	`39`	`}`
`40`	`40`
`41`		`- return new PostAuthenticationToken($passport->getUser(), $providerKey, $passport->getUser()->getRoles());`
	`41`	`+ return new PostAuthenticationToken($passport->getUser(), $firewallName, $passport->getUser()->getRoles());`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,12 +92,12 @@ public function authenticate(Request $request): PassportInterface`
`92`	`92`	`return new SelfValidatingPassport($user, [new PreAuthenticatedUserBadge()]);`
`93`	`93`	`}`
`94`	`94`
`95`		`- public function createAuthenticatedToken(PassportInterface $passport, string $providerKey): TokenInterface`
	`95`	`+ public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface`
`96`	`96`	`{`
`97`		`- return new PreAuthenticatedToken($passport->getUser(), null, $providerKey, $passport->getUser()->getRoles());`
	`97`	`+ return new PreAuthenticatedToken($passport->getUser(), null, $firewallName, $passport->getUser()->getRoles());`
`98`	`98`	`}`
`99`	`99`
`100`		`- public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $providerKey): ?Response`
	`100`	`+ public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response`
`101`	`101`	`{`
`102`	`102`	`return null; // let the original request continue`
`103`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,12 +50,12 @@ public function authenticate(Request $request): PassportInterface`
`50`	`50`	`return new AnonymousPassport();`
`51`	`51`	`}`
`52`	`52`
`53`		`- public function createAuthenticatedToken(PassportInterface $passport, string $providerKey): TokenInterface`
	`53`	`+ public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface`
`54`	`54`	`{`
`55`	`55`	`return new AnonymousToken($this->secret, 'anon.', []);`
`56`	`56`	`}`
`57`	`57`
`58`		`- public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $providerKey): ?Response`
	`58`	`+ public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response`
`59`	`59`	`{`
`60`	`60`	`return null; // let the original request continue`
`61`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,12 +100,12 @@ public function authenticate(Request $request): PassportInterface`
`100`	`100`	`/**`
`101`	`101`	`* @param Passport $passport`
`102`	`102`	`*/`
`103`		`- public function createAuthenticatedToken(PassportInterface $passport, $providerKey): TokenInterface`
	`103`	`+ public function createAuthenticatedToken(PassportInterface $passport, $firewallName): TokenInterface`
`104`	`104`	`{`
`105`		`- return new UsernamePasswordToken($passport->getUser(), null, $providerKey, $passport->getUser()->getRoles());`
	`105`	`+ return new UsernamePasswordToken($passport->getUser(), null, $firewallName, $passport->getUser()->getRoles());`
`106`	`106`	`}`
`107`	`107`
`108`		`- public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $providerKey): ?Response`
	`108`	`+ public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response`
`109`	`109`	`{`
`110`	`110`	`return $this->successHandler->onAuthenticationSuccess($request, $token);`
`111`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -82,12 +82,12 @@ public function authenticate(Request $request): PassportInterface`
`82`	`82`	`/**`
`83`	`83`	`* @param Passport $passport`
`84`	`84`	`*/`
`85`		`- public function createAuthenticatedToken(PassportInterface $passport, $providerKey): TokenInterface`
	`85`	`+ public function createAuthenticatedToken(PassportInterface $passport, $firewallName): TokenInterface`
`86`	`86`	`{`
`87`		`- return new UsernamePasswordToken($passport->getUser(), null, $providerKey, $passport->getUser()->getRoles());`
	`87`	`+ return new UsernamePasswordToken($passport->getUser(), null, $firewallName, $passport->getUser()->getRoles());`
`88`	`88`	`}`
`89`	`89`
`90`		`- public function onAuthenticationSuccess(Request $request, TokenInterface $token, $providerKey): ?Response`
	`90`	`+ public function onAuthenticationSuccess(Request $request, TokenInterface $token, $firewallName): ?Response`
`91`	`91`	`{`
`92`	`92`	`return null;`
`93`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,12 +93,12 @@ public function authenticate(Request $request): PassportInterface`
`93`	`93`	`return $passport;`
`94`	`94`	`}`
`95`	`95`
`96`		`- public function createAuthenticatedToken(PassportInterface $passport, string $providerKey): TokenInterface`
	`96`	`+ public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface`
`97`	`97`	`{`
`98`		`- return new UsernamePasswordToken($passport->getUser(), null, $providerKey, $passport->getUser()->getRoles());`
	`98`	`+ return new UsernamePasswordToken($passport->getUser(), null, $firewallName, $passport->getUser()->getRoles());`
`99`	`99`	`}`
`100`	`100`
`101`		`- public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $providerKey): ?Response`
	`101`	`+ public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response`
`102`	`102`	`{`
`103`	`103`	`if (null === $this->successHandler) {`
`104`	`104`	`return null; // let the original request continue`
Original file line number	Diff line number	Diff line change
`@@ -76,12 +76,12 @@ public function authenticate(Request $request): PassportInterface`
`76`	`76`	`return new SelfValidatingPassport($token->getUser());`
`77`	`77`	`}`
`78`	`78`
`79`		`- public function createAuthenticatedToken(PassportInterface $passport, string $providerKey): TokenInterface`
	`79`	`+ public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface`
`80`	`80`	`{`
`81`		`- return new RememberMeToken($passport->getUser(), $providerKey, $this->secret);`
	`81`	`+ return new RememberMeToken($passport->getUser(), $firewallName, $this->secret);`
`82`	`82`	`}`
`83`	`83`
`84`		`- public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $providerKey): ?Response`
	`84`	`+ public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response`
`85`	`85`	`{`
`86`	`86`	`return null; // let the original request continue`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,24 +7,23 @@`
`7`	`7`
`8`	`8`	`class PostAuthenticationToken extends AbstractToken`
`9`	`9`	`{`
`10`		`- private $providerKey;`
	`10`	`+ private $firewallName;`
`11`	`11`
`12`	`12`	`/**`
`13`		`- * @param string $providerKey The provider (firewall) key`
`14`		`- * @param string[] $roles An array of roles`
	`13`	`+ * @param string[] $roles An array of roles`
`15`	`14`	`*`
`16`	`15`	`* @throws \InvalidArgumentException`
`17`	`16`	`*/`
`18`		`- public function __construct(UserInterface $user, string $providerKey, array $roles)`
	`17`	`+ public function __construct(UserInterface $user, string $firewallName, array $roles)`
`19`	`18`	`{`
`20`	`19`	`parent::__construct($roles);`
`21`	`20`
`22`		`- if (empty($providerKey)) {`
`23`		`- throw new \InvalidArgumentException('$providerKey (i.e. firewall key) must not be empty.');`
	`21`	`+ if (empty($firewallName)) {`
	`22`	`+ throw new \InvalidArgumentException('$firewallName must not be empty.');`
`24`	`23`	`}`
`25`	`24`
`26`	`25`	`$this->setUser($user);`
`27`		`- $this->providerKey = $providerKey;`
	`26`	`+ $this->firewallName = $firewallName;`
`28`	`27`
`29`	`28`	`// this token is meant to be used after authentication success, so it is always authenticated`
`30`	`29`	`// you could set it as non authenticated later if you need to`
`@@ -42,30 +41,25 @@ public function getCredentials()`
`42`	`41`	`return [];`
`43`	`42`	`}`
`44`	`43`
`45`		`- /**`
`46`		`- * Returns the provider (firewall) key.`
`47`		`- *`
`48`		`- * @return string`
`49`		`- */`
`50`		`- public function getProviderKey()`
	`44`	`+ public function getFirewallName(): string`
`51`	`45`	`{`
`52`		`- return $this->providerKey;`
	`46`	`+ return $this->firewallName;`
`53`	`47`	`}`
`54`	`48`
`55`	`49`	`/**`
`56`	`50`	`* {@inheritdoc}`
`57`	`51`	`*/`
`58`	`52`	`public function __serialize(): array`
`59`	`53`	`{`
`60`		`- return [$this->providerKey, parent::__serialize()];`
	`54`	`+ return [$this->firewallName, parent::__serialize()];`
`61`	`55`	`}`
`62`	`56`
`63`	`57`	`/**`
`64`	`58`	`* {@inheritdoc}`
`65`	`59`	`*/`
`66`	`60`	`public function __unserialize(array $data): void`
`67`	`61`	`{`
`68`		`- [$this->providerKey, $parentData] = $data;`
	`62`	`+ [$this->firewallName, $parentData] = $data;`
`69`	`63`	`parent::__unserialize($parentData);`
`70`	`64`	`}`
`71`	`65`	`}`