Arrilot\BitrixModels\Models\UserModel

Complexity

Total Complexity

31

Size/Duplication

Total Lines	273
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	1
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	query()	0	4	1
A	current()	0	6	2
A	freshCurrent()	0	6	1
A	afterFill()	0	6	3
A	fillGroups()	0	6	1
A	load()	0	7	1
A	getGroups()	0	8	2
A	refresh()	0	8	1
A	refreshFields()	0	18	4
A	refreshGroups()	0	16	3
A	isAdmin()	0	4	1
A	isCurrent()	0	6	2
A	hasGroupWithId()	0	4	1
A	isAuthorized()	0	6	2
A	isGuest()	0	4	1
A	logout()	0	6	1
A	scopeFromGroup()	0	6	1
A	substituteGroup()	0	14	3

<?php

namespace Arrilot\BitrixModels\Models;

use Arrilot\BitrixModels\Queries\UserQuery;

class UserModel extends BitrixModel
{
    /**
     * Corresponding object class name.
     *
     * @var string
     */
    protected static $objectClass = 'CUser';

    /**
     * Current user cache.
     *
     * @var static
     */
    protected static $currentUser = null;

    /**
     * Have groups been already fetched from DB?
     *
     * @var bool
     */
    protected $groupsAreFetched = false;

    /**
     * Instantiate a query object for the model.
     *
     * @return UserQuery
     */
    public static function query()
    {
        return new UserQuery(static::instantiateObject(), get_called_class());
    }

    /**
     * Get a new instance for the current user
     *
     * @return static
     */
    public static function current()
    {
        return is_null(static::$currentUser)
            ? static::freshCurrent()
            : static::$currentUser;
    }

    /**
     * Get a fresh instance for the current user and save it to local cache.
     *
     * @return static
     */
    public static function freshCurrent()
    {
        global $USER;

Use of global functionality is not recommended; it makes your code harder to test, and less reusable.

        return static::$currentUser = (new static($USER->getId()))->load();
    }

    /**
     * Fill extra fields when $this->field is called.
     *
     * @return null
     */
    protected function afterFill()
    {
        if (isset($this->fields['GROUP_ID']) && is_array(['GROUP_ID'])) {
            $this->groupsAreFetched = true;
        }
    }

    /**
     * Fill model groups if they are already known.
     * Saves DB queries.
     *
     * @param array $groups
     *
     * @return null
     */
    public function fillGroups($groups)
    {
        $this->fields['GROUP_ID'] = $groups;

        $this->groupsAreFetched = true;
    }

    /**
     * Load model fields from database if they are not loaded yet.
     *
     * @return $this
     */
    public function load()
    {
        $this->getFields();
        $this->getGroups();

        return $this;
    }

    /**
     * Get user groups from cache or database.
     *
     * @return array
     */
    public function getGroups()
    {
        if ($this->groupsAreFetched) {
            return $this->fields['GROUP_ID'];
        }

        return $this->refreshGroups();
    }

    /**
     * Refresh model from database and place data to $this->fields.
     *
     * @return array
     */
    public function refresh()
    {
        $this->refreshFields();

        $this->refreshGroups();

        return $this->fields;
    }

    /**
     * Refresh user fields and save them to a class field.
     *
     * @return array
     */
    public function refreshFields()
    {
        if ($this->id === null) {
            return  $this->fields = [];
        }

        $groupBackup = isset($this->fields['GROUP_ID']) ? $this->fields['GROUP_ID'] : null;

        $this->fields = static::query()->getById($this->id)->fields;

        if ($groupBackup) {
            $this->fields['GROUP_ID'] = $groupBackup;
        }

        $this->fieldsAreFetched = true;

        return $this->fields;
    }

    /**
     * Refresh user groups and save them to a class field.
     *
     * @return array
     */
    public function refreshGroups()
    {
        if ($this->id === null) {
            return [];
        }

        global $USER;

Use of global functionality is not recommended; it makes your code harder to test, and less reusable.

        $this->fields['GROUP_ID'] = $this->isCurrent()
            ? $USER->getUserGroupArray()
            : static::$bxObject->getUserGroup($this->id);

        $this->groupsAreFetched = true;

        return $this->fields['GROUP_ID'];
    }

    /**
     * Check if user is an admin.
     */
    public function isAdmin()
    {
        return $this->hasGroupWithId(1);
    }

    /**
     * Check if this user is the operating user.
     */
    public function isCurrent()
    {
        global $USER;

Use of global functionality is not recommended; it makes your code harder to test, and less reusable.

        return $USER->getId() && $this->id == $USER->getId();
    }

    /**
     * Check if user has role with a given ID.
     *
     * @param $role_id
     *
     * @return bool
     */
    public function hasGroupWithId($role_id)
    {
        return in_array($role_id, $this->getGroups());
    }

    /**
     * Check if user is authorized.
     *
     * @return bool
     */
    public function isAuthorized()
    {
        global $USER;

Use of global functionality is not recommended; it makes your code harder to test, and less reusable.

        return ($USER->getId() == $this->id) && $USER->isAuthorized();
    }

    /**
     * Check if user is guest.
     *
     * @return bool
     */
    public function isGuest()
    {
        return ! $this->isAuthorized();
    }

    /**
     * Logout user.
     *
     * @return void
     */
    public function logout()
    {
        global $USER;

Use of global functionality is not recommended; it makes your code harder to test, and less reusable.

        $USER->logout();
    }

    /**
     * Scope to get only users from a given group / groups.
     *
     * @param UserQuery $query
     * @param int|array $id
     *
     * @return UserQuery
     */
    public function scopeFromGroup($query, $id)
    {
        $query->filter['GROUPS_ID'] = $id;

        return $query;
    }

    /**
     * Substitute old group with the new one.
     *
     * @param int $old
     * @param int $new
     *
     * @return void
     */
    public function substituteGroup($old, $new)
    {
        $groups = $this->getGroups();

        if(($key = array_search($old, $groups)) !== false) {
            unset($groups[$key]);
        }

        if (!in_array($new, $groups)) {
            $groups[] = $new;
        }

        $this->fields['GROUP_ID'] = $groups;
    }
}