colleague / study-project · Files

<?php
/**
 * AbstractService.class.php
 * Service 层基类
 *
 * @author: zhuxun37
 */

namespace Common\Service;

use Common\Common\Cache;
use Common\Common\Department;
use Common\Common\ExportDownload;
use Common\Common\User;
use Com\PythonExcel;

abstract class AbstractService extends \Com\Service
{

    // 积分规则：默认策略
    const INTEGRAL_ACTION_TYPE_DEFAULT = 1;
    // 积分规则：不使用策略
    const INTEGRAL_ACTION_TYPE_NO = 2;
    // 积分规则：使用自定义策略
    const INTEGRAL_ACTION_TYPE_MY = 3;

    // 学分规则：默认策略
    const CREDIT_ACTION_TYPE_DEFAULT = 1;
    // 学分规则：不使用策略
    const CREDIT_ACTION_TYPE_NO = 2;
    // 学分规则：使用自定义策略
    const CREDIT_ACTION_TYPE_MY = 3;

    // 系统默认调研分类
    const CLASSIFY_SYSTEM_DEFAULT = 1;
    // 非系统默认调研分类
    const CLASSIFY_UN_SYSTEM_DEFAULT = 0;

    // 查询人员状态:已关注
    const USER_STATUS_FOLLOW = 1;
    // 查询人员状态:已禁用
    const USER_STATUS_DISABLE = 2;
    // 查询人员状态:未关注
    const USER_STATUS_UNFOLLOW = 4;

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

