Create::getAdminResources() - Code Metrics - Inspection of "New console commands" - abterphp/admin - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 7c51ba...a22fab )

by Peter

created 2019-06-20 19:56 UTC

Create::getAdminResources() A

↳ Parent: Create

Complexity

Conditions	5
Paths	7

Size

Total Lines	21
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	11
dl	0
loc	21
rs	9.6111
c	0
b	0
f	0
cc	5
nc	7
nop	1

<?php

declare(strict_types=1);

namespace AbterPhp\Admin\Console\Commands\ApiClient;

use AbterPhp\Admin\Domain\Entities\ApiClient;
use AbterPhp\Admin\Orm\AdminResourceRepo;
use AbterPhp\Admin\Orm\ApiClientRepo;
use AbterPhp\Admin\Orm\UserRepo;
use AbterPhp\Framework\Authorization\CacheManager;
use AbterPhp\Framework\Crypto\Crypto;
use Hackzilla\PasswordGenerator\Generator\ComputerPasswordGenerator as PasswordGenerator;
filter:
    dependency_paths: ["lib/*"]
use Opulence\Console\Commands\Command;
use Opulence\Console\Requests\Argument;
use Opulence\Console\Requests\ArgumentTypes;
use Opulence\Console\Requests\Option;
use Opulence\Console\Requests\OptionTypes;
use Opulence\Console\Responses\IResponse;
use Opulence\Orm\IUnitOfWork;
use ZxcvbnPhp\Zxcvbn;

class Create extends Command
{
    const COMMAND_NAME            = 'apiclient:create';
    const COMMAND_DESCRIPTION     = 'Creates a new API client';
    const COMMAND_SUCCESS         = '<success>New API client is created. ID: <b>%s</b></success>';
    const COMMAND_DRY_RUN_MESSAGE = '<info>Dry run prevented creating new API client.</info>';

    const ARGUMENT_USER        = 'user';
    const ARGUMENT_DESCRIPTION = 'description';
    const ARGUMENT_RESOURCES   = 'resources';

    const OPTION_DRY_RUN    = 'dry-run';
    const SHORTENED_DRY_RUN = 'd';

    const RESPONSE_SECRET = '<info>Secret generated: <b>%s</b></info>';

    /** @var UserRepo */
    protected $userRepo;

    /** @var AdminResourceRepo */
    protected $adminResourceRepo;

    /** @var ApiClientRepo */
    protected $apiClientRepo;

    /** @var PasswordGenerator */
    protected $passwordGenerator;

    /** @var Crypto */
    protected $crypto;

    /** @var IUnitOfWork */
    protected $unitOfWork;

    /** @var CacheManager */
    protected $cacheManager;

    /** @var Zxcvbn */
    protected $zxcvbn;

    /**
     * Create constructor.
     *
     * @param UserRepo          $userRepo
     * @param AdminResourceRepo $adminResourceRepo
     * @param ApiClientRepo     $apiClientRepo
     * @param PasswordGenerator $passwordGenerator
     * @param Crypto            $crypto
     * @param IUnitOfWork       $unitOfWork
     * @param CacheManager      $cacheManager
     * @param Zxcvbn            $zxcvbn
     */
    public function __construct(
        UserRepo $userRepo,
        AdminResourceRepo $adminResourceRepo,
        ApiClientRepo $apiClientRepo,
        PasswordGenerator $passwordGenerator,
        Crypto $crypto,
        IUnitOfWork $unitOfWork,
        CacheManager $cacheManager,
        Zxcvbn $zxcvbn
    ) {
        $this->userRepo          = $userRepo;
        $this->adminResourceRepo = $adminResourceRepo;
        $this->apiClientRepo     = $apiClientRepo;
        $this->passwordGenerator = $passwordGenerator;
        $this->crypto            = $crypto;
        $this->unitOfWork        = $unitOfWork;
        $this->cacheManager      = $cacheManager;
        $this->zxcvbn            = $zxcvbn;

        parent::__construct();
    }

