Jabe\Engine\Impl\IdentityServiceImpl

Complexity

Total Complexity

47

Size/Duplication

Total Lines	236
Duplicated Lines	0 %

Importance

Changes

0

39 Methods

Rating	Name	Duplication	Size	Complexity
A	createGroupQuery()	0	3	1
A	getUserInfo()	0	3	1
A	setUserInfo()	0	3	1
A	newTenant()	0	3	1
A	checkPasswordAgainstPolicy()	0	20	3
A	deleteMembership()	0	3	1
A	clearAuthentication()	0	3	1
A	deleteGroup()	0	3	1
A	createTenantQuery()	0	3	1
A	newGroup()	0	3	1
A	setAuthenticatedUserId()	0	3	1
A	deleteUserPicture()	0	3	1
A	newUser()	0	3	1
A	deleteUser()	0	3	1
A	deleteTenantGroupMembership()	0	3	1
A	setAuthentication()	0	3	1
A	getUserAccountNames()	0	3	1
A	createTenantGroupMembership()	0	3	1
A	deleteTenant()	0	3	1
A	createUserQuery()	0	3	1
A	deleteTenantUserMembership()	0	3	1
A	saveTenant()	0	9	3
A	saveUser()	0	9	3
A	getPasswordPolicy()	0	3	1
A	getCurrentAuthentication()	0	3	1
A	getUserAccount()	0	3	1
A	saveGroup()	0	9	3
A	getUserPicture()	0	3	1
A	createMembership()	0	3	1
A	setUserPicture()	0	3	1
A	unlockUser()	0	3	1
A	getUserInfoKeys()	0	3	1
A	deleteUserAccount()	0	3	1
A	setUserAccount()	0	3	1
A	createTenantUserMembership()	0	3	1
A	deleteUserInfo()	0	3	1
A	checkPassword()	0	3	1
A	createNativeUserQuery()	0	3	1
A	isReadOnly()	0	3	1

<?php

namespace Jabe\Engine\Impl;

use Jabe\Engine\{
    BadUserRequestException,
    IdentityService,
    ProcessEngineException
};
use Jabe\Engine\Identity\{
    PasswordPolicyResultInterface,
    GroupInterface,
    GroupQueryInterface,
    NativeUserQueryInterface,
    PasswordPolicyInterface,
    PasswordPolicyRuleInterface,
    Picture,
    TenantInterface,
    TenantQueryInterface,
    UserInterface,
    UserQueryInterface
};
use Jabe\Engine\Impl\Cmd\{
    CheckPassword,
    GetPasswordPolicyCmd,
    CreateGroupCmd,
    CreateGroupQueryCmd,
    CreateMembershipCmd,
    CreateNativeUserQueryCmd,
    CreateTenantCmd,
    CreateTenantGroupMembershipCmd,
    CreateTenantQueryCmd,
    CreateTenantUserMembershipCmd,
    CreateUserCmd,
    CreateUserQueryCmd,
    DeleteGroupCmd,
    DeleteMembershipCmd,
    DeleteTenantCmd,
    DeleteTenantGroupMembershipCmd,
    DeleteTenantUserMembershipCmd,
    DeleteUserCmd,
    DeleteUserInfoCmd,
    DeleteUserPictureCmd,
    GetUserAccountCmd,
    GetUserInfoCmd,
    GetUserInfoKeysCmd,
    GetUserPictureCmd,
    IsIdentityServiceReadOnlyCmd,
    SaveGroupCmd,
    SaveTenantCmd,
    SaveUserCmd,
    SetUserInfoCmd,
    SetUserPictureCmd,
    UnlockUserCmd
};
use Jabe\Engine\Impl\Identity\{
    AccountInterface,
    Authentication,
    PasswordPolicyResultImpl
};
use Jabe\Engine\Impl\Persistence\Entity\IdentityInfoEntity;
use Jabe\Engine\Impl\Util\{
    EnsureUtil,
    ExceptionUtil
};

class IdentityServiceImpl extends ServiceImpl implements IdentityServiceInterface
{
    /** thread local holding the current authentication */
    private $currentAuthentication;