        parent::__construct();
    }

    /**
     * 去掉冗余字段
     *
     * @param $data
     */
    public function format_data_other(&$data)
    {

        unset($data['deleted'], $data['updated'], $data['status'], $data['domain']);

        return $data;
    }

    /**
     * 获取调研分类列表
     *
     * @return array|bool|mixed
     */
    public function get_classify_list()
    {

        $list = [];
        $cache = &Cache::instance();

        try {
            // 获取调研分类缓存信息
            $list = $cache->get('Common.Questionnaire_Classify_List');
        } catch (\Exception $e) {

            \Think\Log::record($e);
        }

        // 缓存数据为空
        if (empty($list)) {
            // 实例化调研分类
            $class_s = new ClassifyService();
            // 分类列表
            $list = $class_s->list_all();

            // 格式化分类列表数据
            $list = $this->format_data_classify($list);
            // 将分类列表存入缓存
            $cache->set('Common.Questionnaire_Classify_List', $list);
        }

        return $list;
    }

    /**
     * 格式化数据
     *
     * @param array $data 分类列表数据
     *
     * @return mixed
     */
    protected function format_data_classify($data)
    {

        $list = [];
        if (empty($data)) {

            return $list;
        }

        foreach ($data as $val) {

            $list[] = [
                'qc_id' => rintval($val['qc_id']),
                'qc_name' => $val['qc_name'],
                'qc_desc' => $val['qc_desc'],
                'is_system' => rintval($val['is_system']),
                'created' => rintval($val['created'])
            ];
        }

        return $list;
    }

    /**
     * 获取多个用户信息
     *
     * @param array $uids
     *
     * @return array|bool
     */
    public function getUser($uids = [])
    {

        if (is_array($uids)) {
            // 根据uid获取用户信息
            $users = $this->get_all_user_by_cache($uids);

            return $users;
        }

        return [];
    }

    /**
     * 获取用户信息列表
     *
     * @param array
     *
     * @return array
     */
    public function get_all_user_by_cache($uids = [])
    {

        // 用户信息初始化
        $user = User::instance();

        $user_list = [];
        // 防止缓存不存在时出错
        try {
            $cache = &Cache::instance();

            $user_list = $cache->get('Common.Questionnaire_User_List');
        } catch (\Think\Exception $e) {
            \Think\Log::record($e);

        } catch (\Exception $e) {
            \Think\Log::record($e);

        }

        $user_res = $user->listBasicByConds([], 1, 1);

        // 如果缓存不存在
        if (empty($user_list) || (count($user_list) != $user_res['total'])) {

            $users = $user->listAll();
            $user_list = [];
            foreach ($users as $v) {
                $user_list[$v['memUid']] = [
                    'memUid' => $v['memUid'],
                    'memUserid' => $v['memUserid'],
                    'memMobile' => $v['memMobile'],
                    'memEmail' => $v['memEmail'],
                    'memActive' => $v['memActive'],
                    'memUsername' => $v['memUsername'],
                    'memFace' => $v['memFace'],
                    'memSubscribeStatus' => $v['memSubscribeStatus'],
                    'memJob' => $v['memJob'],
                    'memRole' => $v['memRole'],
                    'dpName' => $v['dpName']
                ];
            }

            if (!empty($user_list)) {
                // 实例化缓存
                $cache = &Cache::instance();
                $cache->set('Common.Questionnaire_User_List', $user_list);
            }
        }

        if (empty($uids)) {

            return $user_list;
        }

        // 初始化指定人员的信息列表
        $user_info_list = [];
        foreach ($user_list as $k => $v) {
            if (in_array($k, $uids)) {
                $user_info_list[$v['memUid']] = $v;
            }
        }

        // 获取缓存中不存在的用户信息
        $all_uids = array_filter(array_column($user_list, 'memUid'));
        $no_uids = array_diff($uids, $all_uids);

        // 查询用户列表
        $arr_users = $user->listByUid($no_uids);
        $arr_users = array_combine_by_key($arr_users, 'memUid');

        // 获取缓存中不存在的或者已被删除的用户信息
        foreach ($no_uids as $_v) {

            $user_info = $arr_users[$_v];
            if (empty($user_info)) {

                $user_info = $user->getByUid($_v);
                $username = $user_info['memUsername'] . '【已删除】';
            } else {

                $username = $user_info['memUsername'];
            }

            $user_info_list[$user_info['memUid']] = [
                'memUid' => $user_info['memUid'],
                'memUserid' => $user_info['memUserid'],
                'memMobile' => $user_info['memMobile'],
                'memEmail' => $user_info['memEmail'],
                'memActive' => $user_info['memActive'],
                'memUsername' => $username,
                'memFace' => $user_info['memFace'],
                'memSubscribeStatus' => $user_info['memSubscribeStatus'],
                'memJob' => $user_info['memJob'],
                'memRole' => $user_info['memRole'],
                'dpName' => $user_info['dpName']
            ];
        }

        return $user_info_list;
    }

    /**
     * 根据部门ID集合，角色ID，岗位ID获取人员ID集合
     *
     * @author daijun
     *
     * @param array $dp_ids 部门ID集合
     * @param String $role_id 角色ID
     * @param String $job_id 岗位ID
     * @param String $memUsername 用户名
     *
     * @return array
     */
    public function list_uids_by_dp_job_role($dp_ids = [], $role_id = '', $job_id = '', $memUsername = '')
    {

        $User = new User();
        // 部门查询
        $uids = [];
        if ($dp_ids) {

            $department = new Department();
            $dpIDs = array_unique($dp_ids);
            sort($dpIDs);
            // 查询子部门
            $department_data = $department->list_childrens_by_cdid($dpIDs, true);
            // 搜索当前部门
            $department_data = array_merge($dpIDs, $department_data);
            $department_data = array_unique($department_data);
            // 升序
            sort($department_data);

            // 查询部门所有用户
            $user_list = $User->listAll(
                [
                    'dpIdList' => $department_data,
                ]);
            $dpid_uid = array_column($user_list, 'memUid');
            $uids = $dpid_uid;
        }

        // 角色查询
        if ($role_id) {
            $role_ids = [$role_id];
            $user_list = $User->listAll(
                [
                    'roleIdList' => $role_ids,
                ]);

            $role_uid = array_column($user_list, 'memUid');
            if (!empty($uids)) {
                $uids = array_intersect($uids, $role_uid);
            } else {
                $uids = $role_uid;
            }
        }

        // 岗位查询
        if ($job_id) {

            $job_ids = [$job_id];
            $user_list = $User->listAll(
                [
                    'jobIdList' => $job_ids,
                ]);

            $job_uid = array_column($user_list, 'memUid');
            if (!empty($uids)) {
                $uids = array_intersect($uids, $job_uid);
            } else {
                $uids = $job_uid;
            }
        }

        // 按照名称搜索
        if ($memUsername) {
            $user_list = $User->listAll(
                [
                    'memUsername' => $memUsername,
                ]);
            $user_uid = array_column($user_list, 'memUid');
            if (!empty($uids)) {
                $uids = array_intersect($uids, $user_uid);
            } else {
                $uids = $user_uid;
            }
        }

        return $uids;
    }

    /**
     * 根据部门ID集合，角色ID，岗位ID，人员姓名（模糊搜索），人员uids获取查询条件数组
     *
     * @author wangjiayu
     *
     * @param array $dp_ids 部门ID集合
     * @param string $role_id 角色ID
     * @param string $job_id 岗位ID
     * @param string $memUsername 用户名
     * @param array $memUids 用户id集合
     *
     * @return array $conds 组成后的搜索条件数组
     */
    public function list_uids_by_dp_job_role_name($dp_ids = [], $role_id = '', $job_id = '', $memUsername = '',
                                                  $memUids = [])
    {

        // 姓名处理（去除0和%因素）
        $memUsername = !empty($memUsername) ? $memUsername : '';
        $memUsername = str_replace('%', '\%', $memUsername);

        // 组装查询条件
        $conditions = [];

        // 部门查询
        if ($dp_ids) {

            $department = new Department();
            $dpIDs = array_unique($dp_ids);
            sort($dpIDs);
            // 查询子部门
            $department_data = $department->list_childrens_by_cdid($dpIDs, true);
            // 搜索当前部门
            $department_data = array_unique(array_merge($dpIDs, $department_data));
            sort($department_data);

            // 组装查询条件
            $conditions['dpIdList'] = $department_data;
        }

        // 角色查询
        if ($role_id) {

            $role_ids = [$role_id];
            $conditions['roleIdList'] = $role_ids;
        }

        // 岗位查询
        if ($job_id) {

            $job_ids = [$job_id];
            $conditions['jobIdList'] = $job_ids;
        }

        // 按照名称搜索
        if ($memUsername) {

            $conditions['memUsername'] = $memUsername;
        }

        if ($memUids) {

            $conditions['memUids'] = $memUids;
        }

        return $conditions;
    }

    /**
     * 数据导出
     *
     * @param array $list 导出数据
     *              + $title array 表头
     *              + $rows array 数据行
     * @param string $file_name 文件名称
     * @param int $ea_id 管理员ID
     * @param string $username 管理员姓名
     *
     * @return bool
     */
    public function download($list = [], $file_name, $ea_id = 0, $username = '')
    {

        // Excel表头
        $title = $list['title'];
        // Excel数据行
        $rows = $list['rows'];

        // 生成Excel 下载
        $real_path = ExportDownload::get_down_dir($ea_id.microtime(true)) . $file_name . '.xls';

        $ret = PythonExcel::instance()->write($real_path, $title, $rows);

        if ($ret) {
            $conditon = [
                'title' => $file_name,
                'ea_id' => $ea_id,
                'type' => ExportDownload::EXCEL_TYPE,
                'size' => filesize($real_path),
                'url' => $real_path,
                'app_dir' => APP_DIR,
                'username' => $username
            ];

            ExportDownload::insert_down_load($conditon);
        }

        return true;
    }
}