SetupCommand::getAdministratorUsername() - Code Metrics - Inspection of "Merge pull request #8798 from GSadee/installation" - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 90fa2c...b55ca8 )

by Kamil

created 2017-10-11 09:20 UTC

SetupCommand::getAdministratorUsername() A

↳ Parent: SetupCommand

Complexity

Conditions	3
Paths	2

Size

Total Lines	19
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	19
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	11
nc	2
nop	3

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Sylius\Bundle\CoreBundle\Command;

use Sylius\Component\Core\Model\AdminUserInterface;
use Sylius\Component\User\Repository\UserRepositoryInterface;
use Symfony\Component\Console\Helper\QuestionHelper;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Question\Question;
use Symfony\Component\Console\Style\SymfonyStyle;
use Symfony\Component\Validator\Constraints\Email;
use Symfony\Component\Validator\Constraints\NotBlank;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Webmozart\Assert\Assert;

/**
 * @author Paweł Jędrzejewski <[email protected]>
 */
final class SetupCommand extends AbstractInstallCommand
{
    /**
     * {@inheritdoc}
     */
    protected function configure(): void
    {
        $this
            ->setName('sylius:install:setup')
            ->setDescription('Sylius configuration setup.')
            ->setHelp(<<<EOT
The <info>%command.name%</info> command allows user to configure basic Sylius data.
EOT
            )
        ;
    }

    /**
     * {@inheritdoc}
     */
    protected function execute(InputInterface $input, OutputInterface $output): void
    {
        $currency = $this->get('sylius.setup.currency')->setup($input, $output, $this->getHelper('question'));
        $locale = $this->get('sylius.setup.locale')->setup($input, $output);
        $this->get('sylius.setup.channel')->setup($locale, $currency);
        $this->setupAdministratorUser($input, $output, $locale->getCode());
    }

    /**
     * @param InputInterface $input
     * @param OutputInterface $output
     * @param string $localeCode
     */
    protected function setupAdministratorUser(InputInterface $input, OutputInterface $output, string $localeCode): void
    {
        $outputStyle = new SymfonyStyle($input, $output);
        $outputStyle->writeln('Create your administrator account.');

        $userManager = $this->get('sylius.manager.admin_user');
        $userFactory = $this->get('sylius.factory.admin_user');

        try {
            $user = $this->configureNewUser($userFactory->createNew(), $input, $output);
        } catch (\InvalidArgumentException $exception) {
            return;
        }

        $user->setEnabled(true);
        $user->setLocaleCode($localeCode);

        $userManager->persist($user);
        $userManager->flush();

        $outputStyle->writeln('<info>Administrator account successfully registered.</info>');
        $outputStyle->newLine();
    }

    /**
     * @param AdminUserInterface $user
     * @param InputInterface $input
     * @param OutputInterface $output
     *
     * @return AdminUserInterface
     */
    private function configureNewUser(
        AdminUserInterface $user,
        InputInterface $input,
        OutputInterface $output
    ): AdminUserInterface {
        /** @var UserRepositoryInterface $userRepository */
        $userRepository = $this->getAdminUserRepository();

        if ($input->getOption('no-interaction')) {
            Assert::null($userRepository->findOneByEmail('[email protected]'));

            $user->setEmail('[email protected]');
            $user->setUsername('sylius');
            $user->setPlainPassword('sylius');

            return $user;
        }

        $email = $this->getAdministratorEmail($input, $output);
        $user->setEmail($email);
        $user->setUsername($this->getAdministratorUsername($input, $output, $email));
        $user->setPlainPassword($this->getAdministratorPassword($input, $output));

        return $user;
    }

    /**
     * @param OutputInterface $output
     *
     * @return Question
     */
    private function createEmailQuestion(OutputInterface $output): Question
    {
        return (new Question('E-mail: '))
            ->setValidator(function ($value) use ($output) {
                /** @var ConstraintViolationListInterface $errors */
                $errors = $this->get('validator')->validate((string) $value, [new Email(), new NotBlank()]);
                foreach ($errors as $error) {
                    throw new \DomainException($error->getMessage());
                }

                return $value;
            })
            ->setMaxAttempts(3)
        ;
    }

