package com.manage.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.manage.dao.Power_DeptMapper;
import com.manage.dao.Power_NoticeMapper;
import com.manage.dao.Power_UserMapper;
import com.manage.entity.Power_Dept;
import com.manage.entity.Power_Menu;
import com.manage.entity.Power_Notice;
import com.manage.entity.Power_User;
import com.manage.service.*;
import com.manage.service.cache.Cache;
import com.manage.service.cache.CacheManager;
import com.manage.service.ipml.Power_NoticeServiceImpl;
import com.manage.service.webSocket.WsPool;
import com.manage.util.DateUtils;
import com.manage.util.ExceptionPrintUtil;
import com.manage.util.Msg;
import com.manage.vo.*;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.*;

/**
 * @ProjectName:
 * @Description:
 * @Param 传输参数
 * @Return
 * @Author: 曾文和
 * @CreateDate: 2019/7/9 15:07
 * @UpdateUser: 曾文和
 * @UpdateDate: 2019/7/9 15:07
 * @UpdateRemark: 更新说明
 * @Version: 1.0
 */
@Controller
@RequestMapping("font/")
public class FontController {
    @Value("${STR_SPLIT}")
    private String STR_SPLIT;
    @Autowired
    private PowerService powerService;
    @Autowired
    private User_Dept_MenuService userDeptMenuService;
    @Autowired
    private Power_NoticeMapper powerNoticeMapper;
    @Autowired
    private Power_UserMapper userMapper;
    @Autowired
    private Power_NoticeServiceImpl noticeService;
    @Autowired
    private Power_UserService userService;
    @Value("${TOKEN_EXPIRE_TIME}")
    private long TOKEN_EXPIRE_TIME;
    @Autowired
    private Power_MenuService powerMenuService;
    @Autowired
    private Power_DeptService power_deptService;
    @Autowired
    private Power_UserMapper power_userMapper;
    @Autowired
    private Power_DeptMapper powerDeptMapper;

    /**
     * 2.1
     *
     * @ProjectName: getUserPowerTreeBySysFlag
     * @Description: 获取菜单通过系统标识
     * @Param 无
     * @Return getMenusByUserIdAndSysFlag
     * @Author: 曾文和
     * @CreateDate: 2019/7/9 10:00
     * @UpdateUser: 更新者
     * @UpdateDate: 2019/7/9 10:00
     * @UpdateRemark: 更新说明
     * @Version: 1.0
     */
    @RequestMapping(value = "getMenusByUserIdAndSysFlag", method = RequestMethod.GET)
    @ResponseBody
    public Msg getMenusByUserIdAndSysFlag(String userName, String sysFlag, Integer userId, Integer roleId,
                                          Integer sysId, Integer hospitalId) throws Exception {
        if (StringUtils.isNotBlank(sysFlag) && StringUtils.isBlank(userName) && userId == null && roleId == null
                && sysId == null && hospitalId == null) {
            return Msg.fail("查询复杂,数据大,暂不支持只带sysFlag参数查询");
        }
        if (StringUtils.isBlank(sysFlag) && StringUtils.isBlank(userName) && userId == null && roleId == null
                && sysId != null && hospitalId == null) {
            return Msg.fail("查询复杂,数据大,暂不支持只带sysId参数查询");
        }
        if (StringUtils.isBlank(sysFlag) && StringUtils.isBlank(userName) && userId == null && roleId == null
                && sysId == null && hospitalId != null) {
            return Msg.fail("查询复杂,数据大,暂不支持只带hospitalId参数查询");
        }
        if (StringUtils.isNotBlank(userName)) {
            List<Power_User> power_users = userMapper.checkUserName(userName);
            if (null != power_users && !power_users.isEmpty()) {
                if (power_users.get(0).getRoleId().equals(0) || power_users.get(0).getRoleId().equals(-100)) {
                    roleId = power_users.get(0).getRoleId();
                }
            }
        }

        List<User_Dept_Menu> list = userDeptMenuService.selectAll(userName, sysFlag, userId, roleId, sysId, hospitalId);
        CacheManager.addExcCount("noExc");
        return Msg.success().add("list", list);
    }

