colleague / study-project · Files

<?php
/**
 * RightService.class.php
 * 调研可见范围表
 *
 * @author: dj
 * @copyright: vchangyi.com
 */

namespace Common\Service;

use Common\Common\Department;
use Common\Common\Job;
use Common\Common\Role;
use Common\Common\Tag;
use Common\Common\User;
use Common\Model\RightModel;

class RightService extends AbstractService
{

    // 构造方法
    public function __construct()
    {

        $this->_d = new RightModel();

        parent::__construct();
    }

    /**
     * 组装权限信息表数据
     *
     * @param int $qu_id 调研ID
     * @param array $data 权限数据
     *
     * @return array|bool  入库权限数据
     */
    public function create_data($qu_id, $data)
    {

        // 权限用户
        $uid_arr = $data['user_list'];
        // 权限部门
        $dep_arr = $data['dp_list'];
        // 权限角色
        $role_arr = $data['role_list'];
        // 权限岗位
        $job_arr = $data['job_list'];
        // 权限标签
        $tag_arr = $data['tag_list'];

        if (empty($uid_arr) && empty($dep_arr) && empty($role_arr) && empty($job_arr) && empty($tag_arr)) {
            // 调研权限设置不能为空
            E('_EMPTY_IS_ALL');
        }

        // 组织权限用户数组
        $add_uid_data = [];
        if (!empty($uid_arr)) {

            foreach ($uid_arr as $v) {

                if (empty($v['memID'])) {

                    continue;
                }

                $add_uid_data[] = [
                    'qu_id' => $qu_id,
                    'uid' => $v['memID'],
                    'dp_id' => '',
                    'role_id' => '',
                    'job_id' => '',
                    'tag_id' => ''
                ];
            }
        }

        // 组织权限部门数组
        $add_dep_data = [];
        if (!empty($dep_arr)) {

            foreach ($dep_arr as $v) {

                if (empty($v['dpID'])) {

                    continue;
                }

                $add_dep_data[] = [
                    'qu_id' => $qu_id,
                    'uid' => '',
                    'dp_id' => $v['dpID'],
                    'role_id' => '',
                    'job_id' => '',
                    'tag_id' => ''
                ];
            }
        }

        // 组织权限角色数组
        $add_role_data = [];
        if (!empty($role_arr)) {

            foreach ($role_arr as $v) {

                if (empty($v['roleID'])) {

                    continue;
                }

                $add_role_data[] = [
                    'qu_id' => $qu_id,
                    'uid' => '',
                    'dp_id' => '',
                    'role_id' => $v['roleID'],
                    'job_id' => '',
                    'tag_id' => ''
                ];
            }
        }

        // 组织权限岗位数组
        $add_job_data = [];
        if (!empty($job_arr)) {

            foreach ($job_arr as $v) {

                if (empty($v['jobID'])) {

                    continue;
                }

                $add_job_data[] = [
                    'qu_id' => $qu_id,
                    'uid' => '',
                    'dp_id' => '',
                    'role_id' => '',
                    'job_id' => $v['jobID'],
                    'tag_id' => ''
                ];
            }
        }

        // 组织权限标签数组
        $add_tag_data = [];
        if (!empty($tag_arr)) {

            foreach ($tag_arr as $v) {

                if (empty($v['tagID'])) {

                    continue;
                }

                $add_tag_data[] = [
                    'qu_id' => $qu_id,
                    'uid' => '',
                    'dp_id' => '',
                    'role_id' => '',
                    'job_id' => '',
                    'tag_id' => $v['tagID']
                ];
            }
        }

        // 合并数组返回
        return array_merge($add_uid_data, $add_dep_data, $add_role_data, $add_job_data, $add_tag_data);
    }

