Skaut\Skautis\User

Complexity

Total Complexity

32

Size/Duplication

Total Lines	226
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

87.01%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	3
A	getLoginId()	0	4	1
A	getRoleId()	0	4	1
A	getUnitId()	0	4	1
A	getLogoutDate()	0	4	1
A	setLoginData()	0	10	1
A	updateLoginData()	0	26	5
A	resetLoginData()	0	7	1
A	isLoggedIn()	0	16	6
A	isAuthConfirmed()	0	4	1
A	setAuthConfirmed()	0	5	1
A	confirmAuth()	0	13	3
A	updateLogoutTime()	0	17	2
A	saveToSession()	0	6	2
A	parseDate()	0	17	3

<?php
declare(strict_types = 1);

namespace Skaut\Skautis;

use DateTimeImmutable;
use DateTimeInterface;
use DateTimeZone;
use Skaut\Skautis\SessionAdapter\AdapterInterface;
use Skaut\Skautis\Wsdl\WebServiceName;
use Skaut\Skautis\Wsdl\WsdlManager;

/**
 * @author Petr Morávek <petr@pada.cz>
 */
class User
{

    public const ID_LOGIN = 'ID_Login';
    public const ID_ROLE = 'ID_Role';
    public const ID_UNIT = 'ID_Unit';
    public const LOGOUT_DATE = 'LOGOUT_Date';
    private const AUTH_CONFIRMED = 'AUTH_Confirmed';
    private const SESSION_ID = 'skautis_user_data';

    /**
     * @var WsdlManager
     */
    private $wsdlManager;

    /**
     * @var AdapterInterface|null
     */
    private $session;

    /**
     * Informace o přihlášení uživatele
     *
     * @var array<string, mixed>
     */
    protected $loginData = [];

    /**
     * @param WsdlManager $wsdlManager
     * @param AdapterInterface|null $session
     */
    public function __construct(WsdlManager $wsdlManager, AdapterInterface $session = null)
    {
        $this->wsdlManager = $wsdlManager;
        $this->session = $session;

        if ($session !== null && $session->has(self::SESSION_ID)) {
            $this->loginData = (array)$session->get(self::SESSION_ID);
        }
    }

    public function getLoginId(): ?string
    {
        return $this->loginData[self::ID_LOGIN] ?? null;
    }

    public function getRoleId(): ?int
    {
        return $this->loginData[self::ID_ROLE] ?? null;
    }

    public function getUnitId(): ?int
    {
        return $this->loginData[self::ID_UNIT] ?? null;
    }

    /**
     * Vrací datum a čas automatického odhlášení ze skautISu
     */
    public function getLogoutDate(): ?DateTimeInterface
    {
        return $this->loginData[self::LOGOUT_DATE] ?? null;
    }

    /**+
     * Hromadné nastavení po přihlášení
     */
    public function setLoginData(
      string $loginId,
      ?int $roleId = null,
      ?int $unitId = null,
      ?DateTimeInterface $logoutDate = null
    ): self {
        $this->loginData = [];

        return $this->updateLoginData($loginId, $roleId, $unitId, $logoutDate);
    }

    /**
     * Hromadná změna údajů, bez vymazání stávajících
     */
    public function updateLoginData(
      ?string $loginId = null,
      ?int $roleId = null,
      ?int $unitId = null,
      ?DateTimeInterface $logoutDate = null
    ): self {
        if ($loginId !== null) {
            $this->loginData[self::ID_LOGIN] = $loginId;
        }

        if ($roleId !== null) {
            $this->loginData[self::ID_ROLE] = $roleId;
        }

        if ($unitId !== null) {
            $this->loginData[self::ID_UNIT] = $unitId;
        }

        if ($logoutDate !== null) {
            $this->loginData[self::LOGOUT_DATE] = $logoutDate;
        }

        $this->saveToSession();

        return $this;
    }

    /**
     * Hromadný reset dat po odhlášení
     */
    public function resetLoginData(): self
    {
        $this->loginData = [];
        $this->saveToSession();

        return $this;
    }

    /**
     * Kontoluje, jestli je přihlášení platné.
     * Pro správné fungování je nezbytně nutné, aby byl na serveru nastaven správný čas.
     *
     * @param bool $hardCheck vynutí kontrolu přihlášení na serveru
     */
    public function isLoggedIn(bool $hardCheck = false): bool
    {
        if (empty($this->loginData[self::ID_LOGIN])) {
            return false;
        }

        if ($hardCheck || !$this->isAuthConfirmed()) {
            $this->confirmAuth();
        }

        if ($this->getLogoutDate() === null) {
          return false;
        }

        return $this->isAuthConfirmed() && $this->getLogoutDate()->getTimestamp() > time();
    }

    /**
     * Bylo potvrzeno přihlášení dotazem na skautIS?
     */
    protected function isAuthConfirmed(): bool
    {
        return !empty($this->loginData[self::AUTH_CONFIRMED]);
    }

    protected function setAuthConfirmed(bool $isConfirmed): void
    {
        $this->loginData[self::AUTH_CONFIRMED] = $isConfirmed;
        $this->saveToSession();
    }

  /**
   * Potvrdí (a prodlouží) přihlášení dotazem na skautIS.
   *
   * @throws \Exception Pokud se authentikace nepovede
   */
    protected function confirmAuth(): void
    {
        try {
          $logoutTimeUpdated = $this->updateLogoutTime();
          if(!$logoutTimeUpdated) {
              throw new \RuntimeException('Updating logout time failed');
            }
            $this->setAuthConfirmed(true);
        } catch (\Exception $e) {
            $this->setAuthConfirmed(false);
            throw $e;
        }
    }

    /**
     * Prodloužení přihlášení o 30 min
     *
     * @throws UnexpectedValueException pokud se nepodaří naparsovat datum
     */
    public function updateLogoutTime(): bool
    {
        $loginId = $this->getLoginId();
        if ($loginId === null) {
            // Nemáme token, uživatel není přihlášen a není, co prodlužovat
            return false;
        }

        $result = $this->wsdlManager->getWebService(WebServiceName::USER_MANAGEMENT, $loginId)->LoginUpdateRefresh(['ID' => $loginId]);

        $logoutDate = $this->parseDate($result->DateLogout);
        $this->loginData[self::LOGOUT_DATE] = $logoutDate;

        $this->saveToSession();

        return true;
    }

    /**
     * Uloží nastavení do session
     */
    protected function saveToSession(): void
    {
        if ($this->session !== null) {
            $this->session->set(self::SESSION_ID, $this->loginData);
        }
    }

    private function parseDate(string $dateText): DateTimeInterface {
      //skautIS vrací sekundy včetně desetinné části
      $dateTextWithoutDecimals = preg_replace('/\.(\d*)$/', '', $dateText);

      if (!is_string($dateTextWithoutDecimals)) {
        throw new UnexpectedValueException("Could not parse date '$dateText'.");
      }

      $tz = new DateTimeZone('Europe/Prague');
      $dateTime =  DateTimeImmutable::createFromFormat('Y-m-d\TH:i:s', $dateTextWithoutDecimals, $tz);

      if ($dateTime === false) {
        throw new UnexpectedValueException("Could not parse date '$dateText'.");
      }

      return $dateTime;
    }
}