kalanis\kw_auth_groups\Access\CompositeSources

Complexity

Total Complexity

74

Size/Duplication

Total Lines	418
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

31 Methods

Rating	Name	Duplication	Size	Complexity
A	updateGroup()	0	5	3
A	canProcess()	0	10	4
A	setCurrentUser()	0	4	1
A	getGroupDataOnly()	0	17	5
A	updatePassword()	0	6	3
A	getGroups()	0	3	1
A	canAccessUserByClassId()	0	3	1
A	isMaintainer()	0	3	1
A	currentUserRepresents()	0	4	1
A	deleteGroup()	0	6	3
A	canAccessUser()	0	3	3
A	getCurrentUser()	0	6	2
A	canAccessGroup()	0	3	2
A	updateCertData()	0	6	3
A	getClasses()	0	3	1
A	isAlreadyInParents()	0	8	3
A	readGroup()	0	10	3
A	readAccounts()	0	11	4
A	__construct()	0	4	2
A	createAccount()	0	5	3
A	getDataOnly()	0	6	3
A	isMe()	0	3	1
A	updateAccount()	0	5	2
A	getAccounts()	0	3	1
A	getCertData()	0	6	3
A	createGroup()	0	16	3
A	getAuth()	0	3	1
A	readClasses()	0	9	3
A	hasChildren()	0	9	3
A	isCurrentUserRepresented()	0	4	1
A	deleteAccount()	0	6	4

<?php

namespace kalanis\kw_auth_groups\Access;


use kalanis\kw_accounts\AccountsException;
use kalanis\kw_accounts\Interfaces;
use kalanis\kw_auth_sources\Access as source_access;
use kalanis\kw_auth_groups\Sources\KwAuth;
use kalanis\kw_auth_sources\AuthSourcesException;
use kalanis\kw_groups\GroupsException;
use kalanis\kw_groups\Interfaces\IProcessor;
use kalanis\kw_groups\Processor\Basic;


/**
 * Class CompositeSources
 * @package kalanis\kw_auth_groups\Access
 *
 * todo: next step: separate user rights themselves and system consistency checks
 */
class CompositeSources extends source_access\CompositeSources
{
    protected IProcessor $libGroup;
    protected ?Interfaces\IUser $currentUser = null;

    /**
     * @param source_access\SourcesAdapters\AAdapter $adapter
     * @param IProcessor|null $libGroup
     * @throws AuthSourcesException
     */
    public function __construct(source_access\SourcesAdapters\AAdapter $adapter, ?IProcessor $libGroup = null)
    {
        parent::__construct($adapter);
        $this->libGroup = $libGroup ?: new Basic(new KwAuth($adapter->getGroups()));
    }

    /**
     * @param string $userName
     * @throws AccountsException
     * @throws GroupsException
     * @return Interfaces\IUser|null
     */
    public function getDataOnly(string $userName): ?Interfaces\IUser
    {
        $data = parent::getDataOnly($userName);
        return $data && $this->canAccessUser($data)
            ? $data
            : null
        ;
    }

    /**
     * @param string $userName
     * @throws AccountsException
     * @throws GroupsException
     * @return Interfaces\ICert|null
     */
    public function getCertData(string $userName): ?Interfaces\ICert
    {
        $data = parent::getDataOnly($userName);
        return $data && $this->canAccessUser($data)
            ? parent::getCertData($userName)
            : null
        ;
    }

    /**
     * @param Interfaces\IUser $user
     * @param string $password
     * @throws AccountsException
     * @throws GroupsException
     * @return bool
     */
    public function createAccount(Interfaces\IUser $user, string $password): bool
    {
        return $this->canAccessUserByClassId($user->getClass()) && !$this->currentUserRepresents($user)
            ? parent::createAccount($user, $password)
            : false
        ;
    }

    /**
     * @throws AccountsException
     * @throws GroupsException
     * @return Interfaces\IUser[]
     */
    public function readAccounts(): array
    {
        $availableAccounts = [];
        /** @var Interfaces\IUser[] $allAccounts */
        $allAccounts = parent::readAccounts();
        foreach ($allAccounts as $account) {
            if ($this->canAccessUserByClassId($account->getClass()) && $this->isCurrentUserRepresented($account)) {
                $availableAccounts[] = $account;
            }
        }
        return $availableAccounts;
    }

