UsersTable::beforeSave() - Code Metrics - Inspection of "Finish 5.4.1" - Schlaefer/Saito - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 225222...7d085e )

by Schlaefer
created 2019-10-20 13:19 UTC
UsersTable::beforeSave() A

↳ Parent: UsersTable
Complexity

Conditions	2
Paths	2
Size

Total Lines
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
nc	2
nop	3
dl	0
loc	10
rs	9.9332
c	0
b	0
f	0
<?php

declare(strict_types=1);

/**
 * Saito - The Threaded Web Forum
 *
 * @copyright Copyright (c) the Saito Project Developers
 * @link https://github.com/Schlaefer/Saito
 * @license http://opensource.org/licenses/MIT
 */

namespace App\Model\Table;

use App\Lib\Model\Table\AppTable;
use App\Lib\Model\Table\FieldFilter;
use App\Model\Table\EntriesTable;
use App\Model\Table\UserBlocksTable;
use App\Model\Table\UserIgnoresTable;
use Authentication\PasswordHasher\DefaultPasswordHasher;
use Authentication\PasswordHasher\PasswordHasherFactory;
use Authentication\PasswordHasher\PasswordHasherInterface;
use Cake\Core\Configure;
use Cake\Database\Schema\TableSchema;
use Cake\Datasource\EntityInterface;
use Cake\Datasource\Exception\RecordNotFoundException;
use Cake\Event\Event;
use Cake\ORM\Entity;
use Cake\ORM\Locator\TableLocator;
use Cake\ORM\Query;
use Cake\ORM\TableRegistry;
use Cake\Validation\Validation;
use Cake\Validation\Validator;
use DateTimeInterface;
use Saito\User\Upload\AvatarFilenameListener;
use Stopwatch\Lib\Stopwatch;

/**
 * Users table
 *
 * @property EntriesTable $Entries
 * @property UserBlocksTable $UserBlocks
 * @property UserIgnoresTable $UserIgnores
 * @property UserOnlineTable $UserOnline
 */
class UsersTable extends AppTable
{
    /**
     * Max lenght for username.
     *
     * Constrained to 191 due to InnoDB index max-length on MySQL 5.6.
     */
    public const USERNAME_MAXLENGTH = 191;

    /**
     * {@inheritDoc}
     */
    protected $_defaultConfig = [
        'user_name_disallowed_chars' => ['\'', ';', '&', '<', '>']
    ];

    /**
     * {@inheritDoc}
     */
    public function initialize(array $config)
    {
        $this->addBehavior(
            'Cron.Cron',
            [
                'registerGc' => [
                    'id' => 'User.registerGc',
                    'due' => '+1 day',
                ],
                'userBlockGc' => [
                    'id' => 'User.userBlockGc',
                    'due' => '+15 minutes',
                ]
            ]
        );

        $avatarRootDir = Configure::read('Saito.Settings.uploadDirectory');
        $this->addBehavior(
            'Proffer.Proffer',
            [
                'avatar' => [ // The name of your upload field (filename)
                    'root' => $avatarRootDir,
                    'dir' => 'avatar_dir', // field for upload directory
                    'thumbnailSizes' => [
                        'square' => ['w' => 100, 'h' => 100],
                    ],
                    // Options are Imagick, Gd or Gmagick
                    'thumbnailMethod' => 'Gd'
                ]
            ]
        );
        $this->getEventManager()->on(new AvatarFilenameListener($avatarRootDir));

        $this->hasOne(
            'UserOnline',
            ['dependent' => true, 'foreignKey' => 'user_id']
        );

        $this->hasMany(
            'Bookmarks',
            ['foreignKey' => 'user_id', 'dependent' => true]
        );
        $this->hasMany('Drafts', ['dependent' => true]);
        $this->hasMany('UserIgnores', ['foreignKey' => 'user_id']);
        $this->hasMany(
            'Entries',
            [
                'foreignKey' => 'user_id',
                'conditions' => ['Entries.user_id' => 'Users.id'],
            ]
        );
        $this->hasMany(
            'ImageUploader.Uploads',
            ['dependent' => true, 'foreignKey' => 'user_id']
        );
        $this->hasMany(
            'UserReads',
            ['foreignKey' => 'user_id', 'dependent' => true]
        );
        $this->hasMany(
            'UserBlocks',
            [
                'foreignKey' => 'user_id',
                'dependent' => true,
                'sort' => [
                    'UserBlocks.ended IS NULL DESC',
                    'UserBlocks.ended' => 'DESC',
                    'UserBlocks.id' => 'DESC'
                ]
            ]
        );
    }