    /**
     * @inheritdoc
     */
    protected function define()
    {
        $this->setName(static::COMMAND_NAME)
            ->setDescription(static::COMMAND_DESCRIPTION)
            ->addArgument(
                new Argument(
                    static::ARGUMENT_USER,
                    ArgumentTypes::REQUIRED,
                    'User Identifier (Email or Username)'
                )
            )
            ->addArgument(
                new Argument(
                    static::ARGUMENT_DESCRIPTION,
                    ArgumentTypes::REQUIRED,
                    'Description'
                )
            )
            ->addArgument(
                new Argument(
                    static::ARGUMENT_RESOURCES,
                    ArgumentTypes::REQUIRED,
                    'Resources (Comma separated list)'
                )
            )
            ->addOption(
                new Option(
                    static::OPTION_DRY_RUN,
                    static::SHORTENED_DRY_RUN,
                    OptionTypes::OPTIONAL_VALUE,
                    'Dry run (default: 0)',
                    '0'
                )
            );
    }

    /**
     * @inheritdoc
     */
    protected function doExecute(IResponse $response)
    {
        $userIdentifier = $this->getArgumentValue(static::ARGUMENT_USER);

        try {
            $user = $this->userRepo->find($userIdentifier);
            if (!$user) {
                throw new \RuntimeException();
            }

            $adminResources = $this->getAdminResources($user->getId());

            $rawSecret        = $this->passwordGenerator->generatePassword();
            $preparedPassword = $this->crypto->prepareSecret($rawSecret);
            $packedPassword   = $this->crypto->hashCrypt($preparedPassword);

            $apiClient = $this->getApiClient($user->getId(), $packedPassword, $adminResources);

            $this->apiClientRepo->add($apiClient);
        } catch (\Exception $e) {
            if ($e->getPrevious()) {
                $response->writeln(sprintf('<error>%s</error>', $e->getPrevious()->getMessage()));
            }
            $response->writeln(sprintf('<fatal>%s</fatal>', $e->getMessage()));

            return;
        }


        $dryRun = (bool)$this->getOptionValue(static::OPTION_DRY_RUN);
        if ($dryRun) {
            $this->unitOfWork->dispose();
            $response->writeln(static::COMMAND_DRY_RUN_MESSAGE);

            return;
        }

        try {
            $this->unitOfWork->commit();
            $this->cacheManager->clearAll();
        } catch (\Exception $e) {
            if ($e->getPrevious()) {
                $response->writeln(sprintf('<error>%s</error>', $e->getPrevious()->getMessage()));
            }
            $response->writeln(sprintf('<fatal>%s</fatal>', $e->getMessage()));

            return;
        }

        $response->writeln(sprintf(static::RESPONSE_SECRET, $rawSecret));
        $response->writeln(sprintf(static::COMMAND_SUCCESS, $apiClient->getId()));
    }

    /**
     * @param string          $userId
     * @param string          $packedPassword
     * @param AdminResource[] $adminResources
     *
     * @return ApiClient
     * @throws \Opulence\Orm\OrmException
     * @throws \RuntimeException
     */
    protected function getApiClient(string $userId, string $packedPassword, array $adminResources): ApiClient
    {
        $description = $this->getArgumentValue(static::ARGUMENT_DESCRIPTION);
        $resources   = $this->getArgumentValue(static::ARGUMENT_RESOURCES);


        return new ApiClient(
            '',
            $userId,
            $description,
            $packedPassword,
            $adminResources
        );
    }