    /**
     * @param Interfaces\IUser $user
     * @throws AccountsException
     * @throws GroupsException
     * @return bool
     */
    public function updateAccount(Interfaces\IUser $user): bool
    {
        return $this->canAccessUser($user)
            ? parent::updateAccount($user)
            : false
        ;
    }

    /**
     * @param string $userName
     * @param string $passWord
     * @throws AccountsException
     * @throws GroupsException
     * @return bool
     */
    public function updatePassword(string $userName, string $passWord): bool
    {
        $user = parent::getDataOnly($userName);
        return $user && $this->canAccessUser($user)
            ? parent::updatePassword($userName, $passWord)
            : false
        ;
    }

    /**
     * @param string $userName
     * @param string|null $certKey
     * @param string|null $certSalt
     * @throws AccountsException
     * @throws GroupsException
     * @return bool
     */
    public function updateCertData(string $userName, ?string $certKey, ?string $certSalt): bool
    {
        $user = $this->getDataOnly($userName);
        return $user && $this->canAccessUser($user)
            ? parent::updateCertData($userName, $certKey, $certSalt)
            : false
        ;
    }

    /**
     * @param string $userName
     * @throws AccountsException
     * @throws GroupsException
     * @return bool
     */
    public function deleteAccount(string $userName): bool
    {
        $user = parent::getDataOnly($userName);
        return $user && $this->canAccessUserByClassId($user->getClass()) && !$this->currentUserRepresents($user)
            ? parent::deleteAccount($userName)
            : false
        ;
    }

    /**
     * All lower classes than user has
     * @throws GroupsException
     * @return array<int, string>
     */
    public function readClasses(): array
    {
        $availableClasses = [];
        foreach (parent::readClasses() as $classId => $className) {
            if ($this->canAccessUserByClassId($classId)) {
                $availableClasses[$classId] = $className;
            }
        }
        return $availableClasses;
    }

    /**
     * @param Interfaces\IGroup $group
     * @throws AccountsException
     * @throws GroupsException
     * @return bool
     */
    public function createGroup(Interfaces\IGroup $group): bool
    {
        $reGroup = clone $group;
        $reGroup->setGroupData(
            $group->getGroupId(),
            $group->getGroupName(),
            $group->getGroupDesc(),
            $this->getCurrentUser()->getAuthId(),
            $group->getGroupStatus(),
            $group->getGroupParents(),
            $group->getGroupExtra()
        );

        return ($this->canAccessGroup($reGroup) && !$this->isAlreadyInParents($reGroup))
            ? parent::createGroup($reGroup)
            : false
        ;
    }

    /**
     * @param string $groupId
     * @throws AccountsException
     * @throws GroupsException
     * @return Interfaces\IGroup|null
     */
    public function getGroupDataOnly(string $groupId): ?Interfaces\IGroup
    {
        $thisGroup = null;
        foreach (parent::readGroup() as $group) {
            /** @var Interfaces\IGroup $group */
            if ($group->getGroupId() == $groupId) {
                $thisGroup = $group;
                break;
            }
        }
        if (!$thisGroup) {
            return null;
        }

        return ($this->canAccessGroup($thisGroup))
            ? $thisGroup
            : null
        ;
    }

    /**
     * @throws AccountsException
     * @throws GroupsException
     * @return Interfaces\IGroup[]
     */
    public function readGroup(): array
    {
        $availableGroups = [];
        foreach (parent::readGroup() as $group) {
            /** @var Interfaces\IGroup $group */
            if ($this->canAccessGroup($group)) {
                $availableGroups[] = $group;
            }
        }
        return $availableGroups;
    }

    /**
     * @param Interfaces\IGroup $group
     * @throws AccountsException
     * @throws GroupsException
     * @return bool
     */
    public function updateGroup(Interfaces\IGroup $group): bool
    {
        return $this->canAccessGroup($group) && !$this->isAlreadyInParents($group)
            ? parent::updateGroup($group)
            : false
        ;
    }

    /**
     * @param string $groupId
     * @throws AccountsException
     * @throws AuthSourcesException
     * @throws GroupsException
     * @return bool
     */
    public function deleteGroup(string $groupId): bool
    {
        $group = $this->getGroupDataOnly($groupId);
        return $group && !$this->hasChildren($group)
            ? parent::deleteGroup($groupId)
            : false
        ;
    }

    public function getAuth(): Interfaces\IAuth
    {
        return $this;
    }

    public function getAccounts(): Interfaces\IProcessAccounts
    {
        return $this;
    }

