UserBlocksTable::findAssocUsers() - Code Metrics - Schlaefer/Saito - Measure and Improve Code Quality continuously with Scrutinizer

UserBlocksTable::findAssocUsers() A
last analyzed 2020-10-20 13:08 UTC

↳ Parent: UserBlocksTable

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	1
dl	0
loc	8
rs	10
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\Model\Table\UsersTable;
use Cake\ORM\Query;
use Cake\ORM\Table;
use Cake\Validation\Validator;
use Saito\User\Blocker\BlockerAbstract;

/**
 * UserBlock table
 *
 * @property UsersTable $Users
 */
class UserBlocksTable extends Table
{

    /**
     * {@inheritDoc}
     */
    public function initialize(array $config)
    {
        $this->addBehavior('Timestamp');

        // Blocked user.
        $this->belongsTo('Users', ['foreignKey' => 'user_id']);
        // User responsible for the blocking.
        $this->belongsTo(
            'BlockedBy',
            ['className' => 'Users', 'foreignKey' => 'blocked_by_user_id']
        );
    }

    /**
     * {@inheritDoc}
     */
    public function validationDefault(Validator $validator)
    {
        $validator
        /** @scrutinizer ignore-deprecated */ $validator
            ->allowEmpty('ends')
            ->add('ends', 'datetime', ['rule' => ['datetime']]);
        $validator->notEmpty('user_id');
        /** @scrutinizer ignore-deprecated */ $validator->notEmpty('user_id');
        $validator->notEmpty('reason');
        /** @scrutinizer ignore-deprecated */ $validator->notEmpty('reason');

        return $validator;
    }

    /**
     * block user
     *
     * @param BlockerAbstract $Blocker blocker
     * @param int $userId user-ID
     * @return bool success
     */
    public function block(BlockerAbstract $Blocker, int $userId): bool
    {
        $Blocker->setUserBlockTable($this);
        $success = $Blocker->block($userId);
        if ($success) {
            $this->_updateIsBlocked($userId);
        }

        return $success;
    }

    /**
     * get block ending for user
     *
     * @param int $userId user-ID
     * @return mixed
     */
    public function getBlockEndsForUser($userId)
    {
        $block = $this->find(
            'all',
            [
                'conditions' => ['user_id' => $userId, 'ended IS' => null],
                'sort' => ['ends' => 'asc'],
            ]
        )->first();

        return $block->get('ends');
    }

    /**
     * unblock
     *
     * @param int $id id
     * @return mixed
     */
    public function unblock($id)
    {
        $block = $this->find()->where(['id' => $id, 'ended IS' => null])->first(
        );
        if (!$block) {
            throw new \InvalidArgumentException();
        }
        $this->patchEntity(
            $block,
            /** @scrutinizer ignore-type */ $block,
            ['ended' => bDate(), 'ends' => null]
        );

        if (!$this->save($block)) {
        if (!$this->save(/** @scrutinizer ignore-type */ $block)) {
            throw new \RuntimeException(
                "Couldn't unblock block with id $id.",
                1420540471
            );
        }

        return $this->_updateIsBlocked($block->get('user_id'));
    }

    /**
     * Garbage collection
     *
     * called hourly from User model
     *
     * @return void
     */
    public function gc()
    {
        $expired = $this->find('toGc')->all();
        foreach ($expired as $block) {
            $this->unblock($block->get('id'));
        }
    }

    /**
     * get all
     *
     * @return Query
     */
    public function getAll()
    {
        $blocklist = $this->find('assocUsers')
            ->order(['UserBlocks.id' => 'DESC']);

        return $blocklist;
    }

    /**
     * gc finder
     *
     * @param Query $query query
     * @param array $options options
     * @return Query
     */
    public function findToGc(Query $query, array $options)
    public function findToGc(Query $query, /** @scrutinizer ignore-unused */ array $options)
    {
        $query->where(
            [
                'ends IS NOT' => null,
                'ends <' => bDate(),
                'ended IS' => null,
            ]
        );

        return $query;
    }

    /**
     * Select required fields from associated Users.
     *
     * Don't hydrate full user entities.
     *
     * @param Query $query query
     * @return Query
     */
    public function findAssocUsers(Query $query)
    {
        $callback = function (Query $query) {
            return $query->select(['id', 'username']);
        };
        $query->contain(['BlockedBy' => $callback, 'Users' => $callback]);

        return $query;
    }

    /**
     * update is blocked
     *
     * @param int $userId user-ID
     * @return mixed
     */
    protected function _updateIsBlocked($userId)
    {
        $blocks = $this->find(
            'all',
            [
                'conditions' => [
                    'ended IS' => null,
                    'user_id' => $userId,
                ],
            ]
        )->first();
        $user = $this->Users->get($userId, ['fields' => ['id', 'user_lock']]);
        $user->set('user_lock', !empty($blocks));

        return $this->Users->save($user);
    }
}


Schlaefer / Saito

UserBlocksTable::findAssocUsers() A last analyzed 2020-10-20 13:08 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

UserBlocksTable::findAssocUsers() A
last analyzed 2020-10-20 13:08 UTC