    /**
     * 2.2
     *
     * @ProjectName: selectAllByUserIdOrRoleIdAndSysIdOrSysFlag
     * @Description: 根据用户id或角色id和系统id或系统标识查询通知记录
     * @Param 无
     * @Return selectAllByUserIdOrRoleIdAndSysIdOrSysFlag
     * @Author: 曾文和
     * @CreateDate: 2019/7/29 10:00
     * @UpdateUser: 更新者
     * @UpdateDate: 2019/7/29 10:00
     * @UpdateRemark: 更新说明
     * @Version: 1.0
     */
    @RequestMapping(value = "selectAllByUserIdOrRoleIdAndSysIdOrSysFlag")
    @ResponseBody
    public Msg selectAllByUserIdOrRoleIdAndSysIdOrSysFlag(Integer userId, Integer roleId, Integer sysId, String sysFlag, String sysName, Integer effective, String noticeTitle, String noticeSend, String noticeDate, String noticeTypeFlag, String noticeTypeName) throws Exception {
        List<Power_Notice> list = powerNoticeMapper.selectAllByUserIdOrRoleIdAndSysIdOrSysFlag(userId, roleId, sysId, sysFlag, sysName, effective, noticeTitle, noticeSend, noticeDate, noticeTypeFlag, noticeTypeName);
        CacheManager.addExcCount("noExc");
        return Msg.success().add("list", list);
    }

    /**
     * 2.4
     *
     * @ProjectName: getUserPowerTreeBySysFlag
     * @Description: 获取系统用户树通过系统标识
     * @Param 无
     * @Return PowerTree
     * @Author: 曾文和
     * @CreateDate: 2019/7/9 10:00
     * @UpdateUser: 更新者
     * @UpdateDate: 2019/7/9 10:00
     * @UpdateRemark: 更新说明
     * @Version: 1.0
     */
    @RequestMapping(value = "getUserPowerTreeBySysFlag", produces = {"text/json;charset=UTF-8"})
    @ResponseBody
    public String getUserPowerTreeBySysFlag(String sysFlag, Integer userId) {
        try {
            if (null != userId) {
                //查询该用户
                Power_UserVo user = userMapper.selectByPrimaryKey(userId);
                List<PowerTree> dicts = powerService.getUserPowerTreeBySysFlag(sysFlag, user);
                ObjectMapper mapper = new ObjectMapper();
                String json = mapper.writeValueAsString(dicts);
                CacheManager.addExcCount("noExc");
                return json;
            } else {
                return null;
            }
        } catch (Exception e) {
            CacheManager.addExcCount("exc");
            e.printStackTrace();
            ExceptionPrintUtil.printException(e);
            return null;
        }
    }

    /**
     * 2.5
     *
     * @ProjectName: getRolePowerTreeBySysFlag
     * @Description: 获取系统角色树通过系统标识
     * @Param 无
     * @Return PowerTree
     * @Author: 曾文和
     * @CreateDate: 2019/7/9 10:00
     * @UpdateUser: 更新者
     * @UpdateDate: 2019/7/9 10:00
     * @UpdateRemark: 更新说明
     * @Version: 1.0
     */
    @RequestMapping(value = "getRolePowerTreeBySysFlag", produces = {"text/json;charset=UTF-8"})
    @ResponseBody
    public String getRolePowerTreeBySysFlag(String sysFlag, Integer userId) {
        try {
            if (null != userId) {
                Power_UserVo user = userMapper.selectByPrimaryKey(userId);
                List<PowerTree> dicts = powerService.getRolePowerTreeBySysFlag(sysFlag, user);
                ObjectMapper mapper = new ObjectMapper();
                String json = mapper.writeValueAsString(dicts);
                CacheManager.addExcCount("noExc");
                return json;
            } else {
                return null;
            }
        } catch (Exception e) {
            CacheManager.addExcCount("exc");
            e.printStackTrace();
            ExceptionPrintUtil.printException(e);
            return null;
        }
    }

