kalanis\kw_auth\Methods\Sessions

Complexity

Total Complexity

22

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	fillSession()	0	4	1
A	tryLogged()	0	8	5
C	process()	0	24	11
A	nameFromSess()	0	3	1
A	clearSession()	0	4	1
A	remove()	0	4	2
A	__construct()	0	6	1

<?php

namespace kalanis\kw_auth\Methods;


use ArrayAccess;
use kalanis\kw_accounts\Interfaces\IAuth;
use SessionHandlerInterface;


/**
 * Class Sessions
 * @package kalanis\kw_auth\AuthMethods
 * Authenticate via Session
 * @codeCoverageIgnore external resource, Cannot start session when headers already sent
 */
class Sessions extends AMethods
{
    protected const SESSION_IP = 'acc_ip';
    protected const SESSION_NAME = 'acc_name';
    protected const SERVER_REMOTE = 'REMOTE_ADDR';
    protected const INPUT_NAME = 'name';
    protected const INPUT_NAME2 = 'user';
    protected const INPUT_PASS = 'pass';
    protected const INPUT_PASS2 = 'password';

    /** @var ArrayAccess<string, string|int> */
    protected ArrayAccess $session;
    /** @var ArrayAccess<string, string|int> */
    protected ArrayAccess $server;
    protected ?SessionHandlerInterface $externalHandler = null;

    /**
     * @param IAuth|null $authenticator
     * @param AMethods|null $nextOne
     * @param ArrayAccess<string, string|int> $session
     * @param ArrayAccess<string, string|int> $server
     * @param SessionHandlerInterface|null $externalHandler
     */
    public function __construct(?IAuth $authenticator, ?AMethods $nextOne, ArrayAccess $session, ArrayAccess $server, ?SessionHandlerInterface $externalHandler = null)
    {
        parent::__construct($authenticator, $nextOne);
        $this->session = $session;
        $this->server = $server;
        $this->externalHandler = $externalHandler;
    }

    public function process(ArrayAccess $credentials): void
    {
        if (PHP_SESSION_NONE == session_status()) {
            if ($this->externalHandler) {
                session_set_save_handler($this->externalHandler, true);
            }
            session_start();
        }
        if ($this->tryLogged()) {
            /** @scrutinizer ignore-call */
            $this->loggedUser = $this->authenticator->getDataOnly($this->nameFromSess());
        } else {
            $name = $credentials->offsetExists(static::INPUT_NAME) ? strval($credentials->offsetGet(static::INPUT_NAME)) : '' ;
            $name = $credentials->offsetExists(static::INPUT_NAME2) ? strval($credentials->offsetGet(static::INPUT_NAME2)) : $name ;
            $pass = $credentials->offsetExists(static::INPUT_PASS) ? strval($credentials->offsetGet(static::INPUT_PASS)) : '' ;
            $pass = $credentials->offsetExists(static::INPUT_PASS2) ? strval($credentials->offsetGet(static::INPUT_PASS2)) : $pass ;
            if (!empty($name) && !empty($pass)) {
                /** @scrutinizer ignore-call */
                $this->loggedUser = $this->authenticator->authenticate($name, ['password' => $pass]);
            }
        }
        $this->clearSession();
        if ($this->loggedUser) {
            $this->fillSession($this->loggedUser->getAuthName());
        }
    }

    public function remove(): void
    {
        if (PHP_SESSION_ACTIVE == session_status()) {
            session_destroy();
        }
    }

    protected function tryLogged(): bool
    {
        return (
            $this->session->offsetExists(static::SESSION_NAME)
            && !empty($this->session->offsetGet(static::SESSION_NAME)) // user has name already set
            && $this->session->offsetExists(static::SESSION_IP)
            && !empty($this->session->offsetGet(static::SESSION_IP)) // user has already set known ip
            && ($this->server->offsetGet(static::SERVER_REMOTE) == $this->session->offsetGet(static::SESSION_IP)) // against proxy attack - changed ip through work
        );
    }

    protected function nameFromSess(): string
    {
        return strval($this->session->offsetGet(static::SESSION_NAME));
    }

    protected function fillSession(string $name): void
    {
        $this->session->offsetSet(static::SESSION_NAME, $name);
        $this->session->offsetSet(static::SESSION_IP, strval($this->server->offsetGet(static::SERVER_REMOTE)));
    }

    protected function clearSession(): void
    {
        $this->session->offsetSet(static::SESSION_NAME, '');
        $this->session->offsetSet(static::SESSION_IP, '');
    }
}