Auth::isValidRegistration() - Code Metrics - Inspection of "feature/nymfonya : auth controller login use Auth..." - pierre-fromager/nymfonya - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 67ae16...651a4a )

by Pierre

created 2019-12-21 20:00 UTC

Auth::isValidRegistration() A

↳ Parent: Auth

Complexity

Conditions	4
Paths	6

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes

Metric	Value
cc	4
eloc	3
nc	6
nop	3
dl	0
loc	5
ccs	0
cts	0
cp	0
crap	20
rs	10
c	0
b	0
f	0

<?php

namespace App\Controllers\Api\V1;

use App\Interfaces\Controllers\IApi;
use App\Reuse\Controllers\AbstractApi;
use Nymfonya\Component\Config;
use Nymfonya\Component\Container;
use Nymfonya\Component\Http\Headers;
use Nymfonya\Component\Http\Request;
use Nymfonya\Component\Http\Response;
use App\Component\Db\Core;
use App\Model\Repository\Users;
use App\Component\Jwt\Token;
use App\Component\Auth\Factory;
use App\Component\Crypt;

final class Auth extends AbstractApi implements IApi
{

    /**
     * core db instance
     *
     * @var Core
     */
    protected $db;

    /**
     * user repository
     *
     * @var UserRepository
filter:
    dependency_paths: ["lib/*"]
     */
    protected $userRepository;

    /**
     * slugs
     *
     * @var array
     */
    protected $slugs;

    /**
     * sql
     *
     * @var String
     */
    protected $sql;

    /**
     * sql values to bind statement
     *
     * @var array
     */
    protected $bindValues;

    /**
     * error
     *
     * @var Boolean
     */
    protected $error;

    /**
     * error message
     *
     * @var String
     */
    protected $errorMessage;

    /**
     * instanciate
     *
     * @param Container $container
     */
    public function __construct(Container $container)
    {
        $this->userRepository = new Users($container);

        $this->db = new Core($container);
        $this->db->fromOrm($this->userRepository);
        $this->error = false;
        $this->errorMessage = '';
        parent::__construct($container);
    }

    /**
     * login action
     *
     * @Role anonymous
     * @return Auth
     */
    final public function login(): Auth
    {
        $config = $this->getService(Config::class);
        $logger = $this->getService(\Monolog\Logger::class);
        $login = filter_var($this->request->getParam('login'), FILTER_SANITIZE_EMAIL);
        $password = filter_var($this->request->getParam('password'), FILTER_SANITIZE_STRING);
        if (false === $this->isValidLogin($login, $password)) {
            $logger->warning(__FUNCTION__ . ' Invalid arguments');
            return $this->setErrorResponse(
                Response::HTTP_BAD_REQUEST,
                'Invalid arguments'
            );
        }
        $authFactory = new Factory($this->getContainer());
        $authFactory->setAdapter();
        if ($user = $authFactory->auth($login, $password)) {
            $jwtToken = new Token($config, $this->request);
            $token = $jwtToken
                ->setIssueAt(time())
                ->setIssueAtDelay(0)
                ->setTtl(1200)
                ->encode(
                    $user[Factory::_ID],
                    $user[Factory::_EMAIL],
                    $user[Factory::_PASSWORD]
                );
            $logger->info(__FUNCTION__ . ' Auth succeed');
            $this->response
                ->setCode(Response::HTTP_OK)
                ->setContent(
                    [Response::_ERROR => false, 'token' => $token]
                );
            return $this;
        }
        $logger->warning(__FUNCTION__ . ' Auth failed');
        unset($authFactory);
        return $this->setErrorResponse(
            Response::HTTP_UNAUTHORIZED,
            'Bad credentials'
        );
    }

    /**
     * register action
     *
     * @Role anonymous
     * @return Auth
     */
    final public function register(): Auth
    {
        $config = $this->getService(Config::class);
        $logger = $this->getService(\Monolog\Logger::class);
        $name = filter_var($this->request->getParam('name'), FILTER_SANITIZE_STRING);
        $email = filter_var($this->request->getParam('email'), FILTER_SANITIZE_EMAIL);
        $password = filter_var($this->request->getParam('password'), FILTER_SANITIZE_STRING);
        if (false === $this->isValidRegistration($name, $email, $password)) {
            $this->error = true;
            $this->errorMessage = 'Invalid arguments';
            $logger->warning(__FUNCTION__ . ' Invalid arguments');
            return $this->setRegistrationResponse(__CLASS__, __FUNCTION__);
        }
        $this->userRepository->emailExists($email);
        $this->sql = $this->userRepository->getSql();
        $this->bindValues = $this->userRepository->getBuilderValues();
        $this->db->run($this->sql, $this->bindValues)->hydrate();
        $emailCount = $this->db->getRowset();
        $emailCounter = (int) $emailCount[0]['counter'];
        if ($emailCounter !== 0) {
            $this->error = true;
            $this->errorMessage = 'Email exists';
            $logger->warning(__FUNCTION__ . $this->errorMessage);
            return $this->setRegistrationResponse(__CLASS__, __FUNCTION__);
        }
        $cryptEngine = new Crypt($config);
        $cryptedPassword = $cryptEngine->encrypt($password);
        unset($cryptEngine);
        $this->userRepository->register($name, $email, $cryptedPassword);
        $this->sql = $this->userRepository->getSql();
        $this->bindValues = $this->userRepository->getBuilderValues();
        $this->db->run($this->sql, $this->bindValues);
        return $this->setRegistrationResponse(__CLASS__, __FUNCTION__);
    }

    /**
     * return true if request methods are allowed
     *
     * @return boolean
     */
    protected function isLoginMethodAllowed(): bool
    {
        return in_array(
            $this->request->getMethod(),
            [Request::METHOD_POST, Request::METHOD_TRACE]
        );
    }

    /**
     * return true if login action can be executed
     *
     * @param string $login
     * @param string $password
     * @return boolean
     */
    protected function isValidLogin(string $login, string $password): bool
    {
        return $this->isLoginMethodAllowed()
            && !empty($login)
            && !empty($password);
    }

    /**
     * return true if registration process can be executed
     *
     * @param string $login
     * @param string $password
     * @return boolean
     */
    protected function isValidRegistration(string $name, string $email, string $password): bool
    {
        $notEmpty = (!empty($name) && !empty($email) && !empty($password));
        $isMethodAllow = $this->request->getMethod() === Request::METHOD_POST;
        return $notEmpty && $isMethodAllow;
    }

    /**
     * return Auth and set response with http code and message
     *
     * @param integer $code
     * @param string $msg
     * @return Auth
     */
    protected function setErrorResponse(int $code, string $msg): Auth
    {
        $this->response
            ->setCode($code)
            ->setContent([
                Response::_ERROR => true,
                Response::_ERROR_CODE => $code,
                Response::_ERROR_MSG => $msg
            ])->getHeaderManager()->add(
                Headers::CONTENT_TYPE,
                'application/json'
            );
        return $this;
    }

    /**
     * set response with for a classname and action
     *
     * @param string $classname
     * @param string $action
     * @return Auth
     */
    protected function setRegistrationResponse(string $classname, string $action): Auth
    {
        $isError = $this->isError();
        $this->response
            ->setCode($this->getStatusCode())
            ->setContent(
                [
                    'error' => $this->error,
                    'errorMessage' => $this->errorMessage,
                    'datas' => [
                        'method' => $this->getRequest()->getMethod(),
                        'params' => $this->getParams(),
                        'controller' => $classname,
                        'action' => $action,
                        'query' => $isError
                            ? ''
                            : $this->sql,
                        'queryValues' => $isError
                            ? [] : $this->bindValues,
                        'rowset' => $isError
                            ? []
                            : $this->db->getRowset()
                    ]
                ]
            );
        return $this;
    }

    /**
     * returns true if error happened
     *
     * @return boolean
     */
    protected function isError(): bool
    {
        return $this->error === true;
    }

    /**
     * returns http status code
     *
     * @return int
     */
    protected function getStatusCode(): int
    {
        return (true === $this->isError())
            ? Response::HTTP_BAD_REQUEST
            : Response::HTTP_OK;
    }
}


1		<?php
2
3		namespace App\Controllers\Api\V1;
4
5		use App\Interfaces\Controllers\IApi;
6		use App\Reuse\Controllers\AbstractApi;
7		use Nymfonya\Component\Config;
8		use Nymfonya\Component\Container;
9		use Nymfonya\Component\Http\Headers;
10		use Nymfonya\Component\Http\Request;
11		use Nymfonya\Component\Http\Response;
12		use App\Component\Db\Core;
13		use App\Model\Repository\Users;
14		use App\Component\Jwt\Token;
15		use App\Component\Auth\Factory;
16		use App\Component\Crypt;
17
18		final class Auth extends AbstractApi implements IApi
19		{
20
21		/**
22		* core db instance
23	7	*
24		* @var Core
25	7	*/
26		protected $db;
27
28		/**
29		* user repository
30		*
31		* @var UserRepository
		0 ignored issues – show Bug introduced 2019-12-21 20:03 UTC by Report Bug Copy Issue Report The type `App\Controllers\Api\V1\UserRepository` 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...
32		*/
33		protected $userRepository;
34	3
35		/**
36	3	* slugs
37	3	*
38	3	* @var array
39	3	*/
40	3	protected $slugs;
41	1
42	1	/**
43	1	* sql
44	1	*
45		* @var String
46		*/
47	2	protected $sql;
48	2
49	1	/**
50		* sql values to bind statement
51	1	*
52	1	* @var array
53	1	*/
54	1	protected $bindValues;
55	1
56	1	/**
57	1	* error
58		*
59	1	* @var Boolean
60	1	*/
61	1	protected $error;
62	1
63	1	/**
64		* error message
65	1	*
66		* @var String
67	1	*/
68	1	protected $errorMessage;
69	1
70	1	/**
71		* instanciate
72		*
73		* @param Container $container
74		*/
75		public function __construct(Container $container)
76		{
77		$this->userRepository = new Users($container);
		0 ignored issues – show Documentation Bug introduced 2019-12-21 20:03 UTC by Report Bug Copy Issue Report It seems like `new App\Model\Repository\Users($container)` of type `App\Model\Repository\Users` is incompatible with the declared type `App\Controllers\Api\V1\UserRepository` of property `$userRepository`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
78		$this->db = new Core($container);
79	1	$this->db->fromOrm($this->userRepository);
80		$this->error = false;
81	1	$this->errorMessage = '';
82	1	parent::__construct($container);
83	1	}
84
85		/**
86		* login action
87		*
88		* @Role anonymous
89		* @return Auth
90		*/
91		final public function login(): Auth
92		{
93		$config = $this->getService(Config::class);
94	1	$logger = $this->getService(\Monolog\Logger::class);
95		$login = filter_var($this->request->getParam('login'), FILTER_SANITIZE_EMAIL);
96	1	$password = filter_var($this->request->getParam('password'), FILTER_SANITIZE_STRING);
97	1	if (false === $this->isValidLogin($login, $password)) {
98	1	$logger->warning(__FUNCTION__ . ' Invalid arguments');
99		return $this->setErrorResponse(
100		Response::HTTP_BAD_REQUEST,
101		'Invalid arguments'
102		);
103		}
104		$authFactory = new Factory($this->getContainer());
105		$authFactory->setAdapter();
106		if ($user = $authFactory->auth($login, $password)) {
107		$jwtToken = new Token($config, $this->request);
108	1	$token = $jwtToken
109		->setIssueAt(time())
110	1	->setIssueAtDelay(0)
111	1	->setTtl(1200)
112	1	->encode(
113	1	$user[Factory::_ID],
114	1	$user[Factory::_EMAIL],
115	1	$user[Factory::_PASSWORD]
116	1	);
117	1	$logger->info(__FUNCTION__ . ' Auth succeed');
118	1	$this->response
119		->setCode(Response::HTTP_OK)
120	1	->setContent(
121		[Response::_ERROR => false, 'token' => $token]
122		);
123		return $this;
124		}
125		$logger->warning(__FUNCTION__ . ' Auth failed');
126		unset($authFactory);
127		return $this->setErrorResponse(
128		Response::HTTP_UNAUTHORIZED,
129		'Bad credentials'
130		);
131		}
132
133		/**
134		* register action
135		*
136		* @Role anonymous
137		* @return Auth
138		*/
139		final public function register(): Auth
140		{
141		$config = $this->getService(Config::class);
142		$logger = $this->getService(\Monolog\Logger::class);
143		$name = filter_var($this->request->getParam('name'), FILTER_SANITIZE_STRING);
144		$email = filter_var($this->request->getParam('email'), FILTER_SANITIZE_EMAIL);
145		$password = filter_var($this->request->getParam('password'), FILTER_SANITIZE_STRING);
146		if (false === $this->isValidRegistration($name, $email, $password)) {
147		$this->error = true;
148		$this->errorMessage = 'Invalid arguments';
149		$logger->warning(__FUNCTION__ . ' Invalid arguments');
150		return $this->setRegistrationResponse(__CLASS__, __FUNCTION__);
151		}
152		$this->userRepository->emailExists($email);
153		$this->sql = $this->userRepository->getSql();
154		$this->bindValues = $this->userRepository->getBuilderValues();
155		$this->db->run($this->sql, $this->bindValues)->hydrate();
156		$emailCount = $this->db->getRowset();
157		$emailCounter = (int) $emailCount[0]['counter'];
158		if ($emailCounter !== 0) {
159		$this->error = true;
160		$this->errorMessage = 'Email exists';
161		$logger->warning(__FUNCTION__ . $this->errorMessage);
162		return $this->setRegistrationResponse(__CLASS__, __FUNCTION__);
163		}
164		$cryptEngine = new Crypt($config);
165		$cryptedPassword = $cryptEngine->encrypt($password);
166		unset($cryptEngine);
167		$this->userRepository->register($name, $email, $cryptedPassword);
168		$this->sql = $this->userRepository->getSql();
169		$this->bindValues = $this->userRepository->getBuilderValues();
170		$this->db->run($this->sql, $this->bindValues);
171		return $this->setRegistrationResponse(__CLASS__, __FUNCTION__);
172		}
173
174		/**
175		* return true if request methods are allowed
176		*
177		* @return boolean
178		*/
179		protected function isLoginMethodAllowed(): bool
180		{
181		return in_array(
182		$this->request->getMethod(),
183		[Request::METHOD_POST, Request::METHOD_TRACE]
184		);
185		}
186
187		/**
188		* return true if login action can be executed
189		*
190		* @param string $login
191		* @param string $password
192		* @return boolean
193		*/
194		protected function isValidLogin(string $login, string $password): bool
195		{
196		return $this->isLoginMethodAllowed()
197		&& !empty($login)
198		&& !empty($password);
199		}
200
201		/**
202		* return true if registration process can be executed
203		*
204		* @param string $login
205		* @param string $password
206		* @return boolean
207		*/
208		protected function isValidRegistration(string $name, string $email, string $password): bool
209		{
210		$notEmpty = (!empty($name) && !empty($email) && !empty($password));
211		$isMethodAllow = $this->request->getMethod() === Request::METHOD_POST;
212		return $notEmpty && $isMethodAllow;
213		}
214
215		/**
216		* return Auth and set response with http code and message
217		*
218		* @param integer $code
219		* @param string $msg
220		* @return Auth
221		*/
222		protected function setErrorResponse(int $code, string $msg): Auth
223		{
224		$this->response
225		->setCode($code)
226		->setContent([
227		Response::_ERROR => true,
228		Response::_ERROR_CODE => $code,
229		Response::_ERROR_MSG => $msg
230		])->getHeaderManager()->add(
231		Headers::CONTENT_TYPE,
232		'application/json'
233		);
234		return $this;
235		}
236
237		/**
238		* set response with for a classname and action
239		*
240		* @param string $classname
241		* @param string $action
242		* @return Auth
243		*/
244		protected function setRegistrationResponse(string $classname, string $action): Auth
245		{
246		$isError = $this->isError();
247		$this->response
248		->setCode($this->getStatusCode())
249		->setContent(
250		[
251		'error' => $this->error,
252		'errorMessage' => $this->errorMessage,
253		'datas' => [
254		'method' => $this->getRequest()->getMethod(),
255		'params' => $this->getParams(),
256		'controller' => $classname,
257		'action' => $action,
258		'query' => $isError
259		? ''
260		: $this->sql,
261		'queryValues' => $isError
262		? [] : $this->bindValues,
263		'rowset' => $isError
264		? []
265		: $this->db->getRowset()
266		]
267		]
268		);
269		return $this;
270		}
271
272		/**
273		* returns true if error happened
274		*
275		* @return boolean
276		*/
277		protected function isError(): bool
278		{
279		return $this->error === true;
280		}
281
282		/**
283		* returns http status code
284		*
285		* @return int
286		*/
287		protected function getStatusCode(): int
288		{
289		return (true === $this->isError())
290		? Response::HTTP_BAD_REQUEST
291		: Response::HTTP_OK;
292		}
293		}
294

pierre-fromager / nymfonya

Push — master ( 67ae16...651a4a )

Auth::isValidRegistration() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like