    /**
     * 2.6
     *
     * @ProjectName: getUserList
     * @Description: 获取用户id和用户名
     * @Param 无
     * @Return userList
     * @Author: 曾文和
     * @CreateDate: 2019/9/6 10:00
     * @UpdateUser: 更新者
     * @UpdateDate: 2019/9/6 10:00
     * @UpdateRemark: 更新说明
     * @Version: 1.0
     */
    @RequestMapping(value = "getUserList")
    @ResponseBody
    public Msg getUserList(String userName) throws Exception {
        List<User> list = new ArrayList<>();
        if (StringUtils.isNoneBlank(userName)) {
            List<Power_User> users = userMapper.checkUserName(userName);
            if (null != users && !users.isEmpty()) {
                Integer roleId = users.get(0).getRoleId();
                if (roleId == 0) {
                    list = userMapper.selectUserIdAndUserNameList(null);
                } else {
                    list = userMapper.selectUserIdAndUserNameList(users.get(0).getUserId());
                }
            }
        } else {
            return Msg.fail("用户名不能为空");
        }
        CacheManager.addExcCount("noExc");
        return Msg.success().add("userList", list);
    }

    /**
     * 2.7
     *
     * @ProjectName: checkToken
     * @Description: 验证token是否有效
     * @Param 无
     * @Return Msg
     * @Author: 曾文和
     * @CreateDate: 2019/9/24 10:00
     * @UpdateUser: 更新者
     * @UpdateDate: 2019/9/24 10:00
     * @UpdateRemark: 更新说明
     * @Version: 1.0
     */
    @RequestMapping(value = "checkToken", method = RequestMethod.POST)
    @ResponseBody
    public Msg checkToken(String token) throws Exception {
        if (StringUtils.isNotBlank(token) && StringUtils.isNotBlank(token)) {
            Cache cache = CacheManager.getCacheInfo(token);
            if (cache == null) {
                return Msg.fail("token已过期或不存在");
            }
        } else {
            return Msg.fail("token不能为空");
        }
        return Msg.success();
    }

    /**
     * 2.8
     *
     * @ProjectName: getUserByToken
     * @Description: 根据token获取用户
     * @Param 无
     * @Return getMenuListByToken
     * @Author: 曾文和
     * @CreateDate: 2019/10/31 10:00
     * @UpdateUser: 更新者
     * @UpdateDate: 2019/10/31 10:00
     * @UpdateRemark: 更新说明
     * @Version: 1.0
     */
    @RequestMapping(value = "getUserByToken", method = RequestMethod.POST)
    @ResponseBody
    public Msg getMenuListByToken(String token, String sysFlag) throws Exception {
        if (StringUtils.isBlank(token)) {
            return Msg.fail("token不能为空!");
        }
        if (StringUtils.isBlank(sysFlag)) {
            return Msg.fail("sysFlag不能为空!");
        }
        Cache cacheInfo = CacheManager.getCacheInfo(token);
        Power_UserVo user = (Power_UserVo) cacheInfo.getValue();
        if (null != user) {
            List<User_Dept_Menu> menuList = user.getMenuList();
            List<User_Dept_Menu> list = new ArrayList<>();
            Set<String> menus = new TreeSet<>();
            if (null != menuList && !menuList.isEmpty()) {
                for (User_Dept_Menu user_dept_menu : menuList) {
                    String menuSysFlag = user_dept_menu.getSysFlag();
                    if (StringUtils.isNotBlank(menuSysFlag) && menuSysFlag.equals(sysFlag)) {
                        list.add(user_dept_menu);
                        if (StringUtils.isNotBlank(user_dept_menu.getMethod())) {
                            menus.add(user_dept_menu.getMenuUrl());
                        }
                    }
                }
            }
            user.setMenuList(list);
            user.setMenus(menus);
            UserVo userVo = new UserVo();
            BeanUtils.copyProperties(user, userVo);
            //查询用户集合
            List<User> userList = new ArrayList<>();
            Integer roleId = userVo.getRoleId();
            if (roleId == 0) {
                userList = userMapper.selectUserIdAndUserNameList(null);
            } else {
                userList = userMapper.selectUserIdAndUserNameList(userVo.getUserId());
            }
            //设置用户集合
            userVo.setUserList(userList);
            CacheManager.addExcCount("noExc");
            return Msg.success().add("user", userVo);
        } else {
            return Msg.fail("token已失效");
        }
    }