    /**
     * 通过问卷ID获取参与总人数
     *
     * @param array $data 问卷数据
     *
     * @return int
     */
    public function user_count($data)
    {
        // 全公司
        if (RightModel::IS_ALL == $data['is_all']) {
            // 用户列表
            $result = User::instance()->listBasicByConds([], 1, 1);

            return rintval($result['total']);
        }

        $right = $data['right'];

        // 人员UID
        $uids = [];
        if (is_array($right['user_list'])) {
            $uids = array_filter(array_column($right['user_list'], 'memID'));
        }

        // 部门
        $dp_ids = [];
        if (is_array($right['dp_list'])) {
            $dp_ids = array_filter(array_column($right['dp_list'], 'dpID'));
        }

        // 获取岗位ID列表
        $jobIds = array_values(array_filter(array_column($right['job_list'], 'jobID'))) ?? [];

        // 获取角色ID列表
        $roleIds = array_values(array_filter(array_column($right['role_list'], 'roleID'))) ?? [];

        // 标签
        $tag_ids = [];
        if (is_array($right['tag_list'])) {
            $tag_ids = array_filter(array_column($right['tag_list'], 'tagID'));
        }
        if (!empty($tag_ids)) {
            sort($tag_ids);
            $tag_s = new Tag();
            $tag_list = $tag_s->listUserByTagId($tag_ids, 1, 1000);
            $tag_dp_id = array_filter(array_column($tag_list['list'], 'dpId'));
            $tag_uid = array_filter(array_column($tag_list['list'], 'memUid'));
            $uids = array_merge($uids, (array)$tag_uid);
            $dp_ids = array_merge($dp_ids, (array)$tag_dp_id);
        }

        // 部门ID
        $conds = [];
        $dp_uids = [];
        if (!empty($dp_ids)) {
            sort($dp_ids);
            $conds['dpIdList'] = $dp_ids;
            $conds['departmentChildrenFlag'] = 1;

            $dp_uids = User::instance()->listAll($conds);
            $dp_uids = array_column($dp_uids, 'memUid');
        }

        // 岗位
        $conds = [];
        $job_uids = [];
        if (!empty($jobIds)) {
            $conds['jobIdList'] = $jobIds;

            $job_uids = User::instance()->listAll($conds);
            $job_uids = array_column($job_uids, 'memUid');
        }

        // 角色
        $conds = [];
        $role_uids = [];
        if (!empty($roleIds)) {
            $conds['roleIdList'] = $roleIds;

            $role_uids = User::instance()->listAll($conds);
            $role_uids = array_column($role_uids, 'memUid');
        }

        // 合并所有uid
        $uids = array_merge($uids, $dp_uids, $job_uids, $role_uids);

        return count(array_filter(array_unique($uids)));
    }

    /**
     * 获取权限用户uid集合
     *
     * @param int $qu_id 调研id
     * @param int $is_all 是否全公司（0=否，1=是）
     *
     * @return array
     */
    public function list_user($qu_id = 0, $is_all = 0)
    {
        // 全公司
        if (RightModel::IS_ALL == $is_all) {
            // 用户列表

            $user_list = User::instance()->listAllBasic([]);

            return array_column($user_list, 'memUid');
        }

        // 获取权限列表
        $list = $this->_d->list_by_conds(['qu_id' => $qu_id]);

        // 获取用户UID列表
        $right['uids'] = array_filter(array_column($list, 'uid'));
        // 获取部门ID列表
        $right['dp_ids'] = array_unique(array_filter(array_column($list, 'dp_id')));
        // 获取角色ID列表
        $right['role_ids'] = array_unique(array_filter(array_column($list, 'role_id')));
        // 获取岗位ID列表
        $right['job_ids'] = array_unique(array_filter(array_column($list, 'job_id')));
        // 获取标签ID列表
        $right['tag_ids'] = array_unique(array_filter(array_column($list, 'tag_id')));

        // 人员UID
        $uids = isset($right['uids']) ? $right['uids'] : [];

        // 部门
        $dp_ids = [];
        if (isset($right['dp_ids'])) {
            $dp_ids = $right['dp_ids'];
        }

        // 标签
        $tag_ids = $right['tag_ids'];
        if (!empty($tag_ids)) {
            sort($tag_ids);
            $tag_s = new Tag();
            $tag_list = $tag_s->listUserByTagId($tag_ids, 1, 1000);
            $tag_dp_id = array_filter(array_column($tag_list['list'], 'dpId'));
            $tag_uid = array_filter(array_column($tag_list['list'], 'memUid'));
            $uids = array_merge($uids, (array)$tag_uid);
            $dp_ids = array_merge($dp_ids, (array)$tag_dp_id);
        }

        // 部门ID
        $conds = [];
        $dp_uids = [];
        if (!empty($dp_ids)) {
            sort($dp_ids);
            $conds['dpIdList'] = $dp_ids;
            $conds['departmentChildrenFlag'] = 1;

            $dp_uids = User::instance()->listAllBasic($conds);
            $dp_uids = array_column($dp_uids, 'memUid');
        }

        // 岗位
        $conds = [];
        $job_uids = [];
        if (!empty($right['job_ids'])) {
            $job_ids = $right['job_ids'];
            sort($job_ids);
            $conds['jobIdList'] = $job_ids;

            $job_uids = User::instance()->listAllBasic($conds);
            $job_uids = array_column($job_uids, 'memUid');
        }

        // 角色
        $conds = [];
        $role_uids = [];
        if (!empty($right['role_ids'])) {
            $role_ids = $right['role_ids'];
            sort($role_ids);
            $conds['roleIdList'] = $role_ids;

            $role_uids = User::instance()->listAllBasic($conds);
            $role_uids = array_column($role_uids, 'memUid');
        }
        // 合并所有uid
        $uids = array_merge($uids, $dp_uids, $job_uids, $role_uids);

        return array_filter(array_unique($uids));
    }