    /**
     * @param InputInterface $input
     * @param OutputInterface $output
     *
     * @return string
     */
    private function getAdministratorEmail(InputInterface $input, OutputInterface $output): string
    {
        /** @var QuestionHelper $questionHelper */
        $questionHelper = $this->getHelper('question');
        /** @var UserRepositoryInterface $userRepository */
        $userRepository = $this->getAdminUserRepository();

        do {
            $question = $this->createEmailQuestion($output);
            $email = $questionHelper->ask($input, $output, $question);
            $exists = null !== $userRepository->findOneByEmail($email);

            if ($exists) {
                $output->writeln('<error>E-Mail is already in use!</error>');
            }
        } while ($exists);

        return $email;
    }

    /**
     * @param InputInterface $input
     * @param OutputInterface $output
     * @param string $email
     *
     * @return string
     */
    private function getAdministratorUsername(InputInterface $input, OutputInterface $output, string $email): string
    {
        /** @var QuestionHelper $questionHelper */
        $questionHelper = $this->getHelper('question');
        /** @var UserRepositoryInterface $userRepository */
        $userRepository = $this->getAdminUserRepository();

        do {
            $question = new Question('Username (press enter to use email): ', $email);
            $username = $questionHelper->ask($input, $output, $question);
            $exists = null !== $userRepository->findOneBy(['username' => $username]);

            if ($exists) {
                $output->writeln('<error>Username is already in use!</error>');
            }
        } while ($exists);

        return $username;
    }

    /**
     * @param InputInterface $input
     * @param OutputInterface $output
     *
     * @return mixed
     */
    private function getAdministratorPassword(InputInterface $input, OutputInterface $output)
    {
        /** @var QuestionHelper $questionHelper */
        $questionHelper = $this->getHelper('question');
        $validator = $this->getPasswordQuestionValidator($output);

        do {
            $passwordQuestion = $this->createPasswordQuestion('Choose password:', $validator);
            $confirmPasswordQuestion = $this->createPasswordQuestion('Confirm password:', $validator);

            $password = $questionHelper->ask($input, $output, $passwordQuestion);
            $repeatedPassword = $questionHelper->ask($input, $output, $confirmPasswordQuestion);

            if ($repeatedPassword !== $password) {
                $output->writeln('<error>Passwords do not match!</error>');
            }
        } while ($repeatedPassword !== $password);

        return $password;
    }

    /**
     * @param OutputInterface $output
     *
     * @return \Closure
     *
     * @throws \DomainException
     */
    private function getPasswordQuestionValidator(OutputInterface $output): \Closure
    {
        return function ($value) use ($output) {
            /** @var ConstraintViolationListInterface $errors */
            $errors = $this->get('validator')->validate($value, [new NotBlank()]);
            foreach ($errors as $error) {
                throw new \DomainException($error->getMessage());
            }

            return $value;
        };
    }

    /**
     * @param string $message
     * @param \Closure $validator
     *
     * @return Question
     */
    private function createPasswordQuestion(string $message, \Closure $validator): Question
    {
        return (new Question($message))
            ->setValidator($validator)
            ->setMaxAttempts(3)
            ->setHidden(true)
            ->setHiddenFallback(false)
        ;
    }

    /**
     * @return UserRepositoryInterface
     */
    private function getAdminUserRepository(): UserRepositoryInterface
    {
        return $this->get('sylius.repository.admin_user');
    }
}