    /**
     * 2.9
     *
     * @ProjectName: getMenuByToken
     * @Description: 根据token获取菜单
     * @Param 无
     * @Return getMenuListByToken
     * @Author: 曾文和
     * @CreateDate: 2019/10/31 10:00
     * @UpdateUser: 更新者
     * @UpdateDate: 2019/10/31 10:00
     * @UpdateRemark: 更新说明
     * @Version: 1.0
     */
    @RequestMapping(value = "getMenuByToken", method = RequestMethod.POST)
    @ResponseBody
    public Msg getMenuByToken(String token, String sysFlag) throws Exception {
        if (StringUtils.isBlank(token)) {
            return Msg.fail("token不能为空!");
        }
        if (StringUtils.isBlank(sysFlag)) {
            return Msg.fail("sysFlag不能为空!");
        }
        Cache cacheInfo = CacheManager.getCacheInfo(token);
        Power_UserVo user = (Power_UserVo) cacheInfo.getValue();
        List<User_Dept_Menu> menuList = user.getMenuList();
        List<User_Dept_Menu> list = new ArrayList<>();
        if (null != menuList && !menuList.isEmpty()) {
            for (User_Dept_Menu user_dept_menu : menuList) {
                String menuSysFlag = user_dept_menu.getSysFlag();
                if (StringUtils.isNotBlank(menuSysFlag) && menuSysFlag.equals(sysFlag)) {
                    list.add(user_dept_menu);
                }
            }
        }
        CacheManager.addExcCount("noExc");
        return Msg.success().add("list", list);
    }

    /**
     * 2.10
     *
     * @ProjectName: getToken
     * @Description: 获取token
     * @Param 无
     * @Return Msg
     * @Author: 曾文和
     * @CreateDate: 2019/11/06 10:00
     * @UpdateUser: 更新者
     * @UpdateDate: 2019/11/06 10:00
     * @UpdateRemark: 更新说明
     * @Version: 1.0
     */
    @RequestMapping(value = "getToken", method = RequestMethod.POST)
    @ResponseBody
    public Msg getToken(String userName, String password) throws Exception {
        if (StringUtils.isBlank(userName)) {
            return Msg.fail("用户名不能为空");
        }
        if (StringUtils.isBlank(password)) {
            return Msg.fail("密码不能为空");
        }
        Power_User user = new Power_User();
        user.setUserName(userName);
        user.setRemark(password);
        Power_UserVo userVo = userService.findPowerUserByUserNameAndRemark(user);
        if (null == userVo) {
            return Msg.fail("用户名或密码不正确");
        }
        String date = String.valueOf(DateUtils.getDate());
        String token = UUID.randomUUID().toString();

        List<Power_Menu> list = null;
        List<User_Dept_Menu> menuList = new ArrayList<>();
        Set<String> menus = new TreeSet<>();
        if (userVo.getRoleId().equals(0) || userVo.getRoleId().equals(-100)) {
            list = powerMenuService.queryAllPowerMenu(null, userVo.getRoleId());
        } else {
            list = powerMenuService.selectUserAndRoleMenuListPower(userVo.getUserId(), null);
        }
        if (null != list && !list.isEmpty()) {
            for (Power_Menu power_menu : list) {
                User_Dept_Menu deptMenu = new User_Dept_Menu();
                String menuUrl = power_menu.getMenuUrl();
                if (StringUtils.isNotBlank(menuUrl)) {
                    BeanUtils.copyProperties(power_menu, deptMenu);
                    deptMenu.setMethodParent(power_menu.getParentId());
                    menuList.add(deptMenu);
                }
                if (StringUtils.isNotBlank(power_menu.getMethod())) {
                    menus.add(power_menu.getMenuUrl());
                }
            }
        }
        userVo.setMenuList(menuList);
        userVo.setMenus(menus);

        //设置科室
        StringBuilder power_depts = new StringBuilder();
        List<Power_Dept> power_depts1 = power_deptService.selectByPrimaryKeys(userVo.getDeptId());
        for (int j = 0; j < power_depts1.size(); j++) {
            if (j < power_depts1.size() - 1) {
                power_depts.append(power_depts1.get(j).getDeptName()).append(",");
            } else {
                power_depts.append(power_depts1.get(j).getDeptName());
            }
        }
        userVo.setRemark(power_depts.toString());
        //移除缓存
        CacheManager.removeCacheByObject(userVo);
        CacheManager.putCache(token, new Cache(date, userVo, TOKEN_EXPIRE_TIME));
        return Msg.success().add("token", token);
    }