    public function isReadOnly(): bool
    {
        return $this->commandExecutor->execute(new IsIdentityServiceReadOnlyCmd());
    }

    public function newGroup(string $groupId): GroupInterface
    {
        return $this->commandExecutor->execute(new CreateGroupCmd($groupId));
    }

    public function newUser(string $userId): UserInterface
    {
        return $this->commandExecutor->execute(new CreateUserCmd($userId));
    }

    public function newTenant(string $tenantId): TenantInterface
    {
        return $this->commandExecutor->execute(new CreateTenantCmd($tenantId));
    }

    public function saveGroup(GroupInterface $group): void
    {
        try {
            $this->commandExecutor->execute(new SaveGroupCmd($group));
        } catch (\Exception $ex) {
            if (ExceptionUtil::checkConstraintViolationException($ex)) {
                throw new BadUserRequestException("The group already exists", $ex);
            }
            throw $ex;
        }
    }

    public function saveUser(UserInterface $user, bool $skipPasswordPolicy = false): void
    {
        try {
            $this->commandExecutor->execute(new SaveUserCmd($user, $skipPasswordPolicy));
        } catch (\Exception $ex) {
            if (ExceptionUtil::checkConstraintViolationException($ex)) {
                throw new BadUserRequestException("The user already exists", $ex);
            }
            throw $ex;
        }
    }

    public function saveTenant(TenantInterface $tenant): void
    {
        try {
            $this->commandExecutor->execute(new SaveTenantCmd($tenant));
        } catch (\Exception $ex) {
            if (ExceptionUtil::checkConstraintViolationException($ex)) {
                throw new BadUserRequestException("The tenant already exists", $ex);
            }
            throw $ex;
        }
    }

    public function createUserQuery(): UserQueryInterface
    {
        return $this->commandExecutor->execute(new CreateUserQueryCmd());
    }

    public function createNativeUserQuery(): NativeUserQueryInterface
    {
        return $this->commandExecutor->execute(new CreateNativeUserQueryCmd());
    }

    public function createGroupQuery(): GroupQueryInterface
    {
        return $this->commandExecutor->execute(new CreateGroupQueryCmd());
    }

    public function createTenantQuery(): TenantQueryInterface
    {
        return $this->commandExecutor->execute(new CreateTenantQueryCmd());
    }

    public function createMembership(string $userId, string $groupId): void
    {
        $this->commandExecutor->execute(new CreateMembershipCmd($userId, $groupId));
    }

    public function deleteGroup(string $groupId): void
    {
        $this->commandExecutor->execute(new DeleteGroupCmd($groupId));
    }

    public function deleteMembership(string $userId, string $groupId): void
    {
        $this->commandExecutor->execute(new DeleteMembershipCmd($userId, $groupId));
    }

    public function checkPassword(string $userId, string $password): bool
    {
        return $this->commandExecutor->execute(new CheckPassword($userId, $password));
    }

    public function checkPasswordAgainstPolicy(
        ?PasswordPolicyResultInterface $policy,
        string $candidatePassword,
        ?UserInterface $user
    ): PasswordPolicyResultInterface {
        $policy = $policy ?? $this->getPasswordPolicy();
        EnsureUtil::ensureNotNull("policy", "policy", $policy);
        EnsureUtil::ensureNotNull("password", "candidatePassword", $candidatePassword);

        $violatedRules = [];
        $fulfilledRules = [];

        foreach ($policy->getRules() as $rule) {

The method getRules() does not exist on Jabe\Engine\Identity\PasswordPolicyResultInterface.

            if ($rule->execute($candidatePassword, $user)) {
                $fulfilledRules[] = $rule;
            } else {
                $violatedRules[] = $rule;
            }
        }
        return new PasswordPolicyResultImpl($violatedRules, $fulfilledRules);
    }

    public function getPasswordPolicy(): PasswordPolicyInterface
    {
        return $this->commandExecutor->execute(new GetPasswordPolicyCmd());
    }

    public function unlockUser(string $userId): void
    {
        $this->commandExecutor->execute(new UnlockUserCmd($userId));
    }

    public function deleteUser(string $userId): void
    {
        $this->commandExecutor->execute(new DeleteUserCmd($userId));
    }

