rhertogh\Yii2Oauth2Server\controllers\console\client\base\Oauth2BaseEditClientAction::configureClient()

Complexity

Conditions	32
Paths	> 20000

Size

Total Lines	149
Code Lines	101

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	1056

Importance

Changes	1
Bugs	0	Features	0

<?php
    protected function configureClient($client)
    {
        $controller = $this->controller;
        $module = $controller->module;

        $identifier = $controller->identifier;
        if (
            empty($identifier)
            || !$this->clientIdentifierValidator($controller->identifier, $clientIdentifierValidatorError)
        ) {
            if (!empty($clientIdentifierValidatorError)) {
                $controller->stdout($clientIdentifierValidatorError . PHP_EOL);
            }
            $identifier = $controller->prompt('Client Identifier?', [
                'required' => true,
                'default' => $client->getIdentifier(),
                'validator' => [$this, 'clientIdentifierValidator'],
            ]);
        }
        $client->setIdentifier($identifier);

        $name = $controller->name;
        if (empty($name)) {
            $name = $controller->prompt('Client Name?', [
                'required' => true,
                'default' => $client->getName(),
            ]);
        }
        $client->setName($name);

        $type = $controller->type;
        if (empty($type)) {
            $clientTypeOptions = [
                Oauth2ClientInterface::TYPE_CONFIDENTIAL => 'Confidential',
                Oauth2ClientInterface::TYPE_PUBLIC => 'Public',
            ];
            $clientTypeOptionsWithDetails = [
                Oauth2ClientInterface::TYPE_CONFIDENTIAL => 'Confidential: Identifies the client via a shared secret.'
                    . ' Note: This should only be trusted in case the client can store the secret securely'
                    . ' (e.g. another server).',
                Oauth2ClientInterface::TYPE_PUBLIC => 'Public: In case the client can not store a secret securely'
                    . ' it should be declared public (e.g. web- or mobile applications).',
            ];
            if ($controller->interactive) {
                $controller->stdout('Client Type options:' . PHP_EOL);
                foreach ($clientTypeOptions as $key => $value) {
                    $controller->stdout(" $key - $value" . PHP_EOL);
                }
            }
            $type = $controller->select(
                'Client Type?',
                $clientTypeOptionsWithDetails,
                $client->isConfidential()
                    ? Oauth2ClientInterface::TYPE_CONFIDENTIAL
                    : Oauth2ClientInterface::TYPE_PUBLIC
            );
        }
        $type = (int)$type;
        $client->setType($type);

        $grantTypes = $controller->grantTypes;
        if (empty($grantTypes)) {
            $availableGrantTypes = array_map(
                fn(GrantTypeInterface $grant) => $grant->getIdentifier(),
                $module->getAuthorizationServer()->getEnabledGrantTypes()
            );

            if ($controller->interactive) {
                $controller->stdout('Enable Grant Types:' . PHP_EOL);
            }
            $grantTypes = 0;
            foreach ($availableGrantTypes as $availableGrantType) {
                if (
                    $controller->confirm(
                        ' - ' . $availableGrantType,
                        (bool)($client->getGrantTypes() & Oauth2Module::getGrantTypeId($availableGrantType))
                    )
                ) {
                    $grantTypes |= Oauth2Module::getGrantTypeId($availableGrantType);
                }
            }
        }
        $client->setGrantTypes($grantTypes);

It seems like $grantTypes can also be of type string; however, parameter $grantTypes of rhertogh\Yii2Oauth2Server\interfaces\models\Oauth2ClientInterface::setGrantTypes() does only seem to accept integer, maybe add an additional type check?

        $redirectUrisRequired =
            (bool)($client->getGrantTypes() & (Oauth2Module::GRANT_TYPE_AUTH_CODE | Oauth2Module::GRANT_TYPE_IMPLICIT));

        $redirectURIs = $controller->redirectURIs;
        if (
            empty($controller->redirectURIs)
            && (
                $redirectUrisRequired
                || (
                    !$client->getIsNewRecord() && $client->getRedirectUri()
                )
            )
        ) {
            $redirectURIs = $controller->prompt('Client Redirect URIs (comma separated)?', [
                'required' => $redirectUrisRequired,
                'default' => implode(',', $client->getRedirectUri())
            ]);
            $redirectURIs = array_map('trim', explode(',', $redirectURIs));
        }
        $client->setRedirectUri($redirectURIs);

        if ($type == Oauth2ClientInterface::TYPE_CONFIDENTIAL && $client->getIsNewRecord()) {
            $secret = $controller->secret;
            if (!empty($secret) && !$client->validateNewSecret($secret, $error)) {
                $controller->stdout("Invalid secret: $error" . PHP_EOL);
                $secret = null;
            }
            if (empty($secret)) {
                $secret = $controller->prompt('Client Secret?', [
                    'required' => true,
                    'validator' => [$client, 'validateNewSecret'],
                ]);
            }
            $client->setSecret($secret, $module->getCryptographer());
        }

        if ($controller->allowVariableRedirectUriQuery !== null) {
            $client->setAllowVariableRedirectUriQuery((bool)$controller->allowVariableRedirectUriQuery);
        }
        if ($controller->allowGenericScopes !== null) {
            $client->setAllowGenericScopes((bool)$controller->allowGenericScopes);
        }
        if ($controller->exceptionOnInvalidScope !== null) {
            $client->setExceptionOnInvalidScope((bool)$controller->exceptionOnInvalidScope);
        }
        if ($controller->endUsersMayAuthorizeClient !== null) {
            $client->setEndUsersMayAuthorizeClient((bool)$controller->endUsersMayAuthorizeClient);
        }
        if ($controller->userAccountSelection !== null) {
            $client->setUserAccountSelection((int)$controller->userAccountSelection);
        }
        if ($controller->isAuthCodeWithoutPkceAllowed !== null) {
            $client->setAllowAuthCodeWithoutPkce((bool)$controller->isAuthCodeWithoutPkceAllowed);
        }
        if ($controller->skipAuthorizationIfScopeIsAllowed !== null) {
            $client->setSkipAuthorizationIfScopeIsAllowed((bool)$controller->skipAuthorizationIfScopeIsAllowed);
        }
        if ($controller->logoUri !== null) {
            $client->setLogoUri($controller->logoUri);
        }
        if ($controller->termsOfServiceUri !== null) {
            $client->setTermsOfServiceUri($controller->termsOfServiceUri);
        }
        if ($controller->contacts !== null) {
            $client->setContacts($controller->contacts);
        }