    /**
     * 2.11
     *
     * @MethodName getUnReadCount
     * @Description: 根据用户获取未读通知数量
     * @Param 无
     * @Returnt Msg
     * @Author: 曾文和
     * @CreateDate: 2019-10-17
     * @UpdateUser: 曾文和
     * @UpdateDate: 2019-10-17
     * @UpdateRemark: 更新说明
     * @Version: 1.2.2
     */
    @RequestMapping("notice/getUnReadCount")
    @ResponseBody
    public Msg getUnReadCount(Integer userId) throws Exception {
        if (null == userId) {
            return Msg.fail("用户id不能为空");
        }
        Power_UserVo userVo = userMapper.selectByPrimaryKey(userId);
        if (null == userVo) {
            return Msg.fail("用户id不存在");
        }
        int unReadCount = noticeService.getUnReadCount(userId);
        CacheManager.addExcCount("noExc");
        return Msg.success().add("unReadCount", unReadCount);
    }

    /**
     * @MethodName checkUserName
     * @Description: 根据用户名判断用户是否存在
     * @Param 无
     * @Returnt Msg
     * @Author: 曾文和
     * @CreateDate: 2020-04-22
     * @UpdateUser: 曾文和
     * @UpdateDate: 2020-04-22
     * @UpdateRemark: 更新说明
     * @Version: 1.2.2
     */
    @RequestMapping("checkUserName")
    @ResponseBody
    public Msg checkUserName(String userName) throws Exception {
        if (StringUtils.isBlank(userName)) {
            return Msg.fail("工号不能为空!");
        }
        //查询用户
        List<Power_User> user = userMapper.checkUserName(userName);
        if (null == user || user.isEmpty()) {
            return Msg.fail("该工号不存在!");
        }
        return Msg.success().add("user", user);
    }

    /**
     * @MethodName sendEmrRecordApproveNotice
     * @Description: 给病案管理系统发送审批通知
     * @Param applyType 申请类型
     * @Param count 新的待审批份数
     * @Returnt Msg
     * @Author: 曾文和
     * @CreateDate: 2020-04-24
     * @UpdateUser: 曾文和
     * @UpdateDate: 2020-04-24
     * @UpdateRemark: 更新说明
     * @Version:
     */
    @RequestMapping("sendEmrRecordApproveNotice")
    @ResponseBody
    public void sendEmrRecordApproveNotice(String applyType, Integer count) {
        try {
            String title = "待审批通知";
            String content = "您有" + count + "份" + applyType + "待审批!";
            //查询有借阅审批权限的id集合
            String menuUrl = "/approve/updateApprove";
            List<Power_User> users = userMapper.selectUserIdsWithApprove(menuUrl);
            for (Power_User user : users) {
                if (null != user) {
                    WsPool.sendMessageToAll("emr_record_" + user.getUserId(), title + STR_SPLIT + content + STR_SPLIT + "emr_record");
                }
            }
        } catch (Exception e) {
            ExceptionPrintUtil.printException(e);
            e.printStackTrace();
        }
    }

    /**
     * 根据当前登录用户工号获取所在科室编号
     *
     * @return String
     * @throws Exception
     * @CreateDate: 2021-08-30
     * @UpdateUser: wzq
     */
    @RequestMapping(value = "/getDeptCodeByUserName", produces = "text/plain;charset=UTF-8")
    @ResponseBody
    public String getDeptCodeByDeptId(Integer deptId) throws Exception {
        Power_Dept power_dept = power_deptService.selectByPrimaryKey(deptId);
        return power_dept.getDeptCode();
    }

    /**
     * 根据病案deptcode，查询出所有符合的科主任，数据：用户id，用户名称，科室名称
     */
    @RequestMapping(value = "/getUserInfoByDeptCodeForChief", produces = "text/plain;charset=UTF-8")
    @ResponseBody
    public String getUserInfoByDeptCodeForChief(String DeptCode) {
        List<Power_User> power_users = power_userMapper.selectAllForChief(DeptCode);
        String result = "";
        for (int i = 0; i < power_users.size(); i++) {
            Power_User power_user = power_users.get(i);
            result += power_user.getUserId() + "," + power_user.getUserName() + "," + power_user.getName() + ";";
        }
        return result;
    }

