colleague / study-project · Files

<?php
/**
 * 直播对象范围表
 * @author: houyingcai
 * @email:    594609175@qq.com
 * @date :  2018-01-08 16:06:35
 * @version $Id$
 */

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\Tag;
use Common\Model\RangeModel;

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

        parent::__construct();
    }

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

        // 数据分组
        foreach ($ranges as $range) {

            $data[$range['type']][] = $range['obj_id'];
        }

        return $data;
    }

    /**
     * 获取格式化后的权限数据
     * @author houyingcai
     * @param array $conds 权限筛选条件
     * @return array
     *          + int is_all               是否全公司（1=否；2=是）
     *          + array dp_list   部门信息
     *                    + string dp_id   部门ID
     *                    + string dp_name 部门名称
     *          + array user_list 人员信息
     *                    + string uid      用户ID
     *                    + string username 用户姓名
     *                    + string face     头像
     *          + array job_list  职位信息
     *                    + string job_id   职位ID
     *                    + string job_name 职位名称
     *          + array role_list  角色信息
     *                    + string role_id   角色ID
     *                    + string role_name 角色名称
     *          + array tag_list  标签信息
     *                    + string tag_id   标签ID
     *                    + string tag_name 标签名称
     */
    public function getData($conds)
    {
        $list = $this->_d->list_by_conds($conds);
        $rights_db = $this->formatDBData($list);
        $data = [
            'is_all' => Constant::RANGE_IS_ALL_FALSE,
            'dp_list' => [],
            'user_list' => [],
            'job_list' => [],
            'role_list' => [],
            'tag_list' => []
        ];

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

            switch ($k) {
                // 全公司
                case Constant::RANGE_TYPE_ALL:
                    $data['is_all'] = Constant::RANGE_IS_ALL_TRUE;
                    break;

                // 部门
                case Constant::RANGE_TYPE_DEPARTMENT:
                    $dpServ = &Department::instance();
                    $dps = $dpServ->listById($v);

                    foreach ($dps as $dp) {

                        $data['dp_list'][] = [
                            'dp_id' => $dp['dpId'],
                            'dp_name' => $dp['dpName'],
                        ];
                    }
                    break;
                // 人员
                case Constant::RANGE_TYPE_USER:
                    $userServ = &User::instance();
                    $users = $userServ->listAll(['memUids' => $v]);

                    foreach ($users as $user) {

                        $data['user_list'][] = [
                            'uid' => $user['memUid'],
                            'username' => $user['memUsername'],
                            'face' => $user['memFace'],
                        ];
                    }
                    break;

                // 职位
                case Constant::RANGE_TYPE_JOB:
                    $jobServ = &Job::instance();
                    $jobs = $jobServ->listById($v);

                    foreach ($jobs as $job) {

                        $data['job_list'][] = [
                            'job_id' => $job['jobId'],
                            'job_name' => $job['jobName'],
                        ];
                    }
                    break;

                // 角色
                case Constant::RANGE_TYPE_ROLE:
                    $roleServ = &Role::instance();
                    $roles = $roleServ->listById($v);

                    foreach ($roles as $role) {

                        $data['role_list'][] = [
                            'role_id' => $role['roleId'],
                            'role_name' => $role['roleName'],
                        ];
                    }
                    break;

                // 标签
                case Constant::RANGE_TYPE_TAG:
                    $tagServ = &Tag::instance();
                    $tags = $tagServ->listById($v);

                    foreach ($tags as $tag) {

                        $data['tag_list'][] = [
                            'tag_id' => $tag['tagId'],
                            'tag_name' => $tag['tagName']
                        ];
                    }
                    break;
            }
        }

        return $data;
    }

    /**
     * 检查用户是否有权限观看直播
     * @author houyingcai
     * @param array $user 用户信息
     * @param int $lm_id 直播ID
     * @return bool
     */
    public function checkUserRange($user, $lm_id)
    {
        if (empty($user)) {

            return false;
        }

        $ranges = $this->getUserRight($user);
        $conds = $this->_buildRightConds($ranges);
        $conds['lm_id'] = $lm_id;
        $count = $this->_d->count_by_conds($conds);

        return $count > 0;
    }

    /**
     * 获取用户权限数据
     * @author houyingcai
     * @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');
            // 使用缓存
            $dpServ = new Department(false);
            $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[Constant::RANGE_TYPE_DEPARTMENT] = array_unique($dp_ids);
        }

        // 全公司
        $data[Constant::RANGE_TYPE_ALL] = Constant::RANGE_TYPE_ALL;
        // 用户
        $data[Constant::RANGE_TYPE_USER] = [$user['memUid']];

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

            $data[Constant::RANGE_TYPE_JOB] = [$user['job']['jobId']];
        }

        // 角色
        if (isset($user['role']['roleId'])) {

            $data[Constant::RANGE_TYPE_ROLE] = [$user['role']['roleId']];
        }

        // 标签
        $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));
        }
        $data[Constant::RANGE_TYPE_TAG] = $tagIds;

        return $data;
    }

    /**
     * 获取直播已观看、未观看、权限范围内人员ID数组
     * @author houyingcai
     * @param int $lm_id 直播ID
     * @return array [0 => 已观看人员ID, 1 => 未观看人员ID, 2 => 权限范围内人员ID]
     */
    public function getWatchDataUids($lm_id)
    {
        $uids_all = [];
        $uids_watched = [];
        $uids_unwatch = [];

        // 查询条件
        $conds = ['lm_id' => $lm_id];

        // 获取权限数据
        $ranges = $this->_d->list_by_conds($conds);
        $ranges = $this->formatDBData($ranges);

        if (empty($ranges)) {

            return [$uids_watched, $uids_unwatch, $uids_all];
        }

        // 获取可观看数据
        $uids_all = $this->getUidsByRange($ranges);

        // 获取已观看数据（包含通讯录中被删除的人员ID）
        $participateServ = new ParticipateService();
        $watched_list = $participateServ->list_by_conds($conds);
        $uids_watched = array_column($watched_list, 'obj_id');

        // 未观看数据
        $uids_unwatch = array_values(array_diff($uids_all, $uids_watched));

        return [$uids_watched, $uids_unwatch, $uids_all];
    }

    /**
     * 根据权限数据，获取对应的用户ID
     * @author houyingcai
     * @param array $ranges 权限数据
     * @return array
     */
    public function getUidsByRange($ranges)
    {
        $dp_ids = [];
        $uids = [];
        $conds = [];

        $userServ = &User::instance();
        // 全公司
        if (isset($ranges[Constant::RANGE_TYPE_ALL])) {

            // 权限表不存在权限信息，为全公司
            $result_user = $userServ->listBasicByConds([], 1, 1);

            $res_list = $userServ->listBasicByConds([],1, $result_user['total']);
            // 直接返回
            return array_column($res_list['list'], 'memUid');
        }

        // 人员
        if (isset($ranges[Constant::RANGE_TYPE_USER])) {

            $uids = array_merge($uids, $ranges[Constant::RANGE_TYPE_USER]);
        }

        // 部门
        if (isset($ranges[Constant::RANGE_TYPE_DEPARTMENT])) {

            $dp_ids = $ranges[Constant::RANGE_TYPE_DEPARTMENT];
        }

        // 标签
        $tag_ids = $ranges[Constant::RANGE_TYPE_TAG];
        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 (isset($ranges[Constant::RANGE_TYPE_JOB])) {

            $conds['jobIdList'] = $ranges[Constant::RANGE_TYPE_JOB];
            $job_uids = $userServ->listAll($conds);
            $job_uids = array_column($job_uids, 'memUid');
        }

        // 角色
        $conds = [];
        $role_uids = [];
        if (isset($ranges[Constant::RANGE_TYPE_ROLE])) {

            $conds['roleIdList'] = $ranges[Constant::RANGE_TYPE_ROLE];
            $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));
    }

    /**
     * 根据权限数据构建查询条件
     * @author houyingcai
     * @param array $ranges 权限数据
     * @return array
     */
    private function _buildRightConds($ranges)
    {
        if (!is_array($ranges) || empty($ranges)) {

            return [];
        }

        $obj_ids = [];

        foreach ($ranges as $k => $v) {
            // 全公司
            if ($k == Constant::RANGE_TYPE_ALL) {

                $obj_ids[] = Constant::RANGE_TYPE_ALL;
            } else { // 部门、人员、职位、角色、标签

                $obj_ids = array_merge($obj_ids, $v);
            }
        }

        return empty($obj_ids) ? [] : ['obj_id' => $obj_ids];
    }

    /**
     * 根据条件读取数据数组
     *
     * @param array $conds 条件数组
     * @param string $field 字段信息
     * @return array|bool
     */
    public function list_by_rang_conds($conds, $field = '*')
    {

        try {
            return $this->_d->list_by_rang_conds($conds,$field);
        } catch (\Exception $e) {
            E($e->getCode() . ":" . $e->getMessage());

            return false;
        }
    }

}