JwPersistentUser\Listener\WriteTokenToCookie

Complexity

Total Complexity

23

Size/Duplication

Total Lines	185
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	7

Test Coverage

Coverage

63.49%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__invoke()	0	19	1
A	authenticate()	0	12	2
A	logout()	0	15	3
A	isValidRequestAndResponse()	0	5	2
A	detachShared()	0	8	3
A	getRememberMeService()	0	7	2
A	setRememberMeService()	0	5	1
A	getResponse()	0	8	2
A	setResponse()	0	5	1
A	getRequest()	0	8	2
A	setRequest()	0	5	1
A	getCookieService()	0	7	2
A	setCookieService()	0	5	1

<?php

namespace JwPersistentUser\Listener;

use Interop\Container\ContainerInterface;
use Interop\Container\Exception\ContainerException;
use JwPersistentUser\Service\CookieService;
use JwPersistentUser\Service\RememberMeService;

use Zend\EventManager\Event;
use Zend\Http\Request;
use Zend\Http\Response;
use Zend\ServiceManager\Exception\ServiceNotCreatedException;
use Zend\ServiceManager\Exception\ServiceNotFoundException;
use Zend\ServiceManager\Factory\DelegatorFactoryInterface;
use Zend\ServiceManager\ServiceLocatorInterface;
use Zend\Stdlib\RequestInterface;
use Zend\Stdlib\ResponseInterface;
use Zend\EventManager\SharedEventManagerInterface;

use ZfcUser\Authentication\Adapter\AdapterChain;
use ZfcUser\Authentication\Adapter\AdapterChainEvent;

class WriteTokenToCookie implements DelegatorFactoryInterface
{
    /**
     * @var []
     */
    protected $sharedListeners = [];

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

    /**
     * @var RequestInterface
     */
    protected $request;

    /**
     * @var ResponseInterface
     */
    protected $response;

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

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

    public function __invoke(ContainerInterface $container, $name, callable $callback, array $options = null)
    {
        $this->serviceLocator = $container;

        /** @var AdapterChain $original */
        $original = call_user_func($callback);

        $original->getEventManager()->attach(
            'authenticate.success',
            [$this, 'authenticate']
        );

        $original->getEventManager()->attach(
            'logout',
            [$this, 'logout']
        );

        return $original;
    }

    public function authenticate(Event $e)
    {
        $e = $e->getTarget();

        if (!$this->isValidRequestAndResponse()) {
            return;
        }

        $serieToken = $this->getRememberMeService()->createNew($e->getIdentity());

        $this->getCookieService()->writeSerie($this->getResponse(), $serieToken);

$this->getResponse() of type object<Zend\Stdlib\ResponseInterface> is not a sub-type of object<Zend\Http\Response>. It seems like you assume a concrete implementation of the interface Zend\Stdlib\ResponseInterface to be always present.

    }

    public function logout(Event $e)
    {
        $e = $e->getTarget();

$e is not used, you could remove the assignment.

        if (!$this->isValidRequestAndResponse()) {
            return;
        }

        $serieToken = $this->getCookieService()->read($this->getRequest(), $this->getResponse());

$this->getRequest() of type object<Zend\Stdlib\RequestInterface> is not a sub-type of object<Zend\Http\Request>. It seems like you assume a concrete implementation of the interface Zend\Stdlib\RequestInterface to be always present.

$this->getResponse() is of type object<Zend\Stdlib\ResponseInterface>, but the function expects a null|object<Zend\Http\Response>.

        if ($serieToken) {
            $this->getRememberMeService()->removeSerie($serieToken->getUserId(), $serieToken->getSerie());
        }

        $this->getCookieService()->writeNull($this->getResponse());

$this->getResponse() of type object<Zend\Stdlib\ResponseInterface> is not a sub-type of object<Zend\Http\Response>. It seems like you assume a concrete implementation of the interface Zend\Stdlib\ResponseInterface to be always present.

    }

    /**
     * @return bool
     */
    protected function isValidRequestAndResponse()
    {
        return $this->getRequest() instanceof Request
            && $this->getResponse() instanceof Response;
    }

    public function detachShared(SharedEventManagerInterface $events)
    {
        foreach ($this->sharedListeners as $index => $listener) {
            if ($events->detach($this->eventIdentifier, $listener)) {

The property eventIdentifier does not exist. Did you maybe forget to declare it?

                unset($this->sharedListeners[$index]);
            }
        }
    }

    /**
     * @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 ResponseInterface
     */
    public function getResponse()
    {
        if (!$this->response) {
            $this->response = $this->serviceLocator->get('Response');
        }

        return $this->response;
    }

    /**
     * @param ResponseInterface $response
     * @return $this
     */
    public function setResponse($response)
    {
        $this->response = $response;
        return $this;
    }

    /**
     * @return RequestInterface
     */
    public function getRequest()
    {
        if (!$this->request) {
            $this->request = $this->serviceLocator->get('Request');
        }

        return $this->request;
    }

    /**
     * @param RequestInterface $request
     * @return $this
     */
    public function setRequest($request)
    {
        $this->request = $request;
        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;
    }
}