Arrilot\BitrixModels\Models\UserModel

Complexity

Total Complexity

26

Size/Duplication

Total Lines	237
Duplicated Lines	7.59 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	9
Bugs	0	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	query()	0	4	1
A	current()	0	12	2
A	afterFill()	0	6	3
A	fillGroups()	0	6	1
A	get()	0	8	1
A	getGroups()	0	8	2
A	refresh()	0	8	1
A	refreshFields()	18	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	logout()	0	6	1
A	scopeFromGroup()	0	6	1

<?php

namespace Arrilot\BitrixModels\Models;

use Arrilot\BitrixModels\Queries\UserQuery;

class UserModel extends BaseModel
{
    /**
     * Bitrix entity object.
     *
     * @var object
     */
    public static $bxObject;

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

    /**
     * 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.
     *
     * @param null $fields
     *
     * @return static
     */
    public static function current($fields = null)
    {
        global $USER;

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

        $user = new static($USER->getId());

        if (!is_null($fields)) {
            $user->fill($fields);
        }

        return $user;
    }

    /**
     * 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;
    }

    /**
     * Get all model attributes from cache or database.
     *
     * @return array
     */
    public function get()
    {
        $this->getFields();

        $this->getGroups();

        return $this->fields;
    }

    /**
     * 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()

This method seems to be duplicated in your project.

    {
        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();
    }

    /**
     * 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;
    }
}