colleague / study-project · Files

<?php
/**
 * 培训权限表Service
 * @author: houyingcai
 * @email:  594609175@qq.com
 * @date :  2017-08-29 16:34:16
 * @version $Id$
 */
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
{
    // 权限类型:全公司
    const RIGHT_TYPE_ALL = 1;
    // 权限类型:部门
    const RIGHT_TYPE_DEPARTMENT = 2;
    // 权限类型:标签
    const RIGHT_TYPE_TAG = 3;
    // 权限类型:人员
    const RIGHT_TYPE_USER = 4;
    // 权限类型:职位
    const RIGHT_TYPE_JOB = 5;
    // 权限类型:角色
    const RIGHT_TYPE_ROLE = 6;

    // 是导入人员
    const IMPORT_USER = 1;
    // 非导入人员
    const NOT_IMPORT_USER = 0;

    public function __construct()
    {
        $this->_d = new RightModel();

        parent::__construct();
    }

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

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

        return $data;
    }


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

        foreach ($rights as $k => $v) {
            // 全公司
            if ($k == 'is_all' && $v == self::IS_ALL) {

                $data = [self::RIGHT_TYPE_ALL => [self::IS_ALL]];
                break;
            }

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

                continue;
            }

            // 数据分组
            switch ($k) {
                case 'dp_list':
                    $dp_ids = array_column($v, 'dpID');
                    $data[self::RIGHT_TYPE_DEPARTMENT] = $dp_ids;
                    break;
                case 'tag_list':
                    $tag_ids = array_column($v, 'tagID');
                    $data[self::RIGHT_TYPE_TAG] = $tag_ids;
                    break;
                case 'user_list':
                    $uids = array_column($v, 'memID');
                    $data[self::RIGHT_TYPE_USER] = $uids;
                    break;
                case 'job_list':
                    $job_ids = array_column($v, 'jobID');
                    $data[self::RIGHT_TYPE_JOB] = $job_ids;
                    break;
                case 'role_list':
                    $role_ids = array_column($v, 'roleID');
                    $data[self::RIGHT_TYPE_ROLE] = $role_ids;
                    break;
                default:

                    break;
            }
        }

        return $data;
    }

    /**
     * 比较权限数据，并返回需要新增和删除的数据
     *
     * @author houyingcai
     *
     * @param array $rights_db 数据库中的权限数据
     * @param array $rights_post 用户输入的权限数据
     *
     * @return array
     */
    public function diff_data($rights_db, $rights_post)
    {
        $keys = [
            self::RIGHT_TYPE_ALL,
            self::RIGHT_TYPE_DEPARTMENT,
            self::RIGHT_TYPE_TAG,
            self::RIGHT_TYPE_USER,
            self::RIGHT_TYPE_JOB,
            self::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 权限数据
     *        + int is_all 是否全公司
     *        + array dp_list 部门ID
     *        + array tag_list 标签ID
     *        + array user_list 用户ID
     *        + array job_list 职位ID
     *        + array role_list 角色ID
     * @param array $import_data 导入人员UID列表
     *
     * @return bool
     */
    public function save_data($conds, $data, $import_data)
    {
        $insert_data = [];
        // 权限范围人员
        if (!empty($data) && is_array($data)) {

            $list = $this->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);

            foreach ($rights as $k => $v) {
                // 删除数据
                if (!empty($v['del'])) {

                    $del_conds = array_merge($conds, ['obj_type' => $k, 'obj_id' => $v['del']]);
                    $this->delete_by_conds($del_conds);
                }

                // 新增数据
                foreach ($v['add'] as $obj_id) {

                    $insert_data[] = array_merge($conds, [
                        'obj_type' => $k,
                        'obj_id' => $obj_id,
                        'uid_is_import' => self::NOT_IMPORT_USER, // 是否导入用户（0:否，1:是）
                    ]);
                }
            }
        }
        // 导入人员
        if (!empty($import_data) && is_array($import_data)) {

            foreach ($import_data as $val) {
                $insert_data[] = array_merge($conds, [
                    'obj_type' => self::RIGHT_TYPE_USER,
                    'obj_id' => $val,
                    'uid_is_import' => self::IMPORT_USER, // 是否导入用户（0:否，1:是）
                ]);
            }
        }

        // 批量插入新增数据
        if (!empty($insert_data)) {

            $this->insert_all($insert_data);
        }

        return true;
    }

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

        // 全公司
        if (isset($rights[self::RIGHT_TYPE_ALL])) {

            $userServ = &User::instance();
            $list = $userServ->listAll(['memSubscribeStatus' => self::USER_STATUS_FOLLOW]);

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

        // 部门
        if (isset($rights[self::RIGHT_TYPE_DEPARTMENT])) {

            $dp_ids = $rights[self::RIGHT_TYPE_DEPARTMENT];
        }

        // 标签
        if (isset($rights[self::RIGHT_TYPE_TAG])) {

            $tagServ = Tag::instance();
            $list = $tagServ->listAllMember(['tagIds' => $rights[self::RIGHT_TYPE_TAG]]);

            foreach ($list as $v) {
                // 标签中的部门
                if (isset($v['dpId']) && !empty($v['dpId'])) {

                    $dp_ids[] = $v['dpId'];

                    // 标签中的人员
                } elseif (isset($v['memUid']) && !empty($v['memUid'])) {

                    $uids[] = $v['memUid'];
                }
            }
        }

        // 部门ID
        if (!empty($dp_ids)) {

            $conds['dpIdList'] = $dp_ids;
            $conds['departmentChildrenFlag'] = 1;
        }

        // 职位
        if (isset($rights[self::RIGHT_TYPE_JOB])) {

            $conds['jobIdList'] = $rights[self::RIGHT_TYPE_JOB];
        }

        // 角色
        if (isset($rights[self::RIGHT_TYPE_ROLE])) {

            $conds['roleIdList'] = $rights[self::RIGHT_TYPE_ROLE];
        }

        // 根据筛选条件获取用户列表
        if (!empty($conds)) {
            $userServ = User::instance();
            $list = $userServ->listAll($conds);
            $data = array_column($list, 'memUid');
            $uids = array_merge($uids, $data);
        }

        // 人员
        if (isset($rights[self::RIGHT_TYPE_USER])) {

            $uids = array_merge($uids, $rights[self::RIGHT_TYPE_USER]);
        }

        return array_unique($uids);

    }

    /**
     * 获取格式化后的权限数据
     *
     * @author houyingcai
     *
     * @param array $conds 权限筛选条件
     *
     * @return array
     */
    public function get_data($conds)
    {
        $list = $this->list_by_conds($conds);
        $rights_db = $this->format_db_data($list);
        $data = [
            'is_all' => self::NOT_IS_ALL,
            'dp_list' => [],
            'tag_list' => [],
            'user_list' => [],
            'job_list' => [],
            'role_list' => [],
        ];

        foreach ($rights_db as $k => $v) {
            switch ($k) {
                // 全公司
                case self::RIGHT_TYPE_ALL:
                    $data['is_all'] = self::IS_ALL;
                    break;

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

                    foreach ($dps as $dp) {
                        $data['dp_list'][] = [
                            'dpID' => $dp['dpId'],
                            'dpName' => $dp['dpName'],
                        ];
                    }
                    break;

                // 标签
                case self::RIGHT_TYPE_TAG:
                    $tagServ = &Tag::instance();
                    $tags = $tagServ->listAll($v);

                    foreach ($tags as $tag) {
                        $data['tag_list'][] = [
                            'tagID' => $tag['tagId'],
                            'tagName' => $tag['tagName'],
                        ];
                    }
                    break;

                // 人员
                case self::RIGHT_TYPE_USER:
                    $userServ = &User::instance();
                    $users = $userServ->listAll(['memUids' => $v]);

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

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

                    foreach ($jobs as $job) {
                        $data['job_list'][] = [
                            'jobID' => $job['jobId'],
                            'jobName' => $job['jobName'],
                        ];
                    }
                    break;

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

                    foreach ($roles as $role) {
                        $data['role_list'][] = [
                            'roleID' => $role['roleId'],
                            'roleName' => $role['roleName'],
                        ];
                    }
                    break;
            }
        }

        return $data;
    }

    /**
     * 统计导入人员数量
     *
     * @author houyingai
     *
     * @param array $conds 筛选条件
     *
     * @return int
     */
    public function count_import_users($conds = [])
    {
        $count = 0;
        if (!empty($conds)) {

            $count = $this->count_by_conds($conds);
        }

        return $count;
    }

    /**
     * 获取所有导入人员UID
     *
     * @author houyingai
     *
     * @param array $conds 筛选条件
     *
     * @return int
     */
    public function list_import_users($conds = [])
    {
        $user_info_list = [];
        if (!empty($conds)) {

            $list = $this->list_by_conds($conds, null, [], 'obj_id');
        }

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

        if (!empty($uids)) {

            $user_list = $this->get_all_user_by_cache($uids);
        }

        if (!empty($user_list)) {

            foreach ($user_list as $v) {

                $user_info_list[] = [
                    'memID' => $v['memUid'],
                    'memUsername' => $v['memUsername'],
                    'memFace' => $v['memFace']
                ];
            }
        }

        return json_encode($user_info_list);
    }

    /**
     * 获取用户提交的权限范围内的所有人UID集合
     *
     * @author houyingcai
     *
     * @param array $post_right 用户提交的权限数据
     *
     * @return array
     */
    public function list_post_right_uids($post_right)
    {
        $userServ = &User::instance();
        if ($post_right['is_all'] == self::IS_ALL) {
            
            // 获取全部人员
            $result = $userServ->listBasicByConds(['memSubscribeStatus' => self::USER_STATUS_FOLLOW], 1, 1);
            $list = $userServ->listBasicByConds(['memSubscribeStatus' => self::USER_STATUS_FOLLOW], 1, $result['total']);

            return array_column($list['list'], 'memUid');
        }

        // 处理标签
        if (!empty($post_right['tag_ids'])) {

            $tagServ = &Tag::instance();
            $list = $tagServ->listAllMember(['tagIds' => $post_right['tag_ids']]);

            foreach ($list as $v) {
                // 标签中的部门
                if (isset($v['dpId']) && !empty($v['dpId'])) {

                    $tag_dp_ids[] = $v['dpId'];

                // 标签中的人员
                } elseif (isset($v['memUid']) && !empty($v['memUid'])) {

                    $tag_uids[] = $v['memUid'];
                }
            }
        }

        // 初始化保存人员UID
        $post_right['uids'] = isset($post_right['uids']) ? $post_right['uids'] : [];
        if (isset($tag_uids)) {
            $post_right['uids'] = array_merge($post_right['uids'], $tag_uids);
        }

        // 处理部门
        $post_right['dp_ids'] = isset($post_right['dp_ids']) ? $post_right['dp_ids'] : [];
        if (isset($tag_dp_ids)) {
            $post_right['dp_ids'] = array_merge($post_right['dp_ids'], $tag_dp_ids);
        }
        if (!empty($post_right['dp_ids'])) {

            // 部门ID去重
            $post_right['dp_ids'] = array_unique($post_right['dp_ids']);
            sort($post_right['dp_ids']);

            $dpServ = &Department::instance();
            // 取子级部门ID
            $child_ids = $dpServ->list_childrens_by_cdid($post_right['dp_ids']);
            // 合并部门ID
            $dp_ids = array_unique(array_merge($post_right['dp_ids'], array_values($child_ids)));
            sort($dp_ids);

            $dp_conds = [
                'dpIdList' => $dp_ids,
                'memSubscribeStatus' => self::USER_STATUS_FOLLOW
            ];

            $dp_users = $userServ->listAll($dp_conds);
            // 选择部门下的员工id集合
            $memUids = array_column($dp_users, 'memUid');

            $post_right['uids'] = array_merge($post_right['uids'], $memUids);
        }

        // 处理岗位
        if (!empty($post_right['job_ids'])) {

            $post_right['job_ids'] = array_unique($post_right['job_ids']);
            sort($post_right['job_ids']);
            // 初始化SDK
            $job_list = $userServ->listAll(
                [
                    'jobIdList' => $post_right['job_ids'],
                    'memSubscribeStatus' => self::USER_STATUS_FOLLOW
                ]);

            // 如果岗位下存在人员
            if (!empty($job_list)) {

                $post_right['uids'] = array_merge($post_right['uids'], array_column($job_list, 'memUid'));
            }
        }

        // 处理角色
        if (!empty($post_right['role_ids'])) {

            $post_right['role_ids'] = array_unique($post_right['role_ids']);

            sort($post_right['role_ids']);

            $role_List = $userServ->listAll(
                [
                    'roleIdList' => $post_right['role_ids'],
                    'memSubscribeStatus' => self::USER_STATUS_FOLLOW
                ]);

            // 如果岗位下存在人员
            if (!empty($role_List)) {
                $post_right['uids'] = array_merge($post_right['uids'], array_column($role_List, 'memUid'));
            }
        }

        return array_unique($post_right['uids']);
    }
}