    /**
     * {@inheritDoc}
     */
    public function validationDefault(Validator $validator)
    {
        $validator->setProvider(
            'saito',
            'Saito\Validation\SaitoValidationProvider'
        );

        $validator

            ->setProvider(
                'proffer',
                'Proffer\Model\Validation\ProfferRules'
            )
            ->allowEmpty('avatar_dir')
            ->allowEmpty('avatar')
            ->add(
                'avatar',
                'avatar-extension',
                [
                    'rule' => ['extension', ['jpg', 'jpeg', 'png']],
                    'message' => __('user.avatar.error.extension', ['jpg, jpeg, png'])
                ]
            )
            ->add(
                'avatar',
                'avatar-size',
                [
                    'rule' => ['fileSize', Validation::COMPARE_LESS, '3MB'],
                    'message' => __('user.avatar.error.size', ['3'])
                ]
            )
            ->add(
                'avatar',
                'avatar-mime',
                [
                    'rule' => ['mimetype', ['image/jpeg', 'image/png']],
                    'message' => __('user.avatar.error.mime')
                ]
            )
            ->add(
                'avatar',
                'avatar-dimension',
                [
                    'rule' => [
                        'dimensions',
                        [
                            'min' => ['w' => 100, 'h' => 100],
                            'max' => ['w' => 1500, 'h' => 1500]
                        ]
                    ],
                    'message' => __(
                        'user.avatar.error.dimension',
                        ['100x100', '1500x1500']
                    ),
                    'provider' => 'proffer'
                ]
            );

        $validator

            ->notEmpty('password')
            ->add(
                'password',
                [
                    'pwConfirm' => [
                        'rule' => [$this, 'validateConfirmPassword'],
                        'last' => true,
                        'message' => __('error_password_confirm')
                    ]
                ]
            );

        $validator

            ->notEmpty('password_old')
            ->add(
                'password_old',
                [
                    'pwCheckOld' => [
                        'rule' => [$this, 'validateCheckOldPassword'],
                        'last' => true,
                        'message' => 'validation_error_pwCheckOld'
                    ]
                ]
            );

        $validator

            ->notEmpty('username', __('error_no_name'))
            ->add(
                'username',
                [
                    'isUnique' => [
                        'rule' => 'validateIsUniqueCiString',
                        'provider' => 'saito',
                        'last' => true,
                        'message' => __('error_name_reserved')
                    ],
                    'isUsernameEqual' => [
                        'on' => 'create',
                        'last' => true,
                        'rule' => [$this, 'validateUsernameEqual']
                    ],
                    'hasAllowedChars' => [
                        'rule' => [$this, 'validateHasAllowedChars'],
                        'message' => __(
                            'model.user.validate.username.hasAllowedChars'
                        )
                    ],
                    'isNotEmoji' => [
                        'rule' => 'utf8',
                        'message' => __(
                            'model.user.validate.username.hasAllowedChars'
                        )
                    ],
                    'maxLength' => [
                        'last' => true,
                        'message' => __('vld.users.username.maxlength', self::USERNAME_MAXLENGTH),
                        'rule' => ['maxLength', self::USERNAME_MAXLENGTH],
                    ],
                ]
            );

        $validator

            ->notEmpty('user_email')
            ->add(
                'user_email',
                [
                    'isUnique' => [
                        'rule' => 'validateUnique',
                        'provider' => 'table',
                        'last' => true,
                        'message' => __('error_email_reserved')
                    ],
                    'isEmail' => [
                        'rule' => ['email', true],
                        'last' => true,
                        'message' => __('error_email_wrong')
                    ]
                ]
            );

        $validator->add(
            'user_forum_refresh_time',
            [
                'numeric' => ['rule' => 'numeric'],
                'greaterNull' => ['rule' => ['comparison', '>=', 0]],
                'maxLength' => ['rule' => ['maxLength', 3]],
            ]
        );

        $validator->add(
            'user_type',
            [
                'allowedType' => [
                    'rule' => ['inList', ['user', 'mod', 'admin']]
                ]
            ]
        );

        $validator->notEmpty('registered');


        $validator->add(
            'logins',
            ['numeric' => ['rule' => ['numeric']]]
        );

        $validator->add(
            'personal_messages',
            ['bool' => ['rule' => ['boolean']]]
        );

        $validator->add(
            'user_lock',
            ['bool' => ['rule' => ['boolean']]]
        );

        $validator

            ->notEmpty('activate_code')
            ->add(
                'activate_code',
                [
                    'numeric' => ['rule' => ['numeric']],
                    'between' => ['rule' => ['range', 0, 9999999]]
                ]
            );

        $validator->add(
            'user_signatures_hide',
            ['bool' => ['rule' => ['boolean']]]
        );

        $validator->add(
            'user_signature_images_hide',
            ['bool' => ['rule' => ['boolean']]]
        );

        $validator->add(
            'user_automaticaly_mark_as_read',
            ['bool' => ['rule' => ['boolean']]]
        );

        $validator->add(
            'user_sort_last_answer',
            ['bool' => ['rule' => ['boolean']]]
        );

        $validator

            ->allowEmpty('user_color_new_postings')
            ->add(
                'user_color_new_postings',
                [
                    'hexformat' => [
                        'rule' => ['custom', '/^#?[a-f0-9]{0,6}$/i']
                    ]
                ]
            );
        $validator

            ->allowEmpty('user_color_old_postings')
            ->add(
                'user_color_old_postings',
                [
                    'hexformat' => [
                        'rule' => ['custom', '/^#?[a-f0-9]{0,6}$/i']
                    ]
                ]
            );
        $validator

            ->allowEmpty('user_color_actual_posting')
            ->add(
                'user_color_actual_posting',
                [
                    'hexformat' => [
                        'rule' => ['custom', '/^#?[a-f0-9]{0,6}$/i']
                    ]
                ]
            );

        return $validator;
    }