    public function getGroups(): Interfaces\IProcessGroups
    {
        return $this;
    }

    public function getClasses(): Interfaces\IProcessClasses
    {
        return $this;
    }

    public function setCurrentUser(?Interfaces\IUser $user): self
    {
        $this->currentUser = $user;
        return $this;
    }

    /**
     * @throws GroupsException
     * @return Interfaces\IUser
     */
    public function getCurrentUser(): Interfaces\IUser
    {
        if (empty($this->currentUser)) {
            throw new GroupsException('Set Current User first!');
        }
        return $this->currentUser;
    }

    /**
     * @param Interfaces\IUser $user
     * @throws GroupsException
     * @return bool
     */
    protected function canAccessUser(Interfaces\IUser $user): bool
    {
        return $this->isMe($user) || $this->canAccessUserByClassId($user->getClass()) || $this->isCurrentUserRepresented($user);
    }

    /**
     * Aktualni Zastupuje dodavaneho
     * Aktualni je potomek dodavaneho
     * @param Interfaces\IUser $data
     * @throws GroupsException
     * @return bool
     */
    protected function currentUserRepresents(Interfaces\IUser $data): bool
    {
//print_r(['grp child', $this->getCurrentUser()->getGroup(), $data->getGroup(), intval($this->libGroup->canAccess($this->getCurrentUser()->getGroup(), $data->getGroup()))]);
        return $this->libGroup->canAccess($this->getCurrentUser()->getGroup(), $data->getGroup());
    }

    /**
     * Akntualni Je zastupovan dodanym
     * Aktualni je rodic dodavaneho
     * @param Interfaces\IUser $data
     * @throws GroupsException
     * @return bool
     */
    protected function isCurrentUserRepresented(Interfaces\IUser $data): bool
    {
//print_r(['grp parent', $this->getCurrentUser()->getGroup(), $data->getGroup(), intval($this->libGroup->canAccess($data->getGroup(), $this->getCurrentUser()->getGroup()))]);
        return $this->libGroup->canAccess($data->getGroup(), $this->getCurrentUser()->getGroup());
    }

    /**
     * @param int $class
     * @throws GroupsException
     * @return bool
     */
    protected function canAccessUserByClassId(int $class): bool
    {
        return $this->getCurrentUser()->getClass() < $class;
    }

    /**
     * @param Interfaces\IUser $data
     * @throws GroupsException
     * @return bool
     */
    protected function isMe(Interfaces\IUser $data): bool
    {
        return $this->getCurrentUser()->getAuthId() == $data->getAuthId();
    }

    /**
     * @param Interfaces\IGroup $data
     * @throws GroupsException
     * @return bool
     */
    protected function canAccessGroup(Interfaces\IGroup $data): bool
    {
        return $this->isMaintainer() || $this->canProcess($data);
    }

    /**
     * @throws GroupsException
     * @return bool
     */
    protected function isMaintainer(): bool
    {
        return Interfaces\IProcessClasses::CLASS_MAINTAINER == $this->getCurrentUser()->getClass();
    }

    /**
     * @param Interfaces\IGroup $group
     * @throws GroupsException
     * @return bool
     */
    protected function canProcess(Interfaces\IGroup $group): bool
    {
        $current = $this->getCurrentUser();
        return
            Interfaces\IProcessClasses::CLASS_ADMIN == $current->getClass()
            && (
                $group->getGroupAuthorId() == $current->getAuthId()
                || (
                    $group->getGroupId()
                    && $this->libGroup->canAccess($group->getGroupId(), $current->getGroup())
                )
            )
        ;
    }

    /**
     * @param Interfaces\IGroup $group
     * @throws GroupsException
     * @return bool
     */
    protected function isAlreadyInParents(Interfaces\IGroup $group): bool
    {
        foreach ($group->getGroupParents() as $groupParent) {
            if ($this->libGroup->canAccess($groupParent, $group->getGroupId())) {
                return true;
            }
        }
        return false;
    }

    /**
     * @param Interfaces\IGroup $group
     * @throws AccountsException
     * @throws AuthSourcesException
     * @return bool
     */
    protected function hasChildren(Interfaces\IGroup $group): bool
    {
        $allGroups = $this->adapter->getGroups()->readGroup();
        foreach ($allGroups as $sourceGroup) {
            if (in_array($group->getGroupId(), $sourceGroup->getGroupParents())) {
                return true;
            }
        }
        return false;
    }
}