    /**
     * 根据病案deptcode，查询出所有符合的病案室用户，需要用户id，用户名称，科室名称
     */
    @RequestMapping(value = "/getUserInfoByDeptCodeForRecordRoom", produces = "text/plain;charset=UTF-8")
    @ResponseBody
    public String getUserInfoByDeptCodeForRecordRoom() {
        List<Power_User> power_users = power_userMapper.selectAllForRecordRoom();
        String result = "";
        for (int i = 0; i < power_users.size(); i++) {
            Power_User power_user = power_users.get(i);
            result += power_user.getUserId() + "," + power_user.getUserName() + "," + power_user.getName() + ";";
        }
        return result;
    }


    /**
     * 通过申请医生id，获取医生名字
     */
    @RequestMapping(value = "/getDoctorNameAndDoctorRoom", produces = "text/plain;charset=UTF-8")
    @ResponseBody
    public String getDoctorNameAndDoctorRoom(String userId) {
        String name = power_userMapper.selectForDoctorName(userId);
        if (StringUtils.isEmpty(name)) {
            name = "未设置名字账号";
        }
//        获取的是deptId数组
        String deptIDResult = powerDeptMapper.selectAllDeptId(userId);
        String room = "";
//        拆分成单一的deptId
        if (!StringUtils.isEmpty(deptIDResult) && deptIDResult.contains(",")) {
            String[] deptIdAll = deptIDResult.split(",");
            for (int i = 0; i < deptIdAll.length; i++) {
                String deptIdOne = power_userMapper.selectForDoctorRoom(deptIdAll[i]);
                if (!StringUtils.isEmpty(deptIdOne)) {
                    room += deptIdOne + "和";
                } else {
                    room = "未分配科室账号";
                }
            }
            room = room.substring(0, room.length() - 1);
        } else {
            String deptIdOne = power_userMapper.selectForDoctorRoom(deptIDResult);
            if (StringUtils.isEmpty(deptIdOne)) {
                room = "未分配科室账号";
            } else {
                room = deptIdOne;
            }
        }
        String result = room + "," + name;
        return result;
    }

    /**
     * 通过userName获取deptcode
     */
    @RequestMapping(value = "/getDoctorDeptcode", produces = "text/plain;charset=UTF-8")
    @ResponseBody
    public String getDoctorDeptcode(Integer userId) {
        //获取deptId
        String deptId = power_userMapper.selectForDeptId(userId);
        //获取deptcode
        StringBuilder result = new StringBuilder();
        String[] deptIdSingle = deptId.split(",");
        if (deptIdSingle != null && deptIdSingle.length > 0) {
            for (int i = 0; i < deptIdSingle.length; i++) {
                String deptCode = power_userMapper.selectForDeptCode(deptIdSingle[i]);
                result.append(deptCode).append(",");
            }
        }
        return result.toString();
    }

    /**
     * 通过userName获取realName
     */
    @RequestMapping(value = "/getRealName", produces = "text/plain;charset=UTF-8")
    @ResponseBody
    public String getRealName(String userName) {
        //获取realName
        String realName = power_userMapper.selectForRealName(userName);
        return realName;
    }

    /**
     * 通过deptcode获取科室中文名称
     */
    @RequestMapping(value = "/getDeptCodeByChinese", produces = "text/plain;charset=UTF-8")
    @ResponseBody
    public String getDeptCodeByChinese(String deptCode) {
        //获取realName
        Power_Dept deptCodeByChinese = powerDeptMapper.getDeptCodeByChinese(deptCode);
        String deptName = deptCodeByChinese.getDeptName();
        return deptName;
    }


