colleague / study-project · Files

<?php
/**
 * Created by PhpStorm.
 * User: yingcai
 * Date: 2018/3/23
 * Time: 下午4:05
 */

namespace Common\Service;

use Common\Common\Constant;
use Common\Common\Department;
use Common\Common\Job;
use Common\Common\Role;
use Common\Common\User;
use Common\Common\UserCache;
use Common\Model\RightModel;

class RightService extends AbstractService
{
    // 构造方法
    public function __construct()
    {
        $this->_d = new RightModel();

        parent::__construct();
    }

    /**
     * 写入权限范围数据
     *
     * @author houyingcai
     * @param array $right 权限范围
     * @param int $ac_id 活动ID
     *
     * @return bool
     */
    public function save_right_data($right, $ac_id)
    {

        $insert_data = [];

        // 对象范围种类
        $right_type = [
            'uids' => Constant::RIGHT_TYPE_UID,
            'dp_ids' => Constant::RIGHT_TYPE_DEPARTMENT,
            'job_ids' => Constant::RIGHT_TYPE_JOB,
            'role_ids' => Constant::RIGHT_TYPE_ROLE
        ];

        foreach ($right_type as $type => $type_number) {

            foreach ($right[$type] as $id) {

                if (empty($id)) {
                    continue;
                }

                $insert_data[] = [
                    'ac_id' => $ac_id,
                    'obj_id' => $id,
                    'type' => $type_number,
                ];
            }
        }

        if (empty($insert_data)) {

            E('_ERR_RIGHT_CAN_NOT_EMPTY');
        }

        $this->_d->insert_all($insert_data);

        return true;
    }


    /**
     * 格式化数据库中的权限数据
     *
     * @author houyingcai
     * @param array $rights 权限数据
     *
     * @return array
     */
    public function format_db_data($rights)
    {
        $data = [];

        // 数据分组
        foreach ($rights as $right) {
            $data[$right['type']][] = $right['obj_id'];
        }

        return $data;
    }

    /**
     * 格式化用户输入的权限数据
     *
     * @author houyingai
     * @param array $rights 权限数据
     *
     * @return array
     */
    public function format_post_data($rights)
    {
        $data = [];

        foreach ($rights as $k => $v) {

            // 过滤空数组
            if (!is_array($v) || empty($v)) {
                continue;
            }

            // 数据分组
            switch ($k) {
                case 'uids':
                    $data[Constant::RIGHT_TYPE_UID] = $v;
                    break;
                case 'dp_ids':
                    $data[Constant::RIGHT_TYPE_DEPARTMENT] = $v;
                    break;
                case 'job_ids':
                    $data[Constant::RIGHT_TYPE_JOB] = $v;
                    break;
                case 'role_ids':
                    $data[Constant::RIGHT_TYPE_ROLE] = $v;
                    break;
            }
        }

        return $data;
    }

    /**
     * 比较权限数据，并返回需要新增和删除的数据
     *
     * @author houyingcai
     * @param array $rights_db 数据库中的权限数据
     * @param array $rights_post 用户输入的权限数据
     *
     * @return array
     */
    public function diff_data($rights_db, $rights_post)
    {
        $keys = [
            Constant::RIGHT_TYPE_UID,
            Constant::RIGHT_TYPE_DEPARTMENT,
            Constant::RIGHT_TYPE_JOB,
            Constant::RIGHT_TYPE_ROLE,
        ];

        $data = [];

        // 遍历所有权限类型
        foreach ($keys as $key) {
            $rights_old = isset($rights_db[$key]) ? $rights_db[$key] : [];
            $rights_new = isset($rights_post[$key]) ? $rights_post[$key] : [];

            // 需要删除的数据
            $data[$key]['del'] = array_diff($rights_old, $rights_new);

            // 需要新增的数据
            $data[$key]['add'] = array_diff($rights_new, $rights_old);
        }

        return $data;
    }

    /**
     * 保存权限数据
     * @author houyingcai
     * @param array $conds 权限筛选条件
     * @param array $data 权限数据
     *        + array uids 用户ID
     *        + array dp_ids 部门ID
     *        + array job_ids 职位ID
     *        + array role_ids 角色ID
     * @return bool
     */
    public function update_right_data($conds, $data)
    {
        if (!is_array($conds) || empty($conds) || !is_array($data) || empty($data)) {

            return false;
        }

        $list = $this->_d->list_by_conds($conds);
        $rights_db = $this->format_db_Data($list);

        $rights_post = $this->format_post_data($data);
        $rights = $this->diff_data($rights_db, $rights_post);

        $insert_data = [];

        foreach ($rights as $k => $v) {
            // 删除数据
            if (!empty($v['del'])) {
                $del_conds = array_merge($conds, ['type' => $k, 'obj_id' => $v['del']]);
                $this->delete_by_conds($del_conds);
            }

            // 新增数据
            foreach ($v['add'] as $obj_id) {
                $insert_data[] = array_merge($conds, [
                    'type' => $k,
                    'obj_id' => $obj_id,
                ]);
            }
        }

        // 批量插入新增数据
        if (!empty($insert_data)) {
            $this->insert_all($insert_data);
        }

        return true;
    }

    /**
     * 获取权限详情
     * @param int $ac_id 活动ID
     * @param int $is_all 是否全公司
     * @return array
     */
    public function get_right_detail($ac_id = 0, $is_all = 0)
    {

        $user_list = []; // 初始化用户列表数据
        $dp_list = [];   // 初始化部门信息列表
        $job_list = [];  // 初始化岗位信息列表
        $role_list = []; // 初始化角色信息列表

        if (Constant::IS_ALL_TRUE == $is_all) {
            // 如果是全公司
            return [
                'user_list' => $user_list,
                'dp_list' => $dp_list,
                'job_list' => $job_list,
                'role_list' => $role_list
            ];
        }

        // 格式化权限数据
        list($uids, $dp_ids, $job_ids, $role_ids) = $this->format_right($ac_id);

        // 如果用户uid集合不为空
        if (!empty($uids)) {

            $user_s = &User::instance();
            // 查询用户列表
            $user_arr = $user_s->listByUid($uids);
            foreach ($user_arr as $user) {
                // 遍历组装数据
                $user_list[] = [
                    'memID' => $user['memUid'],
                    'memUsername' => $user['memUsername'],
                    'memFace' => $user_s->avatar($user['memUid'], $user)
                ];
            }
        }

        // 如果组织ID不为空
        if (!empty($dp_ids)) {

            $department_s = &Department::instance();
            // 查询部门列表
            $dp_arr = $department_s->listById($dp_ids);
            foreach ($dp_arr as $dp) {
                // 遍历组装数据
                $dp_list[] = [
                    'dpID' => $dp['dpId'],
                    'dpName' => $dp['dpName'],
                ];
            }
        }


        // 如果岗位ID不为空
        if (!empty($job_ids)) {

            $job_s = &Job::instance();
            // 查询岗位列表
            $job_arr = $job_s->listById($job_ids);
            foreach ($job_arr as $job) {
                // 遍历组装数据
                $job_list[] = [
                    'jobID' => $job['jobId'],
                    'jobName' => $job['jobName'],
                ];
            }
        }

        // 如果角色ID不为空
        if (!empty($role_ids)) {

            $role_s = &Role::instance();
            // 查询岗位列表
            $role_arr = $role_s->listById($role_ids);
            foreach ($role_arr as $role) {
                // 遍历组装数据
                $role_list[] = [
                    'roleID' => $role['roleId'],
                    'roleName' => $role['roleName'],
                ];
            }
        }

        return [
            'user_list' => $user_list,
            'dp_list' => $dp_list,
            'job_list' => $job_list,
            'role_list' => $role_list
        ];
    }


    /**
     * 获取活动有权参与人员uid集合
     * @param array $info 活动详情
     * @return array
     */
    public function get_uids_by_right($info = [])
    {

        if (Constant::IS_ALL_TRUE == $info['is_all']) {
            // 获取全部人员
            $list = UserCache::get_all_user_by_cache_list([]);

            $uids = array_column($list, 'memUid');

            unset($list);

            return $uids;
        }

        // 格式化权限数据
        list($uids, $dp_ids, $job_ids, $role_ids) = $this->format_right($info['ac_id']);

        $User = User::instance();

        // 如果部门ID存在
        if (!empty($dp_ids)) {

            sort($dp_ids);

            // 获取部门列表详情
            $dp_users = $User->listAllBasic(['dpIdList' => $dp_ids, 'departmentChildrenFlag' => 1, 'memSubscribeStatus' => 1]);

            if (!empty($dp_users)) {
                // 获取uid集合
                $u_ids = array_column($dp_users, 'memUid');

                // 合并数组
                $uids = array_merge($uids, $u_ids);
            }

        }

        // 处理岗位
        if (!empty($job_ids)) {

            $job_ids = array_unique($job_ids);
            sort($job_ids);

            // 获取岗位列表
            $job_list = $User->listAllBasic(['jobIdList' => $job_ids, 'memSubscribeStatus' => 1]);

            if (!empty($job_list)) {
                // 获取uid集合
                $u_ids = array_column($job_list, 'memUid');

                // 合并数组
                $uids = array_merge($uids, $u_ids);
            }

        }

        // 处理角色
        if (!empty($role_ids)) {

            $role_ids = array_unique($role_ids);

            sort($role_ids);

            // 获取角色列表
            $role_list = $User->listAllBasic(['roleIdList' => $role_ids, 'memSubscribeStatus' => 1]);

            if (!empty($role_list)) {
                // 获取uid集合
                $u_ids = array_column($role_list, 'memUid');

                // 合并数组
                $uids = array_merge($uids, $u_ids);
            }
        }


        $uids = array_unique(array_filter($uids));

        sort($uids);

        return $uids;
    }


    /**
     * 格式化权限数据
     * @param int $ac_id 活动ID
     * @return array
     */
    public function format_right($ac_id = 0)
    {

        // 查询权限列表
        $right_list = $this->_d->list_by_conds(['ac_id' => $ac_id]);

        $uids = [];     // 用户uid集合
        $dp_ids = [];   // 部门id集合
        $job_ids = [];  // 岗位id集合
        $role_ids = []; // 角色id集合

        // 循环组装各个类型权限的ID集合
        foreach ($right_list as $v) {

            switch ($v['type']) {
                case Constant::RIGHT_TYPE_UID: // 用户
                    $uids[] = $v['obj_id'];
                    break;
                case Constant::RIGHT_TYPE_DEPARTMENT: // 部门
                    $dp_ids[] = $v['obj_id'];
                    break;
                case Constant::RIGHT_TYPE_JOB: // 岗位
                    $job_ids[] = $v['obj_id'];
                    break;
                case Constant::RIGHT_TYPE_ROLE: // 角色
                    $role_ids[] = $v['obj_id'];
                    break;
                default:
                    break;
            }
        }

        return [$uids, $dp_ids, $job_ids, $role_ids];
    }

    /**
     * 获取用户权限数据
     * @author zhonglei
     * @param array $user 用户信息
     * @return array
     */
    public function getUserRight($user)
    {
        $data = [];

        if (!is_array($user) || empty($user)) {
            return $data;
        }

        // 部门
        if (isset($user['dpName']) && !empty($user['dpName'])) {
            $dp_ids = array_column($user['dpName'], 'dpId');
            // 合并标签成员中的部门ID
            if (!empty($dp_ids)) {
                $dp_ids = array_unique(array_merge($data, $dp_ids));
            }

            $dpServ = &Department::instance();
            $parent_ids = [];

            // 取父级部门ID
            foreach ($dp_ids as $dp_id) {
                $dpServ->list_parent_cdids($dp_id, $parent_ids);
            }

            $dp_ids = array_merge($dp_ids, array_values($parent_ids));

            $data = array_unique($dp_ids);
        }

        // 用户
        $data[] = $user['memUid'];

        // 职位
        if (isset($user['job']['jobId'])) {
            $data[] = $user['job']['jobId'];
        }

        // 角色
        if (isset($user['role']['roleId'])) {
            $data[] = $user['role']['roleId'];
        }

        return $data;
    }


    /**
     * 获取参与活动权限（部门、人员、岗位、角色）
     * @author houyingcai
     * @param array $right 参与权限
     * @return array
     */
    public function list_by_right($right)
    {
        // 初始化保存人员UID
        $right['uids'] = !empty($right['uids']) ? array_unique($right['uids']) : [];

        // 部门ID去重
        $right['dp_ids'] = !empty($right['dp_ids']) ? array_unique($right['dp_ids']) : [];

        // 岗位ID去重
        $right['job_ids'] = !empty($right['job_ids']) ? array_unique($right['job_ids']) : [];

        // 角色ID去重
        $right['role_ids'] = !empty($right['role_ids']) ? array_unique($right['role_ids']) : [];


        return $right;
    }
}