    /**
     * {@inheritDoc}
     */
    protected function _initializeSchema(TableSchema $table)
    {
        $table->setColumnType('avatar', 'proffer.file');
        $table->setColumnType('user_category_custom', 'serialize');

        return $table;
    }

    /**
     * set last refresh
     *
     * @param int $userId user-ID
     * @param DateTimeInterface|null $lastRefresh last refresh
     * @return void
     */
    public function setLastRefresh(int $userId, DateTimeInterface $lastRefresh = null)
    {
        Stopwatch::start('Users->setLastRefresh()');
        $data['last_refresh_tmp'] = bDate();
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}

        if ($lastRefresh) {
            $data['last_refresh'] = $lastRefresh;
        }

        $this->query()
            ->update()
            ->set($data)
            ->where(['id' => $userId])
            ->execute();

        Stopwatch::end('Users->setLastRefresh()');
    }

    /**
     * Increment logins
     *
     * @param Entity $user user
     * @param int $amount amount
     * @return void
     * @throws \Exception
     */
    public function incrementLogins(Entity $user, $amount = 1)
    {
        $data = [
            'logins' => $user->get('logins') + $amount,
            'last_login' => bDate()
        ];
        $this->patchEntity($user, $data);
        if (!$this->save($user)) {
            throw new \Exception('Increment logins failed.');
        }
    }

    /**
     * get userlist
     *
     * @return array
     */
    public function userlist()
    {
        return $this->find(
            'list',
            ['keyField' => 'id', 'valueField' => 'username']
        )->toArray();
    }

    /**
     * Removes a user and all his data execpt for his entries
     *
     * @param int $userId user-ID
     * @return bool
     */
    public function deleteAllExceptEntries(int $userId)
    {
        if ($userId == 1) {
            return false;
        }
        $user = $this->get($userId);
        if (!$user) {
            return false;
        }

        try {
            $this->Entries->anonymizeEntriesFromUser($userId);
            $this->UserIgnores->deleteUser($userId);
            $this->delete($user);
        } catch (\Exception $e) {
            return false;
        }
        $this->_dispatchEvent('Cmd.Cache.clear', ['cache' => 'Thread']);

        return true;
    }

    /**
     * Updates the hashed password if hash-algo is out-of-date
     *
     * @param int $userId user-ID
     * @param string $password password
     * @return void
     */
    public function autoUpdatePassword(int $userId, string $password): void
    {
        $user = $this->get($userId, ['fields' => ['id', 'password']]);
        $oldPassword = $user->get('password');
        $needsRehash = $this->getPasswordHasher()->needsRehash($oldPassword);
        if ($needsRehash) {
            $user->set('password', $password);
            $this->save($user);
        }
    }

    /**
     * Post processing when updating a username.
     *
     * @param Entity $entity The updated entity.
     * @return void
     */
    protected function updateUsername(Entity $entity)
    {
        // Using associating with $this->Entries->updateAll() not working in
        // Cake 3.8.
        $Entries = TableRegistry::getTableLocator()->get('Entries');
        $Entries->updateAll(
            ['name' => $entity->get('username')],
            ['user_id' => $entity->get('id')]
        );

        $Entries->updateAll(
            ['edited_by' => $entity->get('username')],
            ['edited_by' => $entity->getOriginal('username')]
        );

        $this->_dispatchEvent('Cmd.Cache.clear', ['cache' => 'Thread']);
    }

    /**
     * {@inheritDoc}
     */
    public function afterSave(Event $event, Entity $entity, \ArrayObject $options)
    {
        if ($entity->isDirty('username')) {
            $this->updateUsername($entity);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function beforeSave(
        Event $event,
        Entity $entity,
        \ArrayObject $options
    ) {
        if ($entity->isDirty('password')) {
            $hashedPassword = $this->getPasswordHasher()->hash($entity->get('password'));
            $entity->set('password', $hashedPassword);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function beforeValidate(
        Event $event,
        Entity $entity,
        \ArrayObject $options,
        Validator $validator

    ) {
        if ($entity->isDirty('user_forum_refresh_time')) {
            $time = $entity->get('user_forum_refresh_time');
            if (empty($time)) {
                $entity->set('user_forum_refresh_time', 0);
            }
        }
    }

    /**
     * validate old password
     *
     * @param string $value value
     * @param array $context context
     * @return bool
     */
    public function validateCheckOldPassword($value, array $context)
    {
        $userId = $context['data']['id'];
        $oldPasswordHash = $this->get($userId, ['fields' => ['password']])
            ->get('password');

        return $this->getPasswordHasher()->check($value, $oldPasswordHash);
    }

    /**
     * validate confirm password
     *
     * @param string $value value
     * @param array $context context
     * @return bool
     */
    public function validateConfirmPassword($value, array $context)
    {
        if ($value === $context['data']['password_confirm']) {
            return true;
        }

        return false;
    }

    /**
     * Validate allowed chars
     *
     * @param string $value value
     * @param array $context context
     * @return bool
     */
    public function validateHasAllowedChars($value, array $context)

    {
        foreach ($this->getConfig('user_name_disallowed_chars') as $char) {
            if (mb_strpos($value, $char) !== false) {
                return false;
            }
        }

        return true;
    }

    /**
     * checks if equal username exists
     *
     * @param string $value value
     * @param array $context context
     * @return bool|string
     */
    public function validateUsernameEqual($value, array $context)

    {
        Stopwatch::start('validateUsernameEqual');
        $users = $this->userlist();
        $lc = mb_strtolower($value);
        foreach ($users as $name) {
            if ($name === $value) {
                continue;
            }
            $name = mb_strtolower($name);
            $distance = levenshtein($lc, $name);
            if ($distance < 2) {
                return __('error.name.equalExists', $name);
            }
        }
        Stopwatch::stop('validateUsernameEqual');

        return true;
    }

    /**
     * Registers new user
     *
     * @param array $data data
     * @param bool $activate activate
     * @return EntityInterface
     */
    public function register($data, $activate = false): EntityInterface
    {
        $defaults = [
            'registered' => bDate(),
            'user_type' => 'user'
        ];
        $fields = [
            'password',
            'registered',
            'user_email',
            'user_type',
            'username'
        ];

        if ($activate !== true) {
            $defaults['activate_code'] = mt_rand(1000000, 9999999);
            $fields[] = 'activate_code';
        }

        $data = array_merge($data, $defaults);

        $fieldFilter = (new FieldFilter())->setConfig('register', $fields);
        if (!$fieldFilter->requireFields($data, 'register')) {
            throw new \RuntimeException(
                'Required fields for registration were not provided.',
                1563789683
            );
        }

        $user = $this->newEntity($data, ['fields' => $fields]);
        $errors = $user->getErrors();
        if (!empty($errors)) {
            return $user;
        }
        $this->save($user);

        return $user;
    }

    /**
     * Garbage collection for registration
     *
     * Deletes all timed out and unactivated registrations
     *
     * @return void
     */
    public function registerGc()
    {
        $this->deleteAll(
            [
                'activate_code >' => 0,
                'registered <' => bDate(time() - 86400)
            ]
        );
    }

    /**
     * calls garbage collection for UserBlock
     *
     * UserBlock is lazy-loaded rarely and gc may not trigger often enough (at
     * least with manual blocking and ignore blocking only)
     *
     * @return void
     */
    public function userBlockGc()
    {
        $this->UserBlocks->gc();
    }

    /**
     * activates user
     *
     * @param int $userId user-ID
     * @param string $code activation code
     * @return array|bool false if activation failed; array with status and
     *     user data on success
     * @throws \InvalidArgumentException
     */
    public function activate($userId, $code)
    {
        if (!is_int($userId) || !is_string($code)) {
            throw new \InvalidArgumentException();
        }

        try {
            $user = $this->get($userId);
        } catch (RecordNotFoundException $e) {
            throw new \InvalidArgumentException();
        }

        $activateCode = strval($user->get('activate_code'));

        if (empty($activateCode)) {
            return ['status' => 'already', 'User' => $user];
        } elseif ($activateCode !== $code) {
            return false;
        }

        $user->set('activate_code', 0);
        $success = $this->save($user);
        if (empty($success)) {
            return false;
        }

        $this->_dispatchEvent('Model.User.afterActivate', ['User' => $user]);

        return ['status' => 'activated', 'User' => $user];
    }

    /**
     * Count solved posting for a user.
     *
     *
     * @param int $userId user-ID
     * @return int count
     */
    public function countSolved($userId)
    {
        $count = $this->find()
            ->select(['Users.id'])
            ->where(['Users.id' => $userId])
            ->join(
                [
                    'Entries' => [
                        'table' => $this->Entries->getTable(),
                        'type' => 'INNER',
                        'conditions' => [
                            [
                                'Entries.solves >' => '0',
                                'Entries.user_id' => $userId
                            ]
                        ],
                    ],
                    'Root' => [
                        'table' => $this->Entries->getTable(),
                        'type' => 'INNER',
                        // Don't answers to own question.
                        'conditions' => [
                            'Root.id = Entries.solves',
                            'Root.user_id != Users.id',
                        ]
                    ]
                ]
            );

        return $count->count();
    }

    /**
     * Set view categories preferences
     *
     * ## $category
     *
     * - 'all': set to all categories
     * - array: (cat_id1 => true|1|'1', cat_id2 => true|1|'1')
     * - int: set to single category_id
     *
     * @param int $userId user-ID
     * @param string|int|array $category category
     * @return void
     * @throws \InvalidArgumentException
     */
    public function setCategory($userId, $category)
    {
        $User = $this->find()->select(['id' => $userId])->first();
        if (!$User) {
            throw new \InvalidArgumentException(
                "Can't find user with id $userId.",
                1420807691
            );
        }

        if ($category === 'all') {
            //=if show all cateogries
            $active = -1;
        } elseif (is_array($category)) {
            //=if set a custom set of categories
            $active = 0;

            $availableCats = $this->Entries->Categories->find('list')->toArray(
            );
            $categories = array_intersect_key($category, $availableCats);
            if (count($categories) === 0) {
                throw new \InvalidArgumentException();
            }
            $newCats = [];
            foreach ($categories as $cat => $v) {
                $newCats[$cat] = ($v === true || $v === 1 || $v === '1');
            }
            $User->set('user_category_custom', $newCats);
        } else {
            //=if set a single category
            $category = (int)$category;
            if ($category > 0 && $this->Entries->Categories->exists((int)$category)
            ) {
                $active = $category;
            } else {
                throw new \InvalidArgumentException();
            }
        }

        $User->set('user_category_active', $active);
        $this->save($User);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    /**
     * Get default password hasher for hashing user passwords.
     *
     * @return PasswordHasherInterface
     */
    public function getPasswordHasher(): PasswordHasherInterface
    {
        return PasswordHasherFactory::build(DefaultPasswordHasher::class);
    }

    /**
     * Finds a user with additional profil informations from associated tables
     *
     * @param Query $query query
     * @param array $options options
     * @return Query
     */
    public function findProfile(Query $query, array $options): Query
    {
        $query
            // ->enableHydration(false)
            ->contain(
                [
                    'UserIgnores' => function ($query) {
                        return $query->enableHydration(false)->select(
                            ['blocked_user_id', 'user_id']
                        );
                    }
                ]
            );

        return $query;
    }

    /**
     * Find all sorted by username
     *
     * @param Query $query query
     * @param array $options options
     * @return Query
     */
    public function findPaginated(Query $query, array $options)
    {
        $query
            ->contain(['UserOnline'])
            ->order(['Users.username' => 'ASC']);

        return $query;
    }

    /**
     * Find the latest, successfully registered user
     *
     * @param Query $query query
     * @param array $options options
     * @return Query
     */
    public function findLatest(Query $query, array $options)
    {
        $query->where(['activate_code' => 0])
            ->order(['id' => 'DESC'])
            ->limit(1);

        return $query;
    }
}

1			<?php
2
3			declare(strict_types=1);
4
5			/**
6			* Saito - The Threaded Web Forum
7			*
8			* @copyright Copyright (c) the Saito Project Developers
9			* @link https://github.com/Schlaefer/Saito
10			* @license http://opensource.org/licenses/MIT
11			*/
12
13			namespace App\Model\Table;
14
15			use App\Lib\Model\Table\AppTable;
16			use App\Lib\Model\Table\FieldFilter;
17			use App\Model\Table\EntriesTable;
18			use App\Model\Table\UserBlocksTable;
19			use App\Model\Table\UserIgnoresTable;
20			use Authentication\PasswordHasher\DefaultPasswordHasher;
21			use Authentication\PasswordHasher\PasswordHasherFactory;
22			use Authentication\PasswordHasher\PasswordHasherInterface;
23			use Cake\Core\Configure;
24			use Cake\Database\Schema\TableSchema;
25			use Cake\Datasource\EntityInterface;
26			use Cake\Datasource\Exception\RecordNotFoundException;
27			use Cake\Event\Event;
28			use Cake\ORM\Entity;
29			use Cake\ORM\Locator\TableLocator;
30			use Cake\ORM\Query;
31			use Cake\ORM\TableRegistry;
32			use Cake\Validation\Validation;
33			use Cake\Validation\Validator;
34			use DateTimeInterface;
35			use Saito\User\Upload\AvatarFilenameListener;
36			use Stopwatch\Lib\Stopwatch;
37
38			/**
39			* Users table
40			*
Schlaefer / Saito

Push — master ( 225222...7d085e )

UsersTable::beforeSave() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