    /**
     * 从高明更新至湛江，2021/11/20
     */
    @RequestMapping("sendMessage")
    @ResponseBody
    public Msg sendMessage(Message message) throws Exception {
        if (null == message.getUserId()) {
            return Msg.fail("消息用户id不能为空");
        }
        if (StringUtils.isBlank(message.getSysFlag())) {
            return Msg.fail("消息系统标识不能为空");
        }
        if (StringUtils.isBlank(message.getTitle())) {
            return Msg.fail("消息标题不能为空");
        }
        if (StringUtils.isBlank(message.getContent())) {
            return Msg.fail("消息内容不能为空");
        }
        WsPool.sendMessageToAll(message.getSysFlag() + "_" + message.getUserId(), message.getTitle() + STR_SPLIT + message.getContent() + STR_SPLIT + message.getTypeFlag());

        return Msg.success();
    }

    /**
     * 从高明更新至湛江，2021/11/20
     * 修改为向特定用户发送信息
     * 特定用户科主任，病案室
     * 科主任需要判定是否和病案的科室相符，
     * 病案室直接发送未审核数量
     */
    @RequestMapping(value = "sendMessageWithNew")
    @ResponseBody
    public Msg sendMessageWithNew(Message message) throws Exception {
        if (null == message.getUserId()) {
            return Msg.fail("消息用户id不能为空");
        }
        if (StringUtils.isBlank(message.getSysFlag())) {
            return Msg.fail("消息系统标识不能为空");
        }
        if (StringUtils.isBlank(message.getTitle())) {
            return Msg.fail("消息标题不能为空");
        }
        if (StringUtils.isBlank(message.getContent())) {
            return Msg.fail("消息内容不能为空");
        }
        WsPool.sendMessageToAll(message.getSysFlag() + "_" + message.getUserId(), message.getTitle() + STR_SPLIT + message.getContent() + STR_SPLIT + message.getTypeFlag());

        return Msg.success();
    }

    /**
     * 从高明更新至湛江，2021/11/29
     * 修改为向特定用户发送信息,不使用sysflag
     * 特定用户科主任，病案室
     * 科主任需要判定是否和病案的科室相符，
     * 病案室直接发送未审核数量
     */
    @RequestMapping(value = "sendMessageWithNewWithOutSysFlag")
    @ResponseBody
    public Msg sendMessageWithNewWithOutSysFlag(Message message) throws Exception {
        if (null == message.getUserId()) {
            return Msg.fail("消息用户id不能为空");
        }
        if (StringUtils.isBlank(message.getTitle())) {
            return Msg.fail("消息标题不能为空");
        }
        if (StringUtils.isBlank(message.getContent())) {
            return Msg.fail("消息内容不能为空");
        }
        WsPool.sendMessageToAll(message.getUserId().toString(), message.getTitle() + STR_SPLIT + message.getContent() + STR_SPLIT + message.getTypeFlag());
        return Msg.success();
    }


    /**
     * 获取该deptCode对应的所有用户信息包括：userId,userName,userRoleId
     */
    @RequestMapping(value = "/getAllUserInfoByDeptCode", produces = "text/plain;charset=UTF-8")
    @ResponseBody
    public String getAllUserInfoByDeptCode(String deptCode) {
//        deptCode获取userId,userName,userRoleId
        List<Power_User> power_users = power_userMapper.selectDeptIdByDeptCode(deptCode);
        String result = "";
        for (Power_User power_user : power_users) {
            result += power_user.getUserId() + "," + power_user.getName() + "," + power_user.getRoleId() + ";";
        }
        return result;
    }

    /**
     * 获取roleId=22所有用户信息包括：userId,userName
     */
    @RequestMapping(value = "/getAllUserForRoom", produces = "text/plain;charset=UTF-8")
    @ResponseBody
    public String getAllUserForRoom() {
//        获取roleId=22的userId,userName
        List<Power_User> power_users = power_userMapper.selectAllRoomUser();
        String result = "";
        for (Power_User power_user : power_users) {
            result += power_user.getUserId() + "," + power_user.getName() + ";";
        }
        return result;
    }

    /**
     * 获取userName对应的真实姓名
     * return 如果在设置了名字，就返回名称，如果没有，就返回名称未设置
     */
    @RequestMapping(value = "/getUserNameForSave", produces = "text/plain;charset=UTF-8")
    @ResponseBody
    public String getUserNameForSave(String userName) {
//        获取userName对应的真实姓名
        String realName = power_userMapper.selectForRealName(userName);
        if (StringUtils.isNotBlank(realName)) {
            return realName;
        } else {
            return "该账号未设置姓名";
        }
    }

}