1			<?php
2
3			/*
4			* This file is part of the Sylius package.
5			*
6			* (c) Paweł Jędrzejewski
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			declare(strict_types=1);
13
14			namespace Sylius\Bundle\CoreBundle\Command;
15
16			use Sylius\Component\Core\Model\AdminUserInterface;
17			use Sylius\Component\User\Repository\UserRepositoryInterface;
18			use Symfony\Component\Console\Helper\QuestionHelper;
19			use Symfony\Component\Console\Input\InputInterface;
20			use Symfony\Component\Console\Output\OutputInterface;
21			use Symfony\Component\Console\Question\Question;
22			use Symfony\Component\Console\Style\SymfonyStyle;
23			use Symfony\Component\Validator\Constraints\Email;
24			use Symfony\Component\Validator\Constraints\NotBlank;
25			use Symfony\Component\Validator\ConstraintViolationListInterface;
26			use Webmozart\Assert\Assert;
27
28			/**
29			* @author Paweł Jędrzejewski <[email protected]>
30			*/
31			final class SetupCommand extends AbstractInstallCommand
32			{
33			/**
34			* {@inheritdoc}
35			*/
36			protected function configure(): void
37			{
38			$this
39			->setName('sylius:install:setup')
40			->setDescription('Sylius configuration setup.')
41			->setHelp(<<<EOT
42			The <info>%command.name%</info> command allows user to configure basic Sylius data.
43			EOT
44			)
45			;
46			}
47
48			/**
49			* {@inheritdoc}
50			*/
51			protected function execute(InputInterface $input, OutputInterface $output): void
52			{
53			$currency = $this->get('sylius.setup.currency')->setup($input, $output, $this->getHelper('question'));
54			$locale = $this->get('sylius.setup.locale')->setup($input, $output);
55			$this->get('sylius.setup.channel')->setup($locale, $currency);
56			$this->setupAdministratorUser($input, $output, $locale->getCode());
57			}
58
59			/**
60			* @param InputInterface $input
61			* @param OutputInterface $output
62			* @param string $localeCode
63			*/
64			protected function setupAdministratorUser(InputInterface $input, OutputInterface $output, string $localeCode): void
65			{
66			$outputStyle = new SymfonyStyle($input, $output);
67			$outputStyle->writeln('Create your administrator account.');
68
69			$userManager = $this->get('sylius.manager.admin_user');
70			$userFactory = $this->get('sylius.factory.admin_user');
71
72			try {
73			$user = $this->configureNewUser($userFactory->createNew(), $input, $output);
74			} catch (\InvalidArgumentException $exception) {
75			return;
76			}
77
78			$user->setEnabled(true);
79			$user->setLocaleCode($localeCode);
80
81			$userManager->persist($user);
82			$userManager->flush();
83
84			$outputStyle->writeln('<info>Administrator account successfully registered.</info>');
85			$outputStyle->newLine();
86			}
87
88			/**
89			* @param AdminUserInterface $user
90			* @param InputInterface $input
91			* @param OutputInterface $output
92			*
93			* @return AdminUserInterface
94			*/
95			private function configureNewUser(
96			AdminUserInterface $user,
97			InputInterface $input,
98			OutputInterface $output
99			): AdminUserInterface {
100			/** @var UserRepositoryInterface $userRepository */
101			$userRepository = $this->getAdminUserRepository();
102
103			if ($input->getOption('no-interaction')) {
104			Assert::null($userRepository->findOneByEmail('[email protected]'));
105
106			$user->setEmail('[email protected]');
107			$user->setUsername('sylius');
108			$user->setPlainPassword('sylius');
109
110			return $user;
111			}
112
113			$email = $this->getAdministratorEmail($input, $output);
114			$user->setEmail($email);
115			$user->setUsername($this->getAdministratorUsername($input, $output, $email));
116			$user->setPlainPassword($this->getAdministratorPassword($input, $output));
117
118			return $user;
119			}
120
121			/**
122			* @param OutputInterface $output
123			*
124			* @return Question
125			*/
126			private function createEmailQuestion(OutputInterface $output): Question
127			{
128			return (new Question('E-mail: '))
129			->setValidator(function ($value) use ($output) {
130			/** @var ConstraintViolationListInterface $errors */
131			$errors = $this->get('validator')->validate((string) $value, [new Email(), new NotBlank()]);
132			foreach ($errors as $error) {
133			throw new \DomainException($error->getMessage());
134			}
135
136			return $value;
137			})
138			->setMaxAttempts(3)
139			;
140			}
141
142			/**
143			* @param InputInterface $input
144			* @param OutputInterface $output
145			*
146			* @return string
147			*/
148			private function getAdministratorEmail(InputInterface $input, OutputInterface $output): string
149			{
150			/** @var QuestionHelper $questionHelper */
151			$questionHelper = $this->getHelper('question');
152			/** @var UserRepositoryInterface $userRepository */
153			$userRepository = $this->getAdminUserRepository();
154
155			do {
156			$question = $this->createEmailQuestion($output);
157			$email = $questionHelper->ask($input, $output, $question);
158			$exists = null !== $userRepository->findOneByEmail($email);
159
160			if ($exists) {
161			$output->writeln('<error>E-Mail is already in use!</error>');
162			}
163			} while ($exists);
164
165			return $email;
166			}
167
168			/**
169			* @param InputInterface $input
170			* @param OutputInterface $output
171			* @param string $email
172			*
173			* @return string
174			*/
175			private function getAdministratorUsername(InputInterface $input, OutputInterface $output, string $email): string
176			{
177			/** @var QuestionHelper $questionHelper */
178			$questionHelper = $this->getHelper('question');
179			/** @var UserRepositoryInterface $userRepository */
180			$userRepository = $this->getAdminUserRepository();
181
182			do {
183			$question = new Question('Username (press enter to use email): ', $email);
184			$username = $questionHelper->ask($input, $output, $question);
185			$exists = null !== $userRepository->findOneBy(['username' => $username]);
186
187			if ($exists) {
188			$output->writeln('<error>Username is already in use!</error>');
189			}
190			} while ($exists);
191
192			return $username;
193			}
194
195			/**
196			* @param InputInterface $input
197			* @param OutputInterface $output
198			*
199			* @return mixed
200			*/
201			private function getAdministratorPassword(InputInterface $input, OutputInterface $output)
202			{
203			/** @var QuestionHelper $questionHelper */
204			$questionHelper = $this->getHelper('question');
205			$validator = $this->getPasswordQuestionValidator($output);
206
207			do {
208			$passwordQuestion = $this->createPasswordQuestion('Choose password:', $validator);
209			$confirmPasswordQuestion = $this->createPasswordQuestion('Confirm password:', $validator);
210
211			$password = $questionHelper->ask($input, $output, $passwordQuestion);
212			$repeatedPassword = $questionHelper->ask($input, $output, $confirmPasswordQuestion);
213
214			if ($repeatedPassword !== $password) {
215			$output->writeln('<error>Passwords do not match!</error>');
216			}
217			} while ($repeatedPassword !== $password);
218
219			return $password;
220			}
221
222			/**
223			* @param OutputInterface $output
224			*
225			* @return \Closure
226			*
227			* @throws \DomainException
228			*/
229			private function getPasswordQuestionValidator(OutputInterface $output): \Closure
230			{
231			return function ($value) use ($output) {
232			/** @var ConstraintViolationListInterface $errors */
233			$errors = $this->get('validator')->validate($value, [new NotBlank()]);
234			foreach ($errors as $error) {
235			throw new \DomainException($error->getMessage());
236			}
237
238			return $value;
239			};
240			}
241
242			/**
243			* @param string $message
244			* @param \Closure $validator
245			*
246			* @return Question
247			*/
248			private function createPasswordQuestion(string $message, \Closure $validator): Question
249			{
250			return (new Question($message))
251			->setValidator($validator)
252			->setMaxAttempts(3)
253			->setHidden(true)
254			->setHiddenFallback(false)
255			;
256			}
257
258			/**
259			* @return UserRepositoryInterface
260			*/
261			private function getAdminUserRepository(): UserRepositoryInterface
262			{
263			return $this->get('sylius.repository.admin_user');
264			}
265			}
266

pamil / Sylius

Push — master ( 90fa2c...b55ca8 )

SetupCommand::getAdministratorUsername() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like