    /**
     * 根据用户ID、部门ID、角色ID、岗位ID获取有这些权限的问卷ID
     *
     * @param string $memID 用户ID
     * @param array $depIDs 部门ID数组
     * @param array $roleIDs 角色ID数组
     * @param array $jobIDs 岗位ID数组
     * @param array $tagIDs 标签ID数组
     *
     * @return array 返回有权限的问卷ID数组
     */
    public function get_list_id($memID, $depIDs = [], $roleIDs = [], $jobIDs = [], $tagIDs = [])
    {
        return $this->_d->get_list_id($memID, $depIDs, $roleIDs, $jobIDs, $tagIDs);
    }

    /**
     * 获取权限列表
     *
     * @param int $qu_id 问卷ID
     *
     * @return array
     */
    public function get_auth_info($qu_id)
    {

        // 返回的数据
        $result = [
            'user_list' => [],
            'dp_list' => [],
            'role_list' => [],
            'job_list' => [],
            'tag_list' => []
        ];

        // 获取问卷的所属权限列表
        $list = $this->list_by_conds(['qu_id' => $qu_id]);

        // 分别获取人员、部门和标签的ID
        $member_ids = array_filter(array_column($list, 'uid'));
        $dep_ids = array_filter(array_column($list, 'dp_id'));
        $role_ids = array_filter(array_column($list, 'role_id'));
        $job_ids = array_filter(array_column($list, 'job_id'));
        $tag_ids = array_filter(array_column($list, 'tag_id'));

        // 获取人员详情
        $members = $this->_get_members($member_ids);
        // 获取部门详情
        $deps = $this->_get_deps($dep_ids);
        // 获取角色详情
        $roles = $this->_get_roles($role_ids);
        // 获取角色详情
        $jobs = $this->_get_jobs($job_ids);
        // 获取标签详情
        $tags = $this->_get_tags($tag_ids);

        foreach ($list as $v) {

            if (!empty($v['uid']) && array_key_exists($v['uid'], $members)) {

                $result['user_list'][$v['uid']] = $members[$v['uid']];
            }

            if (!empty($v['dp_id']) && array_key_exists($v['dp_id'], $deps)) {

                $result['dp_list'][$v['dp_id']] = $deps[$v['dp_id']];
            }

            if (!empty($v['role_id']) && array_key_exists($v['role_id'], $roles)) {

                $result['role_list'][$v['role_id']] = $roles[$v['role_id']];
            }

            if (!empty($v['job_id']) && array_key_exists($v['job_id'], $jobs)) {

                $result['job_list'][$v['job_id']] = $jobs[$v['job_id']];
            }

            if (!empty($v['tag_id']) && array_key_exists($v['tag_id'], $tags)) {

                $result['tag_list'][$v['tag_id']] = $tags[$v['tag_id']];
            }
        }

        sort($result['user_list']);
        sort($result['dp_list']);
        sort($result['role_list']);
        sort($result['job_list']);
        sort($result['tag_list']);

        return $result;
    }