    /**
     * @param string $userId
     *
     * @return AdminResource[]
     */
    protected function getAdminResources(string $userId): array
    {
        $resources = explode(',', $this->getArgumentValue(static::ARGUMENT_RESOURCES));
        if (!$resources) {

            return [];
        }

        $adminResources = [];
        foreach ($this->adminResourceRepo->getByUserId($userId) as $adminResource) {
            if (!in_array($adminResource->getIdentifier(), $resources, true)) {
                continue;
            }

            $adminResources[] = $adminResource;
        }

        if (count($resources) != count($adminResources)) {
            throw new \RuntimeException('User does not have all requested resources');
        }

        return $adminResources;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace AbterPhp\Admin\Console\Commands\ApiClient;
6
7			use AbterPhp\Admin\Domain\Entities\ApiClient;
8			use AbterPhp\Admin\Orm\AdminResourceRepo;
9			use AbterPhp\Admin\Orm\ApiClientRepo;
10			use AbterPhp\Admin\Orm\UserRepo;
11			use AbterPhp\Framework\Authorization\CacheManager;
12			use AbterPhp\Framework\Crypto\Crypto;
13			use Hackzilla\PasswordGenerator\Generator\ComputerPasswordGenerator as PasswordGenerator;
			0 ignored issues – show Bug introduced 2019-06-20 20:00 UTC by Report Bug Copy Issue Report The type `Hackzilla\PasswordGenera...mputerPasswordGenerator` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
14			use Opulence\Console\Commands\Command;
15			use Opulence\Console\Requests\Argument;
16			use Opulence\Console\Requests\ArgumentTypes;
17			use Opulence\Console\Requests\Option;
18			use Opulence\Console\Requests\OptionTypes;
19			use Opulence\Console\Responses\IResponse;
20			use Opulence\Orm\IUnitOfWork;
21			use ZxcvbnPhp\Zxcvbn;
22
23			class Create extends Command
24			{
25			const COMMAND_NAME = 'apiclient:create';
26			const COMMAND_DESCRIPTION = 'Creates a new API client';
27			const COMMAND_SUCCESS = '<success>New API client is created. ID: <b>%s</b></success>';
28			const COMMAND_DRY_RUN_MESSAGE = '<info>Dry run prevented creating new API client.</info>';
29
30			const ARGUMENT_USER = 'user';
31			const ARGUMENT_DESCRIPTION = 'description';
32			const ARGUMENT_RESOURCES = 'resources';
33
34			const OPTION_DRY_RUN = 'dry-run';
35			const SHORTENED_DRY_RUN = 'd';
36
37			const RESPONSE_SECRET = '<info>Secret generated: <b>%s</b></info>';
38
39			/** @var UserRepo */
40			protected $userRepo;
41
42			/** @var AdminResourceRepo */
43			protected $adminResourceRepo;
44
45			/** @var ApiClientRepo */
46			protected $apiClientRepo;
47
48			/** @var PasswordGenerator */
49			protected $passwordGenerator;
50
51			/** @var Crypto */
52			protected $crypto;
53
54			/** @var IUnitOfWork */
55			protected $unitOfWork;
56
57			/** @var CacheManager */
58			protected $cacheManager;
59
60			/** @var Zxcvbn */
61			protected $zxcvbn;
62
63			/**
64			* Create constructor.
65			*
66			* @param UserRepo $userRepo
67			* @param AdminResourceRepo $adminResourceRepo
68			* @param ApiClientRepo $apiClientRepo
69			* @param PasswordGenerator $passwordGenerator
70			* @param Crypto $crypto
71			* @param IUnitOfWork $unitOfWork
72			* @param CacheManager $cacheManager
73			* @param Zxcvbn $zxcvbn
74			*/
75			public function __construct(
76			UserRepo $userRepo,
77			AdminResourceRepo $adminResourceRepo,
78			ApiClientRepo $apiClientRepo,
79			PasswordGenerator $passwordGenerator,
80			Crypto $crypto,
81			IUnitOfWork $unitOfWork,
82			CacheManager $cacheManager,
83			Zxcvbn $zxcvbn
84			) {
85			$this->userRepo = $userRepo;
86			$this->adminResourceRepo = $adminResourceRepo;
87			$this->apiClientRepo = $apiClientRepo;
88			$this->passwordGenerator = $passwordGenerator;
89			$this->crypto = $crypto;
90			$this->unitOfWork = $unitOfWork;
91			$this->cacheManager = $cacheManager;
92			$this->zxcvbn = $zxcvbn;
93
94			parent::__construct();
95			}
96
97			/**
98			* @inheritdoc
99			*/
100			protected function define()
101			{
102			$this->setName(static::COMMAND_NAME)
103			->setDescription(static::COMMAND_DESCRIPTION)
104			->addArgument(
105			new Argument(
106			static::ARGUMENT_USER,
107			ArgumentTypes::REQUIRED,
108			'User Identifier (Email or Username)'
109			)
110			)
111			->addArgument(
112			new Argument(
113			static::ARGUMENT_DESCRIPTION,
114			ArgumentTypes::REQUIRED,
115			'Description'
116			)
117			)
118			->addArgument(
119			new Argument(
120			static::ARGUMENT_RESOURCES,
121			ArgumentTypes::REQUIRED,
122			'Resources (Comma separated list)'
123			)
124			)
125			->addOption(
126			new Option(
127			static::OPTION_DRY_RUN,
128			static::SHORTENED_DRY_RUN,
129			OptionTypes::OPTIONAL_VALUE,
130			'Dry run (default: 0)',
131			'0'
132			)
133			);
134			}
135
136			/**
137			* @inheritdoc
138			*/
139			protected function doExecute(IResponse $response)
140			{
141			$userIdentifier = $this->getArgumentValue(static::ARGUMENT_USER);
142
143			try {
144			$user = $this->userRepo->find($userIdentifier);
145			if (!$user) {
146			throw new \RuntimeException();
147			}
148
149			$adminResources = $this->getAdminResources($user->getId());
150
151			$rawSecret = $this->passwordGenerator->generatePassword();
152			$preparedPassword = $this->crypto->prepareSecret($rawSecret);
153			$packedPassword = $this->crypto->hashCrypt($preparedPassword);
154
155			$apiClient = $this->getApiClient($user->getId(), $packedPassword, $adminResources);
156
157			$this->apiClientRepo->add($apiClient);
158			} catch (\Exception $e) {
159			if ($e->getPrevious()) {
160			$response->writeln(sprintf('<error>%s</error>', $e->getPrevious()->getMessage()));
161			}
162			$response->writeln(sprintf('<fatal>%s</fatal>', $e->getMessage()));
163
164			return;
165			}
166
167
168			$dryRun = (bool)$this->getOptionValue(static::OPTION_DRY_RUN);
169			if ($dryRun) {
170			$this->unitOfWork->dispose();
171			$response->writeln(static::COMMAND_DRY_RUN_MESSAGE);
172
173			return;
174			}
175
176			try {
177			$this->unitOfWork->commit();
178			$this->cacheManager->clearAll();
179			} catch (\Exception $e) {
180			if ($e->getPrevious()) {
181			$response->writeln(sprintf('<error>%s</error>', $e->getPrevious()->getMessage()));
182			}
183			$response->writeln(sprintf('<fatal>%s</fatal>', $e->getMessage()));
184
185			return;
186			}
187
188			$response->writeln(sprintf(static::RESPONSE_SECRET, $rawSecret));
189			$response->writeln(sprintf(static::COMMAND_SUCCESS, $apiClient->getId()));
190			}
191
192			/**
193			* @param string $userId
194			* @param string $packedPassword
195			* @param AdminResource[] $adminResources
196			*
197			* @return ApiClient
198			* @throws \Opulence\Orm\OrmException
199			* @throws \RuntimeException
200			*/
201			protected function getApiClient(string $userId, string $packedPassword, array $adminResources): ApiClient
202			{
203			$description = $this->getArgumentValue(static::ARGUMENT_DESCRIPTION);
204			$resources = $this->getArgumentValue(static::ARGUMENT_RESOURCES);
			0 ignored issues – show Unused Code introduced 2019-06-20 20:00 UTC by Report Bug Copy Issue Report The assignment to `$resources` is dead and can be removed. Loading history...
205
206			return new ApiClient(
207			'',
208			$userId,
209			$description,
210			$packedPassword,
211			$adminResources
212			);
213			}
214
215			/**
216			* @param string $userId
217			*
218			* @return AdminResource[]
219			*/
220			protected function getAdminResources(string $userId): array
221			{
222			$resources = explode(',', $this->getArgumentValue(static::ARGUMENT_RESOURCES));
223			if (!$resources) {
			0 ignored issues – show Bug Best Practice introduced 2019-06-20 20:00 UTC by Report Bug Copy Issue Report The expression `$resources` of type `string[]` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
224			return [];
225			}
226
227			$adminResources = [];
228			foreach ($this->adminResourceRepo->getByUserId($userId) as $adminResource) {
229			if (!in_array($adminResource->getIdentifier(), $resources, true)) {
230			continue;
231			}
232
233			$adminResources[] = $adminResource;
234			}
235
236			if (count($resources) != count($adminResources)) {
237			throw new \RuntimeException('User does not have all requested resources');
238			}
239
240			return $adminResources;
241			}
242			}
243

abterphp / admin

Push — master ( 7c51ba...a22fab )

Create::getAdminResources() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like