<?php
/**
 * 试卷-权限表
 * @author: houyingcai
 * @email:  594609175@qq.com
 * @date :  2017-05-19 17:50:52
 */

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

    /**
     * 格式化数据库中的权限数据
     *
     * @author daijun
     *
     * @param array $rights 权限数据
     *
     * @return array
     */
    public function format_db_data($rights)
    {
        $data = [];
        // 数据分组
        $data['uids'] = array_values(array_filter(array_column($rights, 'uid')));
        $data['dp_ids'] = array_values(array_filter(array_column($rights, 'cd_id')));
        $data['job_ids'] = array_values(array_filter(array_column($rights, 'job_id')));
        $data['role_ids'] = array_values(array_filter(array_column($rights, 'role_id')));
        $data['tag_ids'] = array_values(array_filter(array_column($rights, 'tag_id')));

        return $data;
    }

    /**
     * 获取格式化后的权限数据
     *
     * @author daijun
     *
     * @param array $conds 权限筛选条件
     * @param bool $skip_deleted 是否跳过查询删除
     *
     * @return  array $data 组装后权限数组
     *          + array dp_list   部门信息
     *                    + string dp_id   部门ID
     *                    + string dp_name 部门名称
     *          + array user_list 人员信息
     *                    + string uid      用户ID
     *                    + string username 用户姓名
     *                    + string face     头像
     *           array $list 原始权限数组
     */
    public function get_right_data($conds, $skip_deleted = false)
    {

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

        // 导入类型
        $conds['source_type'] = self::RIGHT_SOURCE_TYPE_IMPORT;
        // 查询导入人员数量
        $import_num = $this->_d->count_by_conds($conds);

        $rights_db = $this->format_db_data($list);

        $data = [
            'user_list' => [],
            'dp_list' => [],
            'job_list' => [],
            'role_list' => [],
            'tag_list' => []
        ];

        $dpServ = &Department::instance();
        $userServ = &User::instance();
        $jobServ = &Job::instance();
        $roleServ = &Role::instance();
        $tagServ = &Tag::instance();

        // 部门
        if (!empty($rights_db['dp_ids'])) {

            sort($rights_db['dp_ids']);
            $dps = $dpServ->listById($rights_db['dp_ids']);
            foreach ($dps as $dp) {
                $data['dp_list'][] = [
                    'dpID' => $dp['dpId'],
                    'dpName' => $dp['dpName'],
                ];
            }
        }

        // 人员
        if (!empty($rights_db['uids'])) {

            sort($rights_db['uids']);
            // 查询
            $users = $userServ->listAll(['memUids' => $rights_db['uids']]);
            // 查询出来的用户UID列表
            $uid_list = array_column($users, 'memUid');

            // 跳过查询删除
            if (!$skip_deleted) {
                // 获取被删除的用户
                $this->user_list($users, $rights_db['uids'], $uid_list);
            }

            foreach ($users as $user) {
                $data['user_list'][] = [
                    'memID' => $user['memUid'],
                    'memUsername' => $user['memUsername'],
                    'memFace' => $user['memFace'],
                ];
            }
        }

        // 岗位
        if (!empty($rights_db['job_ids'])) {

            $jobs = $jobServ->listById($rights_db['job_ids']);
            foreach ($jobs as $job) {
                $data['job_list'][] = [
                    'jobID' => $job['jobId'],
                    'jobName' => $job['jobName'],
                ];
            }
        }

        // 角色
        if (!empty($rights_db['role_ids'])) {

            $roles = $roleServ->listById($rights_db['role_ids']);
            foreach ($roles as $role) {
                $data['role_list'][] = [
                    'roleID' => $role['roleId'],
                    'roleName' => $role['roleName'],
                ];
            }
        }

        // 标签
        if (!empty($rights_db['tag_ids'])) {

            $tags = $tagServ->listById($rights_db['tag_ids']);
            foreach ($tags as $tag) {
                $data['tag_list'][] = [
                    'tagID' => $tag['tagId'],
                    'tagName' => $tag['tagName'],
                ];
            }
        }

        return [$list, $data, $import_num];
    }

    /**
     * 获取权限表中的人员(即应参与人员集合)
     *
     * @author houyingcai
     *
     * @param array $right 权限数据
     *
     * @return array
     */
    public function list_uids_by_right($right)
    {
        $userServ = &User::instance();
        if ($right['is_all'] == self::AUTH_ALL) {
            // 获取全部人员
            $result = $userServ->listBasicByConds([], 1, 1);
            $total = $result['total'];
            $result = $userServ->listBasicByConds([], 1, $total);
            $uids = array_column($result['list'], 'memUid');

            return $uids;
        }

        // 人员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)) {
            $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)) {
            $conds['dpIdList'] = $dp_ids;
            $conds['departmentChildrenFlag'] = 1;

            $dp_uids = $userServ->listAll($conds);
            $dp_uids = array_column($dp_uids, 'memUid');
        }

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

            $job_uids = $userServ->listAll($conds);
            $job_uids = array_column($job_uids, 'memUid');

        }

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

            $role_uids = $userServ->listAll($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
     *
     * @author 英才
     *
     * @param array $user 传入当前用户信息
     *
     * @return array
     */
    public function get_by_right($user = [])
    {
        // 获取用户所在部门ID以及上级部门ID
        $dpIds = $this->get_user_dp_list($user);

        // 获取用户岗位ID
        $job_ids = [];
        if (!empty($user['job']['jobId'])) {

            $job_ids = $user['job']['jobId'];
        }

        // 获取用户角色ID
        $role_ids = [];
        if (!empty($user['role']['roleId'])) {

            $role_ids = $user['role']['roleId'];
        }

        // 获取用户标签ID
        $tagIds = [];
        $tagsInfo = User::instance()->getTagsByUserId($user['memUid']);
        if (!empty($tagsInfo)) {
            $userTagInfo = isset($tagsInfo['userTagList']) ? array_column($tagsInfo['userTagList'], 'tagId') : [];
            $departTagInfo = isset($tagsInfo['departTagList']) ? array_column($tagsInfo['departTagList'], 'tagId') : [];
            $tagIds = array_unique(array_merge($userTagInfo, $departTagInfo));
        }

        return [
            'memID' => $user['memUid'],
            'dpIds' => $dpIds,
            'jobIds' => $job_ids,
            'roleIds' => $role_ids,
            'tagIds' => $tagIds
        ];
    }

    /**
     * 判断考试权限
     *
     * @author 英才
     *
     * @param array $right 权限数组
     * @param array $user 单个用户信息数组
     *
     * @return bool
     */
    public function check_get_quit($right = [], $user = [])
    {
        $uid = array_filter(array_unique(array_column($right, 'uid')));
        $cd_id = array_filter(array_unique(array_column($right, 'cd_id')));
        $job_id = array_filter(array_unique(array_column($right, 'job_id')));
        $role_id = array_filter(array_unique(array_column($right, 'role_id')));
        $tag_id = array_filter(array_unique(array_column($right, 'tag_id')));

        $arr = array_filter(array_merge($uid, $cd_id, $job_id, $role_id, $tag_id));

        // 部门ID
        $qx_list_ids = [];
        if (!empty($cd_id)) {
            // 获取用户所在部门的ID集合
            $qx_list_ids = $this->get_user_dp_list($user);
        }
        // 用户ID
        $qx_list_ids[] = $user['memUid'];

        // 岗位ID
        if (isset($user['job']['jobId'])) {

            $qx_list_ids[] = $user['job']['jobId'];
        }
        // 角色ID
        if (isset($user['role']['roleId'])) {

            $qx_list_ids[] = $user['role']['roleId'];
        }
        // 获取用户标签ID
        $tagIds = [];
        $tagsInfo = User::instance()->getTagsByUserId($user['memUid']);
        if (!empty($tagsInfo)) {
            $userTagInfo = isset($tagsInfo['userTagList']) ? array_column($tagsInfo['userTagList'], 'tagId') : [];
            $departTagInfo = isset($tagsInfo['departTagList']) ? array_column($tagsInfo['departTagList'], 'tagId') : [];
            $tagIds = array_unique(array_merge($userTagInfo, $departTagInfo));
        }
        $qx_list_ids = array_merge($qx_list_ids, $tagIds);

        // 用试卷权限和用户权限集合取交集
        $ids = array_intersect($arr, $qx_list_ids);
        // 如果交集存在，则有权限，否则无权限
        if (!empty($ids)) {

            return true;
        }

        return false;
    }


    /**
     * 获取用户所在部门以及父级部门的ID集合
     *
     * @param array $user
     *
     * @return array
     */
    private function get_user_dp_list($user = [])
    {
        $dpIds = [];
        // 部门ID
        if (isset($user['dpName']) && !empty($user['dpName'])) {

            $myDpIds = array_column($user['dpName'], 'dpId');

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

            // 取父级部门ID
            foreach ($myDpIds as $myDpId) {
                $dpServ->list_parent_cdids($myDpId, $parentDpIds);
            }

            $dpIds = array_unique(array_merge($myDpIds, array_values($parentDpIds)));
        }

        return $dpIds;
    }

}