UserCreator::initialize() - Code Metrics - Inspection of "Fix deprecation" - SchulIT/idp - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 690dfa...8b5d92 )

by Marcel
created 2021-12-31 12:38 UTC
UserCreator::initialize() A

↳ Parent: UserCreator
Complexity

Conditions	4
Paths	8
Size

Total Lines	14
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	6
CRAP Score	5.024
Importance

Changes
Metric	Value
cc	4
eloc	9
c	0
b	0
f	0
nc	8
nop	0
dl	0
loc	14
ccs	6
cts	10
cp	0.6
crap	5.024
rs	9.9666
<?php

namespace App\Security;

use App\ActiveDirectory\OptionResolver;
use App\Entity\ActiveDirectoryGradeSyncOption;
use App\Entity\ActiveDirectoryRoleSyncOption;
use App\Entity\ActiveDirectorySyncOption;
use App\Entity\ActiveDirectoryUser;
use App\Entity\UserType;
use App\Repository\ActiveDirectoryGradeSyncOptionRepositoryInterface;
use App\Repository\ActiveDirectoryRoleSyncOptionRepositoryInterface;
use App\Repository\ActiveDirectorySyncOptionRepositoryInterface;
use App\Repository\UserRepositoryInterface;
use Ramsey\Uuid\Uuid;

/**
 * Helper which creates users after successful Active Directory authentication.
 */
class UserCreator {
    /** @var ActiveDirectorySyncOption[] */
    private ?array $syncOptions = null;

    /** @var ActiveDirectoryGradeSyncOption[] */
    private ?array $gradeSyncOptions = null;

    /** @var ActiveDirectoryRoleSyncOption[] */
    private ?array $roleSyncOptions = null;

    private OptionResolver $optionsResolver;

    private ActiveDirectorySyncOptionRepositoryInterface $syncOptionRepository;
    private ActiveDirectoryGradeSyncOptionRepositoryInterface $gradeSyncOptionRepository;
    private ActiveDirectoryRoleSyncOptionRepositoryInterface $roleSyncOptionRepository;
    private UserRepositoryInterface $userRepository;

    public function __construct(ActiveDirectorySyncOptionRepositoryInterface $syncOptionRepository,
                                ActiveDirectoryGradeSyncOptionRepositoryInterface $gradeSyncOptionRepository,
                                ActiveDirectoryRoleSyncOptionRepositoryInterface $roleSyncOptionRepository, OptionResolver $optionResolver, UserRepositoryInterface $userRepository) {
        $this->syncOptionRepository = $syncOptionRepository;
        $this->gradeSyncOptionRepository = $gradeSyncOptionRepository;
        $this->roleSyncOptionRepository = $roleSyncOptionRepository;
        $this->optionsResolver = $optionResolver;
        $this->userRepository = $userRepository;
    }

    private function initialize(): void {
        if ($this->syncOptions === null) {
            $this->syncOptions = $this->syncOptionRepository
                ->findAll();
        }

        if ($this->gradeSyncOptions === null) {
            $this->gradeSyncOptions = $this->gradeSyncOptionRepository
                ->findAll();
        }

        if($this->roleSyncOptions === null) {
            $this->roleSyncOptions = $this->roleSyncOptionRepository
                ->findAll();
        }
    }

    /**
     * Determines whether the user can be imported from Active Directory.
     *
     * @param ActiveDirectoryUserInformation $response
     * @return bool
     */
    public function canCreateUser(ActiveDirectoryUserInformation $response): bool {
        $this->initialize();
        return $this->getTargetUserType($response) !== null;
    }

    /**
     * @param ActiveDirectoryUserInformation $response
     * @return UserType|null
     */
    private function getTargetUserType(ActiveDirectoryUserInformation $response): ?UserType {
        /** @var ActiveDirectorySyncOption|null $option */
        $option = $this->optionsResolver
            ->getOption($this->syncOptions, $response->getOu(), $response->getGroups());
            ->getOption(/** @scrutinizer ignore-type */ $this->syncOptions, $response->getOu(), $response->getGroups());

        if ($option !== null) {
            return $option->getUserType();
        }

        return null;
    }

    /**
     * @param ActiveDirectoryUserInformation $response
     * @param ActiveDirectoryUser|null $user Already existing AD user
     * @return ActiveDirectoryUser
     */
    public function createUser(ActiveDirectoryUserInformation $response, ?ActiveDirectoryUser $user = null): ?ActiveDirectoryUser {
        $this->initialize();

        if ($user === null) {
            // Try to find already existing user by GUID (because username has changed)
            $user = $this->userRepository->findActiveDirectoryUserByObjectGuid($response->getGuid());

            if($user === null) {
                $user = new ActiveDirectoryUser();
                $user->setObjectGuid(Uuid::fromString($response->getGuid()));
            }
        }

        $user->setUsername(mb_strtolower($response->getUserPrincipalName()));
        $user->setFirstname($response->getFirstname());
        $user->setLastname($response->getLastname());
        $user->setGrade($this->getGrade($response));
        $user->setUserPrincipalName(mb_strtolower($response->getUserPrincipalName()));
        $user->setType($this->getTargetUserType($response));
        $user->setType(/** @scrutinizer ignore-type */ $this->getTargetUserType($response));
        $user->setEmail($response->getEmail());
        $user->setExternalId($response->getUniqueId());

        $user->setOu($response->getOu());
        $user->setGroups($response->getGroups());

        // Set roles

        /** @var ActiveDirectoryRoleSyncOption[] $options */
        $options = $this->optionsResolver->getAllOptions(
            $this->roleSyncOptions,
            /** @scrutinizer ignore-type */ $this->roleSyncOptions,
            $response->getOu(),
            $response->getGroups()
        );

        foreach($options as $option) {
            $role = $option->getUserRole();

            if($user->getUserRoles()->contains($role) !== true) {
                $user->addUserRole($role);
            }
        }

        $existingUser = $this->userRepository->findOneByUsername($user->getUserPrincipalName());

        // Convert user (if necessary)
        if($existingUser !== null && !$existingUser instanceof ActiveDirectoryUser) {
            $user = $this->userRepository->convertToActiveDirectory($existingUser, $user);
        }

        return $user;
    }

    /**
     * @param ActiveDirectoryUserInformation $response
     * @return string|null
     */
    private function getGrade(ActiveDirectoryUserInformation $response): ?string {
        /** @var ActiveDirectoryGradeSyncOption|null $option */
        $option = $this->optionsResolver
            ->getOption($this->gradeSyncOptions, $response->getOu(), $response->getGroups());
            ->getOption(/** @scrutinizer ignore-type */ $this->gradeSyncOptions, $response->getOu(), $response->getGroups());

        if($option !== null) {
            return $option->getGrade();
        }

        return null;
    }
}
SchulIT / idp

Push — master ( 690dfa...8b5d92 )

UserCreator::initialize() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