    public function deleteTenant(string $tenantId): void
    {
        $this->commandExecutor->execute(new DeleteTenantCmd($tenantId));
    }

    public function setUserPicture(string $userId, Picture $picture): void
    {
        $this->commandExecutor->execute(new SetUserPictureCmd($userId, $picture));
    }

    public function getUserPicture(string $userId): Picture
    {
        return $this->commandExecutor->execute(new GetUserPictureCmd($userId));
    }

    public function deleteUserPicture(string $userId): void
    {
        $this->commandExecutor->execute(new DeleteUserPictureCmd($userId));
    }

    public function setAuthenticatedUserId(string $authenticatedUserId): void
    {
        $this->setAuthentication(new Authentication($authenticatedUserId, null));

The call to Jabe\Engine\Impl\IdentityServiceImpl::setAuthentication() has too few arguments starting with groups.

new Jabe\Engine\Impl\Identity\Authentication($authenticatedUserId, null) of type Jabe\Engine\Impl\Identity\Authentication is incompatible with the type string expected by parameter $userId of Jabe\Engine\Impl\IdentityServiceImpl::setAuthentication().

    }

    public function setAuthentication(string $userId, array $groups, ?array $tenantIds = null): void
    {
        $this->currentAuthentication = new Authentication($userId, $groups, $tenantIds);
    }

    public function clearAuthentication(): void
    {
        $this->currentAuthentication = null;
    }

    public function getCurrentAuthentication(): ?Authentication
    {
        return $this->currentAuthentication;
    }

    public function getUserInfo(string $userId, string $key): string
    {
        return $this->commandExecutor->execute(new GetUserInfoCmd($userId, $key));
    }

    public function getUserInfoKeys(string $userId): array
    {
        return $this->commandExecutor->execute(new GetUserInfoKeysCmd($userId, IdentityInfoEntity::TYPE_USERINFO));
    }

    public function getUserAccountNames(string $userId): array
    {
        return $this->commandExecutor->execute(new GetUserInfoKeysCmd($userId, IdentityInfoEntity::TYPE_USERACCOUNT));
    }

    public function setUserInfo(string $userId, string $key, string $value): void
    {
        $this->commandExecutor->execute(new SetUserInfoCmd($userId, $key, $value));

The call to Jabe\Engine\Impl\Cmd\SetUserInfoCmd::__construct() has too many arguments starting with $userId.

    }

    public function deleteUserInfo(string $userId, string $key): void
    {
        $this->commandExecutor->execute(new DeleteUserInfoCmd($userId, $key));
    }

    public function deleteUserAccount(string $userId, string $accountName): void
    {
        $this->commandExecutor->execute(new DeleteUserInfoCmd($userId, $accountName));
    }

    public function getUserAccount(string $userId, string $userPassword, string $accountName): ?AccountInterface
    {
        return $this->commandExecutor->execute(new GetUserAccountCmd($userId, $userPassword, $accountName));
    }

    public function setUserAccount(string $userId, string $userPassword, string $accountName, string $accountUsername, string $accountPassword, array $accountDetails): void
    {
        $this->commandExecutor->execute(new SetUserInfoCmd($userId, $userPassword, $accountName, $accountUsername, $accountPassword, $accountDetails));

The call to Jabe\Engine\Impl\Cmd\SetUserInfoCmd::__construct() has too many arguments starting with $userId.

    }

    public function createTenantUserMembership(string $tenantId, string $userId): void
    {
        $this->commandExecutor->execute(new CreateTenantUserMembershipCmd($tenantId, $userId));
    }

    public function createTenantGroupMembership(string $tenantId, string $groupId): void
    {
        $this->commandExecutor->execute(new CreateTenantGroupMembershipCmd($tenantId, $groupId));
    }

    public function deleteTenantUserMembership(string $tenantId, string $userId): void
    {
        $this->commandExecutor->execute(new DeleteTenantUserMembershipCmd($tenantId, $userId));
    }

    public function deleteTenantGroupMembership(string $tenantId, string $groupId): void
    {
        $this->commandExecutor->execute(new DeleteTenantGroupMembershipCmd($tenantId, $groupId));
    }
}