Zemit\Models\User

Complexity

Total Complexity

11

Size/Duplication

Total Lines	92
Duplicated Lines	0 %

Test Coverage

Coverage

91.3%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	preparePassword()	0	8	3
A	beforeSave()	0	3	1
A	validation()	0	38	4
A	initialize()	0	17	1
A	checkPassword()	0	3	2

<?php
/**
 * This file is part of the Zemit Framework.
 *
 * (c) Zemit Team <contact@zemit.com>
 *
 * For the full copyright and license information, please view the LICENSE.txt
 * file that was distributed with this source code.
 */

namespace Zemit\Models;

use Zemit\Models\Abstracts\AbstractUser;
use Phalcon\Filter\Validation\Validator\Between;
use Phalcon\Filter\Validation\Validator\Confirmation;
use Phalcon\Filter\Validation\Validator\Date;
use Phalcon\Filter\Validation\Validator\Email;

This use statement conflicts with another class in this namespace, Zemit\Models\Email. Consider defining an alias.

use Phalcon\Filter\Validation\Validator\PresenceOf;
use Phalcon\Filter\Validation\Validator\StringLength\Max;
use Phalcon\Filter\Validation\Validator\Uniqueness;
use Phalcon\Filter\Validation\Validator\InclusionIn;

use Zemit\Identity;
use Zemit\Models\Interfaces\UserInterface;

/**
 * @property UserGroup[] $GroupNode
 * @property Group[] $GroupList
 * @property UserRole[] $RoleNode
 * @property Role[] $RoleList
 * @property UserType[] $TypeNode
 * @property Type[] $TypeList
 * @property File[] $FileList
 * @property Identity $Identity
 *
 * @method UserGroup[] getGroupNode(?array $params = null)
 * @method Group[] getGroupList(?array $params = null)
 * @method UserRole[] getRoleNode(?array $params = null)
 * @method Role[] getRoleList(?array $params = null)
 * @method UserType[] getTypeNode(?array $params = null)
 * @method Type[] getTypeList(?array $params = null)
 * @method File[] getFileList(?array $params = null)
 */
class User extends AbstractUser implements UserInterface
{
    protected $deleted = self::NO;

    public function initialize(): void
    {
        parent::initialize();

        $this->hasMany('id', File::Class, 'userId', ['alias' => 'FileList']);

The constant Zemit\Models\File::Class was not found. Maybe you did not declare it correctly or list all dependencies?

        $this->hasMany('id', UserGroup::class, 'userId', ['alias' => 'GroupNode']);
        $this->hasManyToMany('id', UserGroup::Class, 'userId',

The constant Zemit\Models\UserGroup::Class was not found. Maybe you did not declare it correctly or list all dependencies?

            'groupId', Group::class, 'id', ['alias' => 'GroupList']);

        $this->hasMany('id', UserRole::class, 'userId', ['alias' => 'RoleNode']);
        $this->hasManyToMany('id', UserRole::Class, 'userId',

The constant Zemit\Models\UserRole::Class was not found. Maybe you did not declare it correctly or list all dependencies?

            'roleId', Role::class, 'id', ['alias' => 'RoleList']);

        $this->hasMany('id', UserType::class, 'userId', ['alias' => 'TypeNode']);
        $this->hasManyToMany('id', UserType::Class, 'userId',

The constant Zemit\Models\UserType::Class was not found. Maybe you did not declare it correctly or list all dependencies?

            'typeId', Type::class, 'id', ['alias' => 'TypeList']);
    }

    public function validation(): bool
    {
        $validator = $this->genericValidation();

        $validator->add('username', new PresenceOf(['message' => $this->_('required')]));
        $validator->add('email', new Max(['max' => 120, 'message' => $this->_('length-exceeded')]));

        $validator->add('firstName', new PresenceOf(['message' => $this->_('first-name') . ': ' . $this->_('required')]));
        $validator->add('firstName', new Max(['max' => 60, 'message' => $this->_('first-name') . ': ' . $this->_('length-exceeded')]));

        $validator->add('lastName', new PresenceOf(['message' => $this->_('last-name') . ': ' . $this->_('required')]));
        $validator->add('lastName', new Max(['max' => 60, 'message' => $this->_('last-name') . ': ' . $this->_('length-exceeded')]));

        $validator->add('email', new PresenceOf(['message' => $this->_('required')]));
        $validator->add('email', new Email(['message' => 'email-not-valid']));
        $validator->add('email', new Uniqueness(['message' => $this->_('not-unique')]));
        $validator->add('email', new Max(['max' => 191, 'message' => $this->_('length-exceeded')]));

        $validator->add('gender', new Between(["minimum" => 0, "maximum" => 1, 'message' => $this->_('boolean-not-valid')]));

        if ($this->getDob()) {
            $validator->add('dob', new Date(['format' => self::DATE_FORMAT, 'message' => $this->_('date-not-valid')]));

The constant Zemit\Models\User::DATE_FORMAT was not found. Maybe you did not declare it correctly or list all dependencies?

        }

        $validator->add(['phone', 'phone2', 'cellphone', 'fax'], new Max(['max' => 60, 'message' => $this->_('length-exceeded')]));

        $validator->add('token', new Max(['max' => 120, 'message' => $this->_('length-exceeded')]));

        // Password
        if (!$this->hasSnapshotData() || $this->hasChanged('password')) {
            $validator->add(['password', 'passwordConfirm'], new Max(['max' => 255, 'message' => 'Le mot de passe ne doit pas dépasser :max caractères']));
            $validator->add('passwordConfirm', new Confirmation([
                'message' => 'La mot de passe et la confirmation doivent être identique',
                'with' => 'password',
            ]));
        }

        return $this->validate($validator);
    }

    /**
     * Prepare save after validation
     */
    public function beforeSave(): void
    {
        $this->preparePassword();
    }

    /**
     * Salt & hash the passwordConfirm field into password
     */
    public function preparePassword(): void
    {
        $password = $this->getPassword();
        $passwordConfirm = $this->getPasswordConfirm();
        if (!empty($passwordConfirm) && $password === $passwordConfirm) {
            $this->setPassword($this->hash($passwordConfirm));
        }
        $this->setPasswordConfirm(null);
    }

    /**
     * @param string|null $password
     *
     * @return bool If the hash is valid or not
     */
    public function checkPassword(string $password = null): bool
    {
        return $password && $this->checkHash($this->getPassword(), $password);
    }
}