Symfony Profiler

<?php
/**
* Created by PhpStorm.
* User: matti
* Date: 26/08/2019
* Time: 09:19
*/
namespace App\Security\Authenticator;
use App\Security\Provider\OAuth2Provider;
use App\Service\OAuth2AuthenticatorService;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Routing\Router;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Core\Exception\CustomUserMessageAccountStatusException;
use Symfony\Component\Security\Core\Security;
use Symfony\Component\Security\Core\User\ChainUserProvider;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\User\UserProviderInterface;
use Symfony\Component\Security\Guard\AbstractGuardAuthenticator;
class OAuth2Authenticator extends AbstractGuardAuthenticator
{
/**
* @var EntityManagerInterface
*/
private $em;
/**
* @var RouterInterface
*/
private $router;
/**
* @var OAuth2AuthenticatorService
*/
private $oAuth2AuthenticatorService;
/** @var EventDispatcherInterface */
private $dispatcher;
/**
* @param EntityManagerInterface $entityManagerInterface
* @param Router $router
* @param OAuth2AuthenticatorService $oAuth2AuthenticatorService
*/
public function __construct(
EntityManagerInterface $entityManagerInterface,
RouterInterface $router,
OAuth2AuthenticatorService $oAuth2AuthenticatorService,
EventDispatcherInterface $eventDispatcherInterface
)
{
$this->em = $entityManagerInterface;
$this->router = $router;
$this->oAuth2AuthenticatorService = $oAuth2AuthenticatorService;
$this->dispatcher = $eventDispatcherInterface;
}
/**
* @param Request $request
* @return bool
*/
public function supports(Request $request)
{
$support = $request->query->get('code') !== null ? true : false;
if($support){
$request->query->set('_remember_me', true);
}
$session = $request->getSession();
if ($session->has('company_access_office_id')) {
return false;
}
return $support && $this->oAuth2AuthenticatorService->getRedirectUrl() === $request->attributes->get('_route');
}
/**
* Returns a response that directs the user to authenticate.
*
* This is called when an anonymous request accesses a resource that
* requires authentication. The job of this method is to return some
* response that "helps" the user start into the authentication process.
*
* Examples:
* A) For a form login, you might redirect to the login page
* return new RedirectResponse('/login');
* B) For an API token authentication system, you return a 401 response
* return new Response('Auth header required', 401);
*
* @param Request $request The request that resulted in an AuthenticationException
* @param AuthenticationException $authException The exception that started the authentication process
*
* @return Response
*/
public function start(Request $request, AuthenticationException $authException = null)
{
// TODO: Implement start() method.
return new RedirectResponse('login');
}
/**
* Get the authentication credentials from the request and return them
* as any type (e.g. an associate array).
*
* Whatever value you return here will be passed to getUser() and checkCredentials()
*
* For example, for a form login, you might:
*
* return array(
* 'username' => $request->request->get('_username'),
* 'password' => $request->request->get('_password'),
* );
*
* Or for an API token that's on a header, you might use:
*
* return array('api_key' => $request->headers->get('X-API-TOKEN'));
*
* @param Request $request
*
* @return mixed Any non-null value
*
* @throws \UnexpectedValueException If null is returned
*/
public function getCredentials(Request $request)
{
return [
'code' => $request->query->get('code')
];
}
/**
* Return a UserInterface object based on the credentials.
*
* The *credentials* are the return value from getCredentials()
*
* You may throw an AuthenticationException if you wish. If you return
* null, then a UsernameNotFoundException is thrown for you.
*
* @param mixed $credentials
* @param UserProviderInterface $userProvider
*
* @throws AuthenticationException
*
* @return UserInterface|null
*/
public function getUser($credentials, UserProviderInterface $userProvider)
{
try {
$code = $credentials['code'];
$officeUser = $this->oAuth2AuthenticatorService->getUser($code);
//$tennantId = $officeUser->tennant_id;
//$objectId = $officeUser->oid;
$uniqueName = $officeUser->username;
$user = null;
if ($userProvider instanceof OAuth2Provider) {
$user = $userProvider->loadUserByUsername($uniqueName);
} else {
$user = $userProvider->loadUserByIdentifier($uniqueName);
}
if (!$user) {
throw new AuthenticationException("User not found. Check that your credentials and the authentication method used are correct.");
}
if (!$user->getAbilitato()) {
throw new CustomUserMessageAccountStatusException("Utente non abilitato al login");
}
}
catch (\Exception $e) {
throw $e;
}
return $user;
}
/**
* Returns true if the credentials are valid.
*
* If any value other than true is returned, authentication will
* fail. You may also throw an AuthenticationException if you wish
* to cause authentication to fail.
*
* The *credentials* are the return value from getCredentials()
*
* @param mixed $credentials
* @param UserInterface $user
*
* @return bool
*
* @throws AuthenticationException
*/
public function checkCredentials($credentials, UserInterface $user)
{
// TODO: Implement checkCredentials() method.
return true;
}
/**
* Called when authentication executed, but failed (e.g. wrong username password).
*
* This should return the Response sent back to the user, like a
* RedirectResponse to the login page or a 403 response.
*
* If you return null, the request will continue, but the user will
* not be authenticated. This is probably not what you want to do.
*
* @param Request $request
* @param AuthenticationException $exception
*
* @return Response|null
*/
public function onAuthenticationFailure(Request $request, AuthenticationException $exception)
{
if ($request->getSession() instanceof SessionInterface) {
$request->getSession()->set(Security::AUTHENTICATION_ERROR, $exception);
}
$route = $this->router->generate('login');
return new RedirectResponse($route);
}
/**
* Called when authentication executed and was successful!
*
* This should return the Response sent back to the user, like a
* RedirectResponse to the last page they visited.
*
* If you return null, the current request will continue, and the user
* will be authenticated. This makes sense, for example, with an API.
*
* @param Request $request
* @param TokenInterface $token
* @param string $providerKey The provider (i.e. firewall) key
*
* @return Response|null
*/
public function onAuthenticationSuccess(Request $request, TokenInterface $token, $providerKey)
{
$route = $this->router->generate('homepage');
return new RedirectResponse($route);
}
/**
* Does this method support remember me cookies?
*
* Remember me cookie will be set if *all* of the following are met:
* A) This method returns true
* B) The remember_me key under your firewall is configured
* C) The "remember me" functionality is activated. This is usually
* done by having a _remember_me checkbox in your form, but
* can be configured by the "always_remember_me" and "remember_me_parameter"
* parameters under the "remember_me" firewall key
* D) The onAuthenticationSuccess method returns a Response object
*
* @return bool
*/
public function supportsRememberMe()
{
return false;
}
}

src/Security/Authenticator/OAuth2Authenticator.php line 81