example

<?php

use \Progsmile\Validator\Validator as V;

class UsersController extends BaseController
{

    public function onConstruct()
    {
        parent::onConstruct();
    }





    /**
     * Страница управления пользователями
     */
    public function indexAction()
    {
        $allUsers            = Users::getSubUsers($this->user->id);
        $this->view->experts = Users::find(["conditions" => "role_id = ?0", "bind" => [Roles::ROLE_EXPERT]]);
        $this->view->users   = $allUsers;

        //это нужно для того чтобы поддержать иерархическую связь
        //директор - админ - секретарь | - эксперт -агент
        array_shift($allUsers);
        array_walk_recursive($allUsers, function ($elem) use (&$flatUsers) {
            $flatUsers[] = $elem;
        });

        $this->view->flatUsers = $flatUsers;
    }





    public function agentsAction()
    {
        $this->view->pick(['users/index']);
        $this->view->users = $this->user->getChildUsers(Roles::ROLE_AGENT);
    }





    /**
     * Create new user
     */
    public function addUserAction()
    {
        $this->view->title = 'Добавить пользователя';
        $this->view->roles = Roles::find();
    }





    /**
     * Save user to DB
     * @return mixed
     */
    public function saveAction()
    {
        $this->setupAjaxRequest();

        //чистка
        $postData = Input::sanitize($this->request->getPost());


        // если роль которую добавляем больше роли пользователя
        // например эксперт хочет добавить админа О_о
        $this->checkPermissions(intval($postData['role_id']));

        //Валидация
        $validationResult = Users::validateUser($postData);


        if ($validationResult->fails()) {
            $this->sendJSON(['status' => ResponseStatus::FAIL, 'message' => $validationResult->first('password')]);
        }

        $userCreatedCode = Users::createUser($postData);

        if ($userCreatedCode) {
            $this->sendJSON(['status' => ResponseStatus::OK, 'code' => $userCreatedCode]);
        }

        //fail
        $this->sendJSON();
    }





    /**
     * Активировать или деактивировать пользователя
     * @param $action 1 - для активации, 0 - для выключения
     * @param $id
     */
    public function manageActivationAction($action, $id)
    {
        /** @var Users $user */
        $user = Users::findFirst($id);

        //проверка прав
        if ($this->checkPermissions($user->role_id)) {
            $user->is_active = ($action) ? UserStatus::USER_ACTIVE : UserStatus::USER_NOT_ACTIVE;
            $user->save();
        }

        $this->redirectBack();
    }





    // метод добавляет комментарий при удаления пользователя.
    public function addCommentaryAction($id)
    {

        $this->view->setVars([

           'users' => Users::findFirst($id),

        ]);

        $this->view->pick('users/commentary');
    }





    /**
     * Удалить пользователя по ID
     * @param $id
     * @return mixed
     */
    public function deleteAction($id)
    {
        $this->setupAjaxRequest();

        $user = Users::findFirst($id);

        if ($this->user->role_id > $user->role_id) {
            $user->is_deleted = 1;
            $user->commentary = $this->request->getPost()['commentary'];
            $user->deleted_at = now();
            $user->save();
        }

        return $this->redirectBack();
    }





    /**
     * Изменение пароля пользователя
     * @param $id
     */
    public function changePasswordAction($id)
    {
        $this->setupAjaxRequest();
        /** @var Users $user */
        if ($user = Users::findFirst($id)) {

            $this->checkPermissions($user->role_id);

            $postData = $this->request->getPost();

            $user->password = $this->security->hash($postData['password']); //срабатывает beforeSave и пароль хэшируется

            $user->save();

        }
    }





    /**
     * Проверка прав доступа
     *
     * @param $roleID
     * @return bool
     */
    protected function checkPermissions($roleID)
    {
        if ($this->user->role_id < $roleID) {
            $this->flash->error('Нет прав');

            return $this->redirectBack();
        }

        return true;
    }

}








<?php

use Phalcon\Validation\Message;
use Phalcon\Mvc\Model\Query;
use \Progsmile\Validator\Validator as V;

class Users extends Phalcon\Mvc\Model
{
    use SearchTrait;

    public $id;
    public $role_id;
    public $full_name;
    public $last_access;
    public $code;
    public $password;
    public $is_deleted;
    public $is_active;
    public $created_at;
    public $parent_id;
    public $deleted_at;
    public $commentary;
    public $count_enters;
    public $deleted_from_db;
    public $customers_added;
    public $objects_added;
    public $deleted_cust_from_room;
    public $deleted_obj_from_room;





    public static function getAgentExpertCodes($userID)
    {
        $cacheKey = 'users.agent.codes';

        $cache = Phalcon\Di::getDefault()->get('modelsCache');

        $users = $cache->get($cacheKey);

        if ( !$users) {

            $queriedUsers = Users::find(['columns' => 'id, code, parent_id'])->toArray();

            $users = [];
            foreach ($queriedUsers as $user) {
                $users[$user['id']] = ['code' => $user['code'], 'parent_id' => $user['parent_id']];
            }

            $cache->save($cacheKey, $users);
        }

        $agent      = $users[$userID];
        $agentCode  = $agent['code'];
        $expertCode = $users[$agent['parent_id']]['code'];

        return $agentCode . ', ' . $expertCode;
    }





    public function initialize()
    {
        //Блокноты
        $this->hasMany('id', Blocknotu::class, 'user_id', ['alias' => 'blocknotu']);


        //Показы
        $this->hasMany('id', Pokazu::class, 'user_id', [
           'alias'  => 'pokazuKvs',
           'params' => [
              'conditions' => 'realty_type = 1',
           ],
        ]);

        $this->hasMany('id', Pokazu::class, 'user_id', [
           'alias'  => 'pokazuDomov',
           'params' => [
              'conditions' => 'realty_type = 2',
           ],
        ]);

        //Сделки
        $this->hasManyToMany('id', Pokazu::class, 'user_id', 'id', Sdelki::class, 'pokaz_id', [
           'alias'  => 'sdelkiKvs',
           'params' => ['conditions' => 'realty_type = "' . RealtyTip::REALTY_KVARTIRA . '"'],
        ]);

        $this->hasManyToMany('id', Pokazu::class, 'user_id', 'id', Sdelki::class, 'pokaz_id', [
           'alias'  => 'sdelkiDomov',
           'params' => ['conditions' => 'realty_type = "' . RealtyTip::REALTY_DOM . '"'],
        ]);


        //Задатки
        $this->hasManyToMany('id', Pokazu::class, 'user_id', 'id', Zadatki::class, 'pokaz_id', [
           'alias'  => 'zadatkiKvs',
           'params' => ['conditions' => 'realty_type = "' . RealtyTip::REALTY_KVARTIRA . '"'],
        ]);

        $this->hasManyToMany('id', Pokazu::class, 'user_id', 'id', Zadatki::class, 'pokaz_id', [
           'alias'  => 'zadatkiDomov',
           'params' => ['conditions' => 'realty_type = "' . RealtyTip::REALTY_DOM . '"'],
        ]);


        //Реклама
        $this->hasMany('id', ReklamaKv::class, 'user_id', ['alias' => 'reklamaKv']);

        $this->hasMany('id', ReklamaDoma::class, 'user_id', ['alias' => 'reklamaDoma']);


        //Клиенты квартир
        $this->hasManyToMany('id', UserClientu::class, 'user_id', 'client_id', CustomersKv::class, 'id', [
           'alias'  => 'clientsKv',
           'params' => ['conditions' => 'client_type = "' . RealtyTip::REALTY_KVARTIRA . '"'],
        ]);

        //Клиенты домов
        $this->hasManyToMany('id', UserClientu::class, 'user_id', 'client_id', CustomersDoma::class, 'id', [
           'alias'  => 'clientsDoma',
           'params' => ['conditions' => 'client_type = "' . RealtyTip::REALTY_DOM . '"'],
        ]);


        //Квартиры в объектах
        $this->hasManyToMany('id', UserObjects::class, 'user_id', 'object_id', Kvartiru::class, 'id', [
           'alias'  => 'kvartiru',
           'params' => ['conditions' => 'object_type = "' . RealtyTip::REALTY_KVARTIRA . '"'],
        ]);

        //Дома в объектах
        $this->hasManyToMany('id', UserObjects::class, 'user_id', 'object_id', Doma::class, 'id', [
           'alias'  => 'doma',
           'params' => ['conditions' => 'object_type = "' . RealtyTip::REALTY_DOM . '"'],
        ]);

    }





    /**
     * Обновить профиль пользователя.
     *
     * @param $userID
     * @param $postData
     * @return bool
     */
    public static function updateProfile($userID, $postData)
    {
        /** @var Users $user */
        if ($user = Users::findFirst($userID)) {

            $user->save([
               'created_at' => isset($postData['created_at']) ? $postData['created_at'] : $user->created_at,
            ]);

            UserSites::updateLinks($postData, $userID);

            UsersPhones::updatePhones($postData, $userID);

            return true;
        }

        return false;
    }





    /**
     * Получить всех подчиненных текущего пользователя
     * @param $userID
     * @return array | null
     */
    public static function getSubUsers($userID)
    {
        $subUsers = [];
        foreach (Users::find(["conditions" => "is_deleted = ?0", "bind" => [0 => 0]])->toArray() as &$user) {
            $subUsers[$user['parent_id']][$user['id']] = $user;
        }

        //get only parent nodes
        $subUsers = Users::create_tree($subUsers, $userID);
        $newQuery = [];

        //tree array to flat array
        array_walk_recursive($subUsers, function (&$elem) use (&$newQuery) {
            $newQuery[] = $elem;
        });

        //group array by role
        $subUsers = [];
        foreach ($newQuery as &$val) {
            $subUsers[$val->role_id][] = $val;
        }

        //sort keys
        ksort($subUsers);

        return $subUsers;
    }





    /**
     * Сформировать дерево пользователей
     * @param $subUsers
     * @param $parentID
     * @return array|null
     */
    private static function create_tree($subUsers, $parentID)
    {
        if (is_array($subUsers) && isset($subUsers[$parentID])) {
            $tree = [];

            foreach ($subUsers[$parentID] as &$cat) {

                if ($cat) {
                    $tree[] = (object)$cat;
                }

                $result = self::create_tree($subUsers, $cat['id']);

                if ($result) {
                    $tree[] = $result;
                }
            }

        } else {
            return null;
        }

        return $tree;
    }





    /**
     * Авторизировать
     */
    public function authorize()
    {
        $this->getDI()->getSession()->set('user', $this);
        $this->count_enters++;

        if (in_array($this->role_id, [Roles::ROLE_AGENT, Roles::ROLE_AGENT])) {
            UserSites::initUserLinks($this->id);
        }

        $this->save();

    }





    /**
     * После создания пользователя
     * Создать ссылки на рекламные аккаунты
     */
    public function afterCreate()
    {
        if (in_array($this->role_id, [Roles::ROLE_AGENT, Roles::ROLE_EXPERT])) {
            UserSites::initUserLinks($this->id);
        }
    }





    public function beforeCreate()
    {
        if ( !$this->created_at) {
            $this->created_at = now();
        }
    }





    public function beforeDelete()
    {
        $this->is_active  = false;
        $this->is_deleted = true;
        $this->deleted_at = now();

        return isset($this->forceDelete);
    }





    /**
     * Создать пользователя
     *
     * @param $postData
     * @return string
     */
    public static function createUser($postData)
    {
        $user = new Users();
        $user->assignData($postData);

        //специально для агента
        $tempParentID = 0;
        if ($postData['role_id'] == Roles::ROLE_AGENT) {
            $tempParentID = $postData['parent_id'];
        }

        //сформировать код
        $user->code = UsersCodeResolver::extractUserCode($user->role_id, $tempParentID);

        $user->save();

        return $user->code;
    }





    /**
     * Инициализировать поля
     *
     * @param $postData
     */
    public function assignData($postData)
    {
        $securityService  = Phalcon\DI::getDefault()->getSecurity();
        $this->password   = $securityService->hash($postData['password']);
        $this->role_id    = $postData['role_id'];
        $this->parent_id  = $postData['parent_id'];
        $this->created_at = now();
    }





    /**
     * User creating validation
     *
     * @param $postData
     *
     * @return \Progsmile\Validator\Helpers\ValidatorFacade
     */
    public static function validateUser($postData)
    {
        $validationResult = V::make($postData, [
           'password' => 'required|min:5',
        ], [
           'password.required' => 'Введите пароль',
           'password.min'      => 'Пароль слишком короткий',
        ]);

        return $validationResult;
    }





    /**
     * Создать код для пользователя
     * @return string
     */
    private function makeCode($expertID, $expertCode)
    {
        $code = $this->id;

        switch ($this->role_id) {
            case Roles::ROLE_ADMIN:
                $code = $this->getUserWithMaxCode(4, 'a');
                break;

            case Roles::ROLE_SECRETARY:
                $code = $this->getUserWithMaxCode(3, 's');
                break;

            case Roles::ROLE_EXPERT:
                $user = self::findFirst(["conditions" => "role_id = ?0 order by code DESC", "bind" => [0 => 2]]);
                $code = $user->code + 1000;
                break;

            case Roles::ROLE_AGENT:
                $getLastSubUsersCode = Users::findFirst([
                   "conditions" => "parent_id = ?0 order by id DESC",
                   "bind"       => [0 => $expertID],
                ])->code;
                $code                = $getLastSubUsersCode ? $getLastSubUsersCode + 1 : $expertCode + 1;
                break;
        }

        $this->code = $code;
        $this->save();

        return $this->code;
    }





    // Метод получает из БД код последнего добавленного секретаря или админа и генерирует из этих данных код для нового юзера.
    private function getUserWithMaxCode($role, $name)
    {
        $newCodeParts = [];

        $userLastCode = str_split(self::findFirst([
           "conditions" => "role_id = ?0 order by id DESC",
           "bind"       => [0 => $role],
        ])->code);

        for ($i = 1; $i < count($userLastCode); $i++) {

            $newCodeParts[] = $userLastCode[$i];
        }

        $newCodeNumbers = (integer)implode($newCodeParts) + 1;
        $code           = $name . $newCodeNumbers;

        return $code;
    }





    /**
     * Получить ID эксперта
     */
    public function getExpert()
    {
        return Users::findFirstByParentId($this->id);
    }





    /**
     * Повертае всiх cекретарiв
     * @return mixed
     */
    public static function getAllSecretaries()
    {
        return static::find([
           'conditions' => 'role_id = ?0',
           'bind'       => [Roles::ROLE_SECRETARY],
        ]);
    }





    // Считает количество дней, которые юзер работает в Аверсе.
    public function howLongWorking($id)
    {
        $user = self::findFirst(["conditions" => "id = ?0", "bind" => [$id]]);

        if ($user->created_at !== null) {
            $timestampCreatting = strtotime($user->created_at);
            $timestampNow       = time();
            $dayWorking         = floor(($timestampNow - $timestampCreatting) / 86400);

            return $dayWorking;
        }

        return 0;
    }





    // Метод возвращает массив уволенных сотрудников, с датами принятия на работу и увольния.
    public function getHiredFiredData()
    {
        $getUsers   = self::find([
           "conditions" => "role_id = ?0 AND is_deleted = ?1",
           "bind"       => [Roles::ROLE_AGENT, 1],
        ]);
        $firedUsers = [];

        foreach ($getUsers as $key => $value) {

            $value->created_at = explode(' ', $value->created_at)[0];
            $value->deleted_at = explode(' ', $value->deleted_at)[0];
            $firedUsers[]      = $value;
        }

        return $firedUsers;
    }





    /**-------------------------------------
     * Получить текущего пользователя
     *
     * @return Users
     *-------------------------------------*/
    public static function getCurrentUserID()
    {
        /** @var Users $user */
        $user = Phalcon\Di::getDefault()->get('session')->get('user');


        return $user ? $user->id : 0;
    }
}