JwPersistentUser\Service\CookieAuthenticationService

Complexity

Total Complexity

21

Size/Duplication

Total Lines	175
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

73.21%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	loginFrom()	0	38	7
A	invalidAttempt()	0	6	1
A	getAuthService()	0	8	2
A	setAuthService()	0	5	1
A	getRememberMeService()	0	8	2
A	setRememberMeService()	0	5	1
A	getCookieService()	0	7	2
A	setCookieService()	0	5	1
A	getUserMapper()	0	8	2
A	setUserMapper()	0	4	1

<?php

namespace JwPersistentUser\Service;

use JwPersistentUser\Authentication\Adapter\ForceLogin;

use Zend\Http\Request;
use Zend\Http\Response;
use Zend\ServiceManager\ServiceLocatorInterface;
use Zend\Stdlib\RequestInterface;
use Zend\Stdlib\ResponseInterface;
use Zend\EventManager\EventManagerAwareTrait;
use Zend\Authentication\AuthenticationService;

use ZfcUser\Mapper\User as ZfcUserMapper;

/**
 * Note that dependencies in this service are pulled directory out of the service locator for
 * a reason: performance. Would we NOT do this than we would instantiate those resources on
 * every request.
 */
class CookieAuthenticationService
{
    use EventManagerAwareTrait;

    /**
     * @var ServiceLocatorInterface
     */
    protected $serviceLocator;

    /**
     * @var AuthenticationService
     */
    protected $authService;

    /**
     * @var RememberMeService
     */
    protected $rememberMeService;

    /**
     * @var CookieService
     */
    protected $cookieService;

    /**
     * @var ZfcUserMapper
     */
    protected $userMapper;

    /**
     * @param ServiceLocatorInterface $serviceLocator
     */
    public function __construct(ServiceLocatorInterface $serviceLocator)
    {
        $this->serviceLocator = $serviceLocator;
    }

    /**
     * @param RequestInterface $request
     * @param ResponseInterface $response
     */
    public function loginFrom(RequestInterface $request, ResponseInterface $response)
    {
        if (!($request instanceof Request) || !($response instanceof Response)) {
            return;
        }

        $serieToken = $this->getCookieService()->read($request, $response);
        if (!$serieToken) {
            return;
        }

        // TODO use a session once we validated using Cookie. So we do not need to instantiate
        //      the AuthService on every following request.

        if ($this->getAuthService()->hasIdentity()) {
            return;
        }

        $user = $this->getUserMapper()->findById($serieToken->getUserId());
        if (!$user) {
            $this->invalidAttempt($response);
            return;
        }

        $nextSerieToken = $this->getRememberMeService()->getNextInSerie($serieToken);
        if (!$nextSerieToken) {
            $this->invalidAttempt($response);
            return;
        }

        $this->getCookieService()->writeSerie($response, $nextSerieToken);

        $this->getAuthService()->authenticate(new ForceLogin($nextSerieToken->getUserId()));

        $this->getEventManager()->trigger('login', $this, [
            'token' => $nextSerieToken,
        ]);
    }

    /**
     * @param Response $response
     */
    protected function invalidAttempt(Response $response)
    {
        $this->getAuthService()->clearIdentity();

        $this->getCookieService()->writeNull($response);
    }

    /**
     * @return AuthenticationService
     */
    public function getAuthService()
    {
        if ($this->authService === null) {
            $this->authService = $this->serviceLocator->get('zfcuser_auth_service');
        }

        return $this->authService;
    }

    /**
     * @param AuthenticationService $authService
     * @return $this
     */
    public function setAuthService($authService)
    {
        $this->authService = $authService;
        return $this;
    }

    /**
     * @return RememberMeService
     */
    public function getRememberMeService()
    {
        if ($this->rememberMeService === null) {
            $this->rememberMeService = $this->serviceLocator->get('JwPersistentUser\Service\RememberMe');
        }

        return $this->rememberMeService;
    }

    /**
     * @param RememberMeService $rememberMeService
     * @return $this
     */
    public function setRememberMeService($rememberMeService)
    {
        $this->rememberMeService = $rememberMeService;
        return $this;
    }

    /**
     * @return CookieService
     */
    public function getCookieService()
    {
        if ($this->cookieService === null) {
            $this->cookieService = $this->serviceLocator->get('JwPersistentUser\Service\Cookie');
        }
        return $this->cookieService;
    }

    /**
     * @param CookieService $cookieService
     * @return $this
     */
    public function setCookieService($cookieService)
    {
        $this->cookieService = $cookieService;
        return $this;
    }

    /**
     * @return ZfcUserMapper
     */
    public function getUserMapper()
    {
        if ($this->userMapper === null) {
            $this->userMapper = $this->serviceLocator->get('zfcuser_user_mapper');
        }

        return $this->userMapper;
    }

    /**
     * @param ZfcUserMapper $mapper
     */
    public function setUserMapper(ZfcUserMapper $mapper)
    {
        $this->userMapper = $mapper;
    }
}