GenerateTestUsersCommand::createGroup() - Code Metrics - Inspection of "User generator (#4181)" - zikula/core - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( 88d657...8f0691 )

by Craig

created 2020-03-24 20:39 UTC

GenerateTestUsersCommand::createGroup() A

↳ Parent: GenerateTestUsersCommand

Complexity

Conditions	2
Paths	2

Size

Total Lines	16
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	11
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	16
rs	9.9

<?php

declare(strict_types=1);

/*
 * This file is part of the Zikula package.
 *
 * Copyright Zikula Foundation - https://ziku.la/
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Zikula\Bundle\CoreBundle\Command;

use Doctrine\DBAL\Connection;
use Doctrine\DBAL\DBALException;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use Zikula\UsersModule\Constant as UsersConstant;
use Zikula\ZAuthModule\ZAuthConstant;

class GenerateTestUsersCommand extends Command
{
    /**
     * @var Connection
     */
    private $conn;

    /**
     * @var \DateTime
     */
    private $nowUTC;

    /**
     * @var \DateTime
     */
    private $startUTC;

    /**
     * @var int
     */
    private $active;

    /**
     * @var int
     */
    private $verified;

    protected static $defaultName = 'zikula:users:generate';

    public function __construct(
        Connection $connection
    ) {
        parent::__construct();
        $this->conn = $connection;
        $utcTZ = new \DateTimeZone('UTC');
        $this->nowUTC = new \DateTime('now', $utcTZ);
        $this->startUTC = new \DateTime('1970-01-01 00:00:00', $utcTZ);
    }

    protected function configure()
    {
        $this
            ->setDefinition([
                new InputArgument('amount', InputArgument::REQUIRED, 'The number of users to create'),
            ])
            ->addOption(
                'active',
                null,
                InputOption::VALUE_REQUIRED,
                'All the users are 1=active, 0=inactive, 2=random choice 0|1',
                UsersConstant::ACTIVATED_ACTIVE
            )
            ->addOption(
                'verified',
                null,
                InputOption::VALUE_REQUIRED,
                'All the user emails marked as 1=verified, 0=unverified, 2=random choice 0|1',
                1
            )
            ->setDescription('Generates users for testing purposes')
            ->setHelp(
                <<<'EOT'
The <info>%command.name%</info> command generates users in order to fill a database for testing purposes.
These users will not be able to login. The users are placed into a newly created group, not the standard users group.

<info>php %command.full_name% 1000</info>

This will generate 1000 randomly named users using all the default values.

Options:
<info>--active (-a)</info> 0|1|2 (default: 1) 1=all users active, 0=all users inactive, 2=random assignment 0|1

<info>--verified (-v)</info> 0|1|2 (default: 1) 1=all user emails verified, 0=all user emails unverified, 2=random assignment 0|1

<info>php %command.full_name% 1000 --active=0 --verified=2</info>

EOT
            );
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = new SymfonyStyle($input, $output);
        $amount = (int) abs($input->getArgument('amount'));
        $key = bin2hex(random_bytes(3));
        $groupId = $this->createGroup($key);
        $divisor = (int) ceil($amount / 100);
        $this->active = in_array((int) $input->getOption('active'), [0, 1, 2]) ? (int) $input->getOption('active') : UsersConstant::ACTIVATED_ACTIVE;
        $this->verified = in_array((int) $input->getOption('verified'), [0, 1, 2]) ? (int) $input->getOption('verified') : 1;

        $io->title('User generation utility');
        $io->text('Generating users...');
        $io->progressStart($amount);

        for ($i = 1; $i <= $amount; $i++) {
            $uname = 'user' . $key . $i;
            $this->insertUser($uname);
            $uid = (int) $this->conn->lastInsertId();
            $this->insertAttributes($uid);
            $this->insertMapping($uid, $uname);
            $this->insertGroup($uid, $groupId);
            if (0 === $i % $divisor) {
                $io->progressAdvance((int) ceil($amount / $divisor));
            }
        }

        $io->progressFinish();
        $io->success('User generation complete!');
        $io->text(sprintf('%d users created (group name: <info>group%s</info>).', $amount, $key));

        return 0;
    }

    private function insertUser(string $uname): void
    {
        $types = [\PDO::PARAM_STR, \PDO::PARAM_STR, \PDO::PARAM_INT, 'datetime', \PDO::PARAM_INT, 'datetime', 'datetime', \PDO::PARAM_STR, \PDO::PARAM_STR];
        try {
            $this->conn->insert('users', [
                'uname' => $uname,
                'email' => $uname . '@example.com',
                'activated' => 2 === $this->active ? random_int(0, 1) : $this->active,
                'approved_date' => $this->nowUTC,
                'approved_by' => 2,
                'user_regdate' => $this->nowUTC,
                'lastlogin' => $this->startUTC,
                'tz' => '',
                'locale' => ''
            ], $types);
        } catch (DBALException $exception) {
            // do nothing?
        }
    }

    private function insertAttributes(int $uid): void
    {
        $types = [\PDO::PARAM_STR, \PDO::PARAM_INT, \PDO::PARAM_STR];
        try {
            $this->conn->insert('users_attributes', [
                'name' => UsersConstant::AUTHENTICATION_METHOD_ATTRIBUTE_KEY,
                'user_id' => $uid,
                'value' => ZAuthConstant::AUTHENTICATION_METHOD_EITHER,
            ], $types);
        } catch (DBALException $exception) {
            // do nothing?
        }
    }

    private function insertMapping(int $uid, string $uname): void
    {
        $types = [\PDO::PARAM_STR, \PDO::PARAM_INT, \PDO::PARAM_STR, \PDO::PARAM_STR, \PDO::PARAM_INT, \PDO::PARAM_STR];
        try {
            $this->conn->insert('zauth_authentication_mapping', [
                'method' => ZAuthConstant::AUTHENTICATION_METHOD_EITHER,
                'uid' => $uid,
                'uname' => $uname,
                'email' => $uname . '@example.com',
                'verifiedEmail' => 2 === $this->verified ? random_int(0, 1) : $this->verified,
                'pass' => '',
            ], $types);
        } catch (DBALException $exception) {
            // do nothing?
        }
    }

    private function createGroup(string $key): int
    {
        $types = [\PDO::PARAM_STR, \PDO::PARAM_INT, \PDO::PARAM_STR, \PDO::PARAM_INT, \PDO::PARAM_INT];
        try {
            $this->conn->insert('groups', [
                'name' => 'group' . $key,
                'gtype' => 0,
                'description' => 'temp group for testing',
                'state' => 0,
                'nbumax' => 0,
            ], $types);
        } catch (DBALException $exception) {
            // do nothing?
        }

        return (int) $this->conn->lastInsertId();
    }

    private function insertGroup(int $uid, int $gid): void
    {
        $types = [\PDO::PARAM_INT, \PDO::PARAM_INT];
        try {
            $this->conn->insert('group_membership', [
                'uid' => $uid,
                'gid' => $gid,
            ], $types);
        } catch (DBALException $exception) {
            // do nothing?
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Zikula package.
7			*
8			* Copyright Zikula Foundation - https://ziku.la/
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Zikula\Bundle\CoreBundle\Command;
15
16			use Doctrine\DBAL\Connection;
17			use Doctrine\DBAL\DBALException;
18			use Symfony\Component\Console\Command\Command;
19			use Symfony\Component\Console\Input\InputArgument;
20			use Symfony\Component\Console\Input\InputInterface;
21			use Symfony\Component\Console\Input\InputOption;
22			use Symfony\Component\Console\Output\OutputInterface;
23			use Symfony\Component\Console\Style\SymfonyStyle;
24			use Zikula\UsersModule\Constant as UsersConstant;
25			use Zikula\ZAuthModule\ZAuthConstant;
26
27			class GenerateTestUsersCommand extends Command
28			{
29			/**
30			* @var Connection
31			*/
32			private $conn;
33
34			/**
35			* @var \DateTime
36			*/
37			private $nowUTC;
38
39			/**
40			* @var \DateTime
41			*/
42			private $startUTC;
43
44			/**
45			* @var int
46			*/
47			private $active;
48
49			/**
50			* @var int
51			*/
52			private $verified;
53
54			protected static $defaultName = 'zikula:users:generate';
55
56			public function __construct(
57			Connection $connection
58			) {
59			parent::__construct();
60			$this->conn = $connection;
61			$utcTZ = new \DateTimeZone('UTC');
62			$this->nowUTC = new \DateTime('now', $utcTZ);
63			$this->startUTC = new \DateTime('1970-01-01 00:00:00', $utcTZ);
64			}
65
66			protected function configure()
67			{
68			$this
69			->setDefinition([
70			new InputArgument('amount', InputArgument::REQUIRED, 'The number of users to create'),
71			])
72			->addOption(
73			'active',
74			null,
75			InputOption::VALUE_REQUIRED,
76			'All the users are 1=active, 0=inactive, 2=random choice 0\|1',
77			UsersConstant::ACTIVATED_ACTIVE
78			)
79			->addOption(
80			'verified',
81			null,
82			InputOption::VALUE_REQUIRED,
83			'All the user emails marked as 1=verified, 0=unverified, 2=random choice 0\|1',
84			1
85			)
86			->setDescription('Generates users for testing purposes')
87			->setHelp(
88			<<<'EOT'
89			The <info>%command.name%</info> command generates users in order to fill a database for testing purposes.
90			These users will not be able to login. The users are placed into a newly created group, not the standard users group.
91
92			<info>php %command.full_name% 1000</info>
93
94			This will generate 1000 randomly named users using all the default values.
95
96			Options:
97			<info>--active (-a)</info> 0\|1\|2 (default: 1) 1=all users active, 0=all users inactive, 2=random assignment 0\|1
98
99			<info>--verified (-v)</info> 0\|1\|2 (default: 1) 1=all user emails verified, 0=all user emails unverified, 2=random assignment 0\|1
100
101			<info>php %command.full_name% 1000 --active=0 --verified=2</info>
102
103			EOT
104			);
105			}
106
107			protected function execute(InputInterface $input, OutputInterface $output): int
108			{
109			$io = new SymfonyStyle($input, $output);
110			$amount = (int) abs($input->getArgument('amount'));
111			$key = bin2hex(random_bytes(3));
112			$groupId = $this->createGroup($key);
113			$divisor = (int) ceil($amount / 100);
114			$this->active = in_array((int) $input->getOption('active'), [0, 1, 2]) ? (int) $input->getOption('active') : UsersConstant::ACTIVATED_ACTIVE;
115			$this->verified = in_array((int) $input->getOption('verified'), [0, 1, 2]) ? (int) $input->getOption('verified') : 1;
116
117			$io->title('User generation utility');
118			$io->text('Generating users...');
119			$io->progressStart($amount);
120
121			for ($i = 1; $i <= $amount; $i++) {
122			$uname = 'user' . $key . $i;
123			$this->insertUser($uname);
124			$uid = (int) $this->conn->lastInsertId();
125			$this->insertAttributes($uid);
126			$this->insertMapping($uid, $uname);
127			$this->insertGroup($uid, $groupId);
128			if (0 === $i % $divisor) {
129			$io->progressAdvance((int) ceil($amount / $divisor));
130			}
131			}
132
133			$io->progressFinish();
134			$io->success('User generation complete!');
135			$io->text(sprintf('%d users created (group name: <info>group%s</info>).', $amount, $key));
136
137			return 0;
138			}
139
140			private function insertUser(string $uname): void
141			{
142			$types = [\PDO::PARAM_STR, \PDO::PARAM_STR, \PDO::PARAM_INT, 'datetime', \PDO::PARAM_INT, 'datetime', 'datetime', \PDO::PARAM_STR, \PDO::PARAM_STR];
143			try {
144			$this->conn->insert('users', [
145			'uname' => $uname,
146			'email' => $uname . '@example.com',
147			'activated' => 2 === $this->active ? random_int(0, 1) : $this->active,
148			'approved_date' => $this->nowUTC,
149			'approved_by' => 2,
150			'user_regdate' => $this->nowUTC,
151			'lastlogin' => $this->startUTC,
152			'tz' => '',
153			'locale' => ''
154			], $types);
155			} catch (DBALException $exception) {
156			// do nothing?
157			}
158			}
159
160			private function insertAttributes(int $uid): void
161			{
162			$types = [\PDO::PARAM_STR, \PDO::PARAM_INT, \PDO::PARAM_STR];
163			try {
164			$this->conn->insert('users_attributes', [
165			'name' => UsersConstant::AUTHENTICATION_METHOD_ATTRIBUTE_KEY,
166			'user_id' => $uid,
167			'value' => ZAuthConstant::AUTHENTICATION_METHOD_EITHER,
168			], $types);
169			} catch (DBALException $exception) {
170			// do nothing?
171			}
172			}
173
174			private function insertMapping(int $uid, string $uname): void
175			{
176			$types = [\PDO::PARAM_STR, \PDO::PARAM_INT, \PDO::PARAM_STR, \PDO::PARAM_STR, \PDO::PARAM_INT, \PDO::PARAM_STR];
177			try {
178			$this->conn->insert('zauth_authentication_mapping', [
179			'method' => ZAuthConstant::AUTHENTICATION_METHOD_EITHER,
180			'uid' => $uid,
181			'uname' => $uname,
182			'email' => $uname . '@example.com',
183			'verifiedEmail' => 2 === $this->verified ? random_int(0, 1) : $this->verified,
184			'pass' => '',
185			], $types);
186			} catch (DBALException $exception) {
187			// do nothing?
188			}
189			}
190
191			private function createGroup(string $key): int
192			{
193			$types = [\PDO::PARAM_STR, \PDO::PARAM_INT, \PDO::PARAM_STR, \PDO::PARAM_INT, \PDO::PARAM_INT];
194			try {
195			$this->conn->insert('groups', [
196			'name' => 'group' . $key,
197			'gtype' => 0,
198			'description' => 'temp group for testing',
199			'state' => 0,
200			'nbumax' => 0,
201			], $types);
202			} catch (DBALException $exception) {
203			// do nothing?
204			}
205
206			return (int) $this->conn->lastInsertId();
207			}
208
209			private function insertGroup(int $uid, int $gid): void
210			{
211			$types = [\PDO::PARAM_INT, \PDO::PARAM_INT];
212			try {
213			$this->conn->insert('group_membership', [
214			'uid' => $uid,
215			'gid' => $gid,
216			], $types);
217			} catch (DBALException $exception) {
218			// do nothing?
219			}
220			}
221			}
222

zikula / core

Push — master ( 88d657...8f0691 )

GenerateTestUsersCommand::createGroup() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like