    /**
     * 根据用户ID查找用户信息详情
     *
     * @param array $ids 用户ID数组
     *
     * @return array 返回用户详情数组：[memUid:用户ID,memUsername:用户名,memFace:用户头像]
     */
    protected function _get_members($ids)
    {

        $result = [];
        sort($ids);

        // 获取人员详情
        $mem_obj = new User();
        $members = $mem_obj->listByUid($ids, true);

        // 循环人员获取详情返回
        foreach ($ids as $v) {

            if (array_key_exists($v, $members) && !empty($members[$v])) {

                $result[$v] = [
                    'memID' => $v,
                    'memUsername' => $members[$v]['memUsername'],
                    'memFace' => $members[$v]['memFace']
                ];
            }
        }

        return $result;
    }

    /**
     * 根据部门ID查找部门信息详情
     *
     * @param array $ids 部门ID数组
     *
     * @return array 返回部门详情数组：[dpId:部门ID,dpName:部门名称]
     */
    protected function _get_deps($ids)
    {

        // 如果部门ID组不存在
        if (empty($ids)) {

            return [];
        }

        $result = [];
        sort($ids);

        // 获取部门详情
        $dep_obj = new Department();

        // 获取所有部门详情
        $departments = $dep_obj->listById($ids, []);

        // 循环部门获取详情返回
        foreach ($ids as $v) {

            if (array_key_exists($v, $departments) && !empty($departments[$v])) {

                $result[$v] = [
                    'dpID' => $v,
                    'dpName' => $departments[$v]['dpName']
                ];
            }
        }

        return $result;
    }

    /**
     * 根据角色ID查找角色信息详情
     *
     * @param array $ids 角色ID数组
     *
     * @return array 返回角色详情数组：[roleID:角色ID,roleName:角色名]
     */
    protected function _get_roles($ids)
    {

        $result = [];
        sort($ids);

        // 获取角色详情
        $roleServ = &Role::instance();
        $roles = $roleServ->listById($ids);

        // 循环人员获取详情返回
        foreach ($ids as $v) {

            if (array_key_exists($v, $roles) && !empty($roles[$v])) {

                $result[$v] = [
                    'roleID' => $v,
                    'roleName' => $roles[$v]['roleName']
                ];
            }
        }

        return $result;
    }

    /**
     * 根据岗位ID查找岗位信息详情
     *
     * @param array $ids 岗位ID数组
     *
     * @return array 返回岗位详情数组：[jobID:岗位ID,jobName:岗位名]
     */
    protected function _get_jobs($ids)
    {

        $result = [];

        sort($ids);

        // 获取岗位详情
        $jobServ = &Job::instance();
        $jobs = $jobServ->listById($ids);

        // 循环人员获取详情返回
        foreach ($ids as $v) {

            if (array_key_exists($v, $jobs) && !empty($jobs[$v])) {

                $result[$v] = [
                    'jobID' => $v,
                    'jobName' => $jobs[$v]['jobName']
                ];
            }
        }

        return $result;
    }

    /**
     * 根据标签ID查找标签信息详情
     *
     * @param array $ids 标签ID数组
     *
     * @return array 返回标签详情数组：[tagID:标签ID,tagName:标签名]
     */
    protected function _get_tags($ids)
    {

        $result = [];

        sort($ids);

        // 获取岗位详情
        $tagServ = &Tag::instance();
        $tags = $tagServ->listAll($ids);
        $tags = array_column($tags, null, 'tagId');

        // 循环人员获取详情返回
        foreach ($ids as $v) {

            if (array_key_exists($v, $tags) && !empty($tags[$v])) {

                $result[$v] = [
                    'tagID' => $v,
                    'tagName' => $tags[$v]['tagName']
                ];
            }
        }

        return $result;
    }
}