system/tianhu-system/src/main/java/com/tianhu/system/controller/SysUserController.java

package com.tianhu.system.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.tianhu.common.core.constant.CacheConstants;
import com.tianhu.common.core.constant.Constants;
import com.tianhu.common.core.constant.SalaryConstants;
import com.tianhu.common.core.constant.UserConstants;
import com.tianhu.common.core.domain.R;
import com.tianhu.common.core.exception.BaseException;
import com.tianhu.common.core.utils.CommonUtil;
import com.tianhu.common.core.utils.IdUtils;
import com.tianhu.common.core.utils.SecurityUtils;
import com.tianhu.common.core.utils.StringUtils;
import com.tianhu.common.core.utils.poi.ExcelUtil;
import com.tianhu.common.core.web.controller.BaseController;
import com.tianhu.common.core.web.domain.AjaxResult;
import com.tianhu.common.log.annotation.Log;
import com.tianhu.common.log.enums.BusinessType;
import com.tianhu.common.redis.service.RedisService;
import com.tianhu.common.security.annotation.PreAuthorize;
import com.tianhu.common.security.service.TokenService;
import com.tianhu.system.api.RemoteSystemService;
import com.tianhu.system.api.domain.SysDept;
import com.tianhu.system.api.domain.SysRole;
import com.tianhu.system.api.domain.SysUser;
import com.tianhu.system.api.model.LoginUser;
import com.tianhu.system.common.IMessageUtilsService;
import com.tianhu.system.common.ValidateCodeService;
import com.tianhu.system.domain.*;
import com.tianhu.system.domain.vo.TreeSelect;
import com.tianhu.system.mapper.SysDeptMapper;
import com.tianhu.system.mapper.SysUserMapper;
import com.tianhu.system.mapper.SysUserRoleMapper;
import com.tianhu.system.service.*;
import com.tianhu.system.utils.FlowableService;
import com.tianhu.system.utils.SysConstant;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * 用户信息
 *
 * @author tianhu
 */
@RestController
@RequestMapping("/user")
public class SysUserController extends BaseController
{
    @Autowired
    private ISysUserService userService;

    @Autowired
    private ISysRoleService roleService;

    @Autowired
    private ISysDeptService deptService;

    @Autowired
    private ISysPermissionService permissionService;
    @Autowired
    private ISysUserRoleService   iSysUserRoleService;
    @Autowired
    private TokenService tokenService;
    @Autowired
    private ISysUserCompanyRelService userCompanyRelService;
    @Autowired
    private ISysCompanyService companyService;
    @Autowired
    private IPubVerifyCodeService iPubVerifyCodeService;
    @Autowired
    private ISysConfigService configService;
    @Autowired
    private RedisService redisService;
    @Autowired
    private ISysWeChatService iSysWeChatService;
    @Autowired
    private FlowableService flowableService;
    @Autowired
    private SysUserMapper userMapper;
    @Autowired
    private SysUserRoleMapper userRoleMapper;
    @Autowired
    private SysDeptMapper deptMapper;
    @Autowired
    private IMessageUtilsService messageUtilsService;
    @Autowired
    private ISysCompanyService sysCompanyService;
    @Autowired
    private RemoteSystemService remoteSystemService;
    /**
     * 用户注册成功
     */
    private String zhucechenggong = "zhucechenggong";
    @Autowired
    private ValidateCodeService validateCodeService;

    //    下载模板
    @PostMapping("/importTemplate")
    public void importTemplate(HttpServletResponse response) throws IOException
    {
        ExcelUtil<OwnSysUser> util = new ExcelUtil<OwnSysUser>(OwnSysUser.class);
        util.importTemplateExcel(response, "用户数据");
    }

    //    导入
    @Log(title = "用户管理", businessType = BusinessType.IMPORT)
    @PreAuthorize(hasPermi = "system:user:import")
    @PostMapping("/importData")
    public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception
    {
        ExcelUtil<OwnSysUser> util = new ExcelUtil<OwnSysUser>(OwnSysUser.class);
        List<OwnSysUser> userList = util.importExcel(file.getInputStream());
        //获取当前用户名
        LoginUser user = tokenService.getLoginUser();
        String operName = user.getSysUser().getNickName();
        String message = userService.importUser(userList, updateSupport, operName);
        return AjaxResult.success(message);
    }

//    //    下载模板
//    @PostMapping("/importTemplate")
//    public void importTemplate(HttpServletResponse response) throws IOException
//    {
//        ExcelUtil<OwnSysUser> util = new ExcelUtil<OwnSysUser>(OwnSysUser.class);
//        util.importTemplateExcel(response, "用户数据");
//    }


    /**
     * 获取当前用户信息
     */
    @PostMapping("/zcInfo")
    @Transactional(rollbackFor = Exception.class)
    public R<Map<String, Object>> info(@RequestParam(value = "type", required = false) String type,
                                       @RequestParam(value = "code", required = false) String code,
                                       @RequestParam(value = "uuid", required = false) String uuid,
                                       @RequestParam(value = "unionId", required = false) String unionId,
                                       @RequestParam(value = "username") String username,
                                       @RequestParam(value = "shortMessageCode", required = false) String shortMessageCode)
    {
        Map<String, Object> resMap = new HashMap<>();

        validateCodeService.checkCapcha(code, uuid, true);

        SysUser sysUser = userService.selectUserByUserName(username);
        // 短信验证码登陆 或者 验证码注册
        if ("1".equals(type) || "2".equals(type)) {
            // 验证短信验证码
            if(CommonUtil.isNotEmpty(shortMessageCode)){
                LambdaQueryWrapper<PubVerifyCode> pubVerifyCode = new LambdaQueryWrapper<>();
                pubVerifyCode.eq(PubVerifyCode::getPvcPhone,username);
                pubVerifyCode.eq(PubVerifyCode::getPvcCode,shortMessageCode);
                pubVerifyCode.orderByDesc(PubVerifyCode::getPvcLastTime);
                List<PubVerifyCode> staffInf = iPubVerifyCodeService.findPubVerifyCodes(pubVerifyCode);
                if(staffInf.size()>0){
                    if("01".equals(staffInf.get(0).getPvcState())){
                        throw new BaseException("验证码已使用,请重新获取！");
                    }
                    //取得指定时间间隔后的系统时间
                    GregorianCalendar calendar = (GregorianCalendar) Calendar.getInstance();
                    calendar.add( Calendar.MINUTE, -5);
                    SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss");
                    if(formatter.format(calendar.getTime()).compareTo(formatter.format(staffInf.get(0).getPvcLastTime()))>0){
                        throw new BaseException("验证码已过期,请重新获取！");
                    }

                    staffInf.get(0).setPvcState("01");
                    iPubVerifyCodeService.updatePubVerifyCode(staffInf.get(0));

                }else{
                    throw new BaseException("验证码校验失败请重新发送验证码！");
                }
            }else{
                throw new BaseException("请填写验证码！");
            }

            // 未注册账号,自动注册一个账号
            if ("1".equals(type) && StringUtils.isNull(sysUser)) {
                sysUser = new SysUser();
                sysUser.setUserName(username);
                sysUser.setNickName(username);
                String password = configService.selectConfigByKey("sys.user.initPassword");
                sysUser.setPassword(SecurityUtils.encryptPassword(password));
                userService.insertUser(sysUser);
                sysUser = userService.selectUserByUserName(username);

                LoginUser sysUserVo = new LoginUser();
                sysUserVo.setSysUser(sysUser);
                resMap.put("code", "0");
                resMap.put("message", "用户未绑定企业");
                resMap.put("loginUser", sysUserVo);
                return R.ok(resMap);
            }

            // 扫码后注册
            if ("2".equals(type)) {
                if (StringUtils.isNotNull(sysUser)) {
                    throw new BaseException("手机号已被注册!");
                }
                if (StringUtils.isEmpty(unionId)) {
                    throw new BaseException("unionId数据错误!");
                }

                //查询微信关联表找到员工信息
                LambdaQueryWrapper<SysWeChat> weChatLambdaQueryWrapper = new LambdaQueryWrapper<>();
                weChatLambdaQueryWrapper.eq(SysWeChat::getSwcWxUuid, unionId);
                List<SysWeChat> list = iSysWeChatService.findSysWeChats(weChatLambdaQueryWrapper);
                if (list.size() != 0) {
                    throw new BaseException("此微信已绑定账号!");
                }

                sysUser = new SysUser();
                sysUser.setUserName(username);
                sysUser.setNickName(username);
                String password = configService.selectConfigByKey("sys.user.initPassword");
                sysUser.setPassword(SecurityUtils.encryptPassword(password));
                userService.insertUser(sysUser);
                sysUser = userService.selectUserByUserName(username);

                String  wechatId  =  IdUtils.fastSimpleUUID();
                SysWeChat sysWeChat = new SysWeChat();
                sysWeChat.setSwcId(wechatId);
                sysWeChat.setSwcUserId(String.valueOf(sysUser.getUserId()));
                sysWeChat.setSwcStatus("00");
                sysWeChat.setSwcWxUuid(unionId);
                iSysWeChatService.createSysWeChat(sysWeChat);

                LoginUser sysUserVo = new LoginUser();
                sysUserVo.setSysUser(sysUser);
                resMap.put("code", "0");
                resMap.put("message", "用户未绑定企业");
                resMap.put("loginUser", sysUserVo);
                return R.ok(resMap);
            }

        // 密码登陆
        } else {
            if (StringUtils.isNull(sysUser))
            {
                throw new BaseException("用户名或密码错误");
            }
        }
        // 查询是否实名认证
        LambdaQueryWrapper<SysUserCompanyRel> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(SysUserCompanyRel::getSucrUserId, sysUser.getUserId());
        List<SysUserCompanyRel> userCompanyRelList = userCompanyRelService.findSysUserCompanyRels(lambdaQueryWrapper);

        // 未认证
        if (userCompanyRelList.size() == 0) {
            resMap.put("code", "0");
            resMap.put("message", "用户未绑定企业");
            LoginUser sysUserVo = new LoginUser();
            sysUserVo.setSysUser(sysUser);
            resMap.put("loginUser", sysUserVo);
        // 只绑定了一家企业
        } else if (userCompanyRelList.size() == 1) {
            resMap.put("code", "1");
            resMap.put("message", "用户已绑定一家企业");

            // 绑定企业
            sysUser.setCompanyId(userCompanyRelList.get(0).getSucrCompanyId());
            // 不是平台
            if(!SysConstant.PLATFORM_NO.equals(sysUser.getCompanyId()) ){
                // 绑定部门
                sysUser.setDeptId(userCompanyRelList.get(0).getSucrDeptId());
                SysDept dept = deptService.selectDeptById(userCompanyRelList.get(0).getSucrDeptId());
                sysUser.setDept(dept);
                // 存放企业类型
                SysCompany company = companyService.getById(userCompanyRelList.get(0).getSucrCompanyId());
                sysUser.setCompanyType(company.getScyType());
                if ("01".equals(company.getScyStatus()) || "99".equals(company.getScyStatus())) {
                    throw new BaseException("企业状态异常,请联系管理员!");
                }
                sysUser.setCompanyStatus(company.getScyStatus());
             // 平台用户
            } else {
                sysUser.setCompanyType("00");
                sysUser.setCompanyStatus("00");
            }
            // 角色集合
            Set<String> roles = permissionService.getRolePermission(sysUser.getUserId(), sysUser.getCompanyId());
            Set<String> permissions = this.getPermissions(sysUser);

            LoginUser sysUserVo = new LoginUser();
            sysUserVo.setRoles(roles);
            sysUserVo.setPermissions(permissions);
            sysUserVo.setSysUser(sysUser);

            resMap.put("loginUser", sysUserVo);
        // 绑定多加企业
        } else {
            LoginUser sysUserVo = new LoginUser();
            sysUserVo.setSysUser(sysUser);
            resMap.put("loginUser", sysUserVo);

            List<String> companyIdList = new ArrayList<>();
            for (SysUserCompanyRel companyRel : userCompanyRelList) {
                companyIdList.add(companyRel.getSucrCompanyId());
            }
            LambdaQueryWrapper<SysCompany> companyLambdaQueryWrapper = new LambdaQueryWrapper<>();
            companyLambdaQueryWrapper.in(SysCompany::getScyId, companyIdList);
            List<SysCompany> companyList = companyService.findSysCompanys(companyLambdaQueryWrapper);

            resMap.put("code", "2");
            resMap.put("message", "用户已绑定" + userCompanyRelList.size() + "家企业");
            resMap.put("companyList", companyList);
        }
        return R.ok(resMap);
    }

    @PostMapping("/chooseCompanyLogin")
    public R<LoginUser> chooseCompanyLogin(@RequestBody Map<String, String> param, HttpServletRequest request)
    {
        String companyId = param.get("companyId");
        if (StringUtils.isEmpty(companyId)) {
            return R.fail("请选择登陆企业!");
        }
        LoginUser loginUser = tokenService.getLoginUser();
        LambdaQueryWrapper<SysUserCompanyRel> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(SysUserCompanyRel::getSucrUserId, loginUser.getUserid());
        lambdaQueryWrapper.eq(SysUserCompanyRel::getSucrCompanyId, companyId);
        List<SysUserCompanyRel> userCompanyRelList = userCompanyRelService.findSysUserCompanyRels(lambdaQueryWrapper);
        if (userCompanyRelList.size() == 0) {
            return R.fail("用户未关联选择企业!");
        }
        // 查询企业信息
        SysCompany company = companyService.getById(companyId);
        if ("01".equals(company.getScyStatus()) || "99".equals(company.getScyStatus())) {
            return R.fail("企业状态异常,请联系管理员!");
        }

        SysUser sysUser = loginUser.getSysUser();
        sysUser.setCompanyId(companyId);
        sysUser.setCompanyType(company.getScyType());
        sysUser.setCompanyStatus(company.getScyStatus());

        // 角色集合
        Set<String> roles = permissionService.getRolePermission(sysUser.getUserId(), sysUser.getCompanyId());
        Set<String> permissions = this.getPermissions(sysUser);

        loginUser.setRoles(roles);
        loginUser.setPermissions(permissions);
        loginUser.setSysUser(sysUser);

        String token = SecurityUtils.getToken(request);
        redisService.setCacheObject(CacheConstants.LOGIN_TOKEN_KEY + token, loginUser, Constants.TOKEN_EXPIRE * 60, TimeUnit.SECONDS);
        return R.ok(loginUser);
    }

    /**
     * 获取用户信息
     *
     * @return 用户信息
     */
    @GetMapping("getInfo")
    public AjaxResult getInfo()
    {
        Long userId = SecurityUtils.getUserId();
        SysUser user = tokenService.getLoginUser().getSysUser();
        // 角色集合
        Set<String> roles = permissionService.getRolePermission(userId, user.getCompanyId());

        //公司用户判断角色isAuto是否包括1数据，如包含则菜单权限数据取企业-产品-菜单数据
        //不包含则取角色-菜单 与 企业产品菜单数据并集
        //获取用户角色列表，判断是否存在isAuto
//        SysUser user = userService.selectUserById(userId);

        // 权限集合
        System.out.println("getInfo 菜单权限加载开始");
        Set<String> permissions = this.getPermissions(user);
        for(String p:permissions){
            System.out.println(p);
        }
        System.out.println("getInfo 菜单权限加载结束");
        AjaxResult ajax = AjaxResult.success();
        ajax.put("user", user);
        ajax.put("roles", roles);
        ajax.put("permissions", permissions);
        return ajax;
    }

    /**
     * 获取用户权限
     * @param user
     * @return
     */
    private Set<String> getPermissions(SysUser user){
        Set<String> permissions = new HashSet<String>();
        //平台走原流程
        if(SysConstant.PLATFORM_NO.equals(user.getCompanyId()) ){
            permissions = permissionService.getMenuPermission(user.getUserId());
            System.out.println("平台用户");
        }else{
            List<String> roleList = permissionService.getRoles(user.getUserId().toString(), user.getCompanyId());
            //初始用户，菜单权限数据取企业产品菜单数据
            if(roleList.contains(SysConstant.ROLE_IS_AUTO)){
                permissions = permissionService.getMenuByAutoUser(user);
                System.out.println("企业初始用户");
            }else{
                //非初始用户菜单数据取  角色菜单-公司产品菜单数据并集
                permissions = permissionService.getMenuByCommonUser(user);
                System.out.println("企业普通用户");
            }
        }
        return permissions;
    }
    /**
     * 根据用户编号获取详细信息
     */
    @PreAuthorize(hasPermi = "system:user:query")
    @GetMapping(value = { "/", "/{userId}" })
    public AjaxResult getInfo(@PathVariable(value = "userId", required = false) Long userId)
    {
        //获取当前操作人员
        LoginUser userInfo = tokenService.getLoginUser();
        String companyId = userInfo.getSysUser().getCompanyId();
        AjaxResult ajax = AjaxResult.success();
        //角色
        SysRole role = new SysRole();
        role.setIsAuto("0");
        Map map = new HashMap<>();
//        if(!SalaryConstants.OPEX.equals(companyId)){
            map.put("companyId",companyId);
            role.setCompanyId(companyId);
//        }
        List<SysRole> roles = roleService.selectRoleAll(role);
        ajax.put("roles", SysUser.isAdmin(userId) ? roles : roles.stream().filter(r -> !r.isAdmin() ).collect(Collectors.toList()));
        if (StringUtils.isNotNull(userId))
        {
            ajax.put(AjaxResult.DATA_TAG, userService.selectUserById(userId, companyId));
            ajax.put("roleIds", roleService.selectRoleListByUserId(userId));

        }
        return ajax;
    }

    /**
     * 新增用户
     */
    @PreAuthorize(hasPermi = "system:user:add")
    @Log(title = "用户管理", businessType = BusinessType.INSERT)
    @PostMapping
    @Transactional(rollbackFor=Exception.class)
    public AjaxResult add(@Validated @RequestBody SysUser user) throws Exception {
        LoginUser userInfo = tokenService.getLoginUser();
        SysUser use = userInfo.getSysUser();
        String companyId = use.getCompanyId();
        //000000：代表运维人员
        if(!SalaryConstants.OPEX.equals(use.getCompanyId())){
            user.setCompanyId(companyId);
        }else {
            if(user.getCompanyId() == null){
                user.setCompanyId(companyId);
            }
        }

        if(user.getRoleIds().length == 0){
            return AjaxResult.error("新增用户'" + user.getUserName() + "'失败，请先选择角色");
        }

        String password = configService.selectConfigByKey("sys.user.initPassword");

        //查询用户是否存在
        Map useMap = new HashMap();
        useMap.put("userName",user.getUserName());
        List<Map> listNormalUser = userService.selectNormalUser(useMap);
        if(listNormalUser.size() > 0){
           //获取用户Id
           String userId = listNormalUser.get(0).get("userId")+"";
           //查询此企业是否存在此用户
           LambdaQueryWrapper<SysUserCompanyRel> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(SysUserCompanyRel::getSucrUserId,userId);
            queryWrapper.eq(SysUserCompanyRel::getSucrCompanyId,companyId);
            List<SysUserCompanyRel> list = userCompanyRelService.findSysUserCompanyRels(queryWrapper);
            if(list.size() > 0){
                return AjaxResult.error("新增用户'" + user.getUserName() + "'失败，用户已存在");
            }
        } else{
            user.setStatus("0");
            user.setPassword(password);
            user.setCreateBy(SecurityUtils.getUsername());
            userMapper.insertUser(user);
        }

        SysUser queryUser = userService.selectUserByUserName(user.getUserName());
        Long[] roles = user.getRoleIds();
        if (StringUtils.isNotNull(roles))
        {
            // 新增用户与角色管理
            List<SysUserRole> list = new ArrayList<SysUserRole>();
            for (Long roleId : roles)
            {
                SysUserRole ur = new SysUserRole();
                ur.setUserId(queryUser.getUserId());
                ur.setRoleId(roleId);
                list.add(ur);
            }
            if (list.size() > 0)
            {
                userRoleMapper.batchUserRole(list);
            }
        }

        SysUserCompanyRel userCompanyRel = new SysUserCompanyRel();
        userCompanyRel.setSucrUserId(queryUser.getUserId());
        userCompanyRel.setSucrCompanyId(companyId);
        userCompanyRel.setSucrHandler("0");
        userCompanyRel.setSucrDeptId(user.getDeptId());
        userCompanyRelService.createSysUserCompanyRel(userCompanyRel);



        // 审批表增加数据
//        Map<String, Object> flowableRes = flowableService.addFlowableUser(String.valueOf(queryUser.getUserId()), user.getNickName(), use.getCompanyId());
//        if (!"200".equals(flowableRes.get("code"))) {
//            throw new Exception("审批数据新增失败!");
//        }
//        SysDept dept = deptMapper.selectDeptById(use.getDeptId());
//        flowableRes = flowableService.addFlowableUser(String.valueOf(queryUser.getUserId()), user.getNickName(), dept.getAlternateNumber());
//        if (!"200".equals(flowableRes.get("code"))) {
//            throw new Exception("审批数据新增失败!");
//        }
//        //获取企业信息
//        SysCompany sysCompany = sysCompanyService.getById(companyId);
//        //待办标题
//        String tittle = "【" +sysCompany.getScyName()+"】尊敬的用户，您好! 欢迎您来到招采云链医疗供应链金融平台，平台将提供：" +
//                "医疗招商、医疗集采、供应链金融等企业级服务，如果您再平台使用中遇到任何问题，" +
//                "请再首页查看并拨打平台客服专线电话，我们将竭尽所能为您提供免费的咨询服务";
//        remoteSystemService.sendNotice(use.getCompanyId(),use.getCompanyId(),tittle,"01","00",null,"0",String.valueOf(queryUser.getUserId()),null);
        if (listNormalUser.size() < 0) {
            Map passwordMap =new HashMap();
            passwordMap.put("password",password);
            messageUtilsService.sendMessageCode(user.getPhonenumber(),zhucechenggong,passwordMap,null);
        }
        return toAjax(1);
    }

    /**
     * 修改用户
     */
    @PreAuthorize(hasPermi = "system:user:edit")
    @Transactional(rollbackFor=Exception.class)
    @Log(title = "用户管理", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult edit(@Validated @RequestBody SysUser user)
    {
        LoginUser userInfo = tokenService.getLoginUser();
        SysUser use = userInfo.getSysUser();
        String companyId = use.getCompanyId();
        if(SalaryConstants.OPEX.equals(companyId)) {
            String com = user.getCompanyId();
            if (CommonUtil.isEmpty(com)) {
                return AjaxResult.error("修改用户'" + user.getNickName() + "'失败，请选择公司");
            }
            userService.checkUserAllowed(user);
            if (UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user))) {
                return AjaxResult.error("修改用户'" + user.getNickName() + "'失败，手机号码已存在");
            }
            else if (UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user))) {
                return AjaxResult.error("修改用户'" + user.getNickName() + "'失败，邮箱账号已存在");
            }
            user.setUpdateBy(CommonUtil.objToString(SecurityUtils.getUserId()));
        }else if(!SalaryConstants.OPEX.equals(companyId)){
            userService.checkUserAllowed(user);
            if (UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user))) {
                return AjaxResult.error("修改用户'" + user.getNickName() + "'失败，手机号码已存在");
            }
            else if (UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user))) {
                return AjaxResult.error("修改用户'" + user.getNickName() + "'失败，邮箱账号已存在");
            }
            user.setUpdateBy(CommonUtil.objToString(SecurityUtils.getUserId()));
        }
        return toAjax(userService.updateUser(user));
    }

    /**
     * 删除用户
     */
    @PreAuthorize(hasPermi = "system:user:remove")
    @Log(title = "用户管理", businessType = BusinessType.DELETE)
    @DeleteMapping("/{userIds}")
    public AjaxResult remove(@PathVariable Long[] userIds)
    {
        return toAjax(userService.deleteUserByIds(userIds));
    }

    /**
     * 重置密码
     */
    @PreAuthorize(hasPermi = "system:user:edit")
    @Log(title = "用户管理", businessType = BusinessType.UPDATE)
    @PutMapping("/resetPwd")
    public AjaxResult resetPwd(@RequestBody SysUser user)
    {
        String regEx = "[\u4e00-\u9fa5]";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(user.getPassword());
        if(m.find()){
            return AjaxResult.error("请输入字母、数字、特殊符号格式编码");
        }
        userService.checkUserAllowed(user);
        user.setPassword(SecurityUtils.encryptPassword(user.getPassword()));
        user.setUpdateBy(SecurityUtils.getUsername());
        return toAjax(userService.resetPwd(user));
    }

    /**
     * 状态修改
     */
    @PreAuthorize(hasPermi = "system:user:edit")
    @Log(title = "用户管理", businessType = BusinessType.UPDATE)
    @PutMapping("/changeStatus")
    public AjaxResult changeStatus(@RequestBody SysUser user)
    {
        userService.checkUserAllowed(user);
        user.setUpdateBy(SecurityUtils.getUsername());
        return toAjax(userService.updateUserStatus(user));
    }

    /**
     * 根据企业id获取部门与角色信息
     * @param companyId
     * @return
     */
    @GetMapping("getRoleDept/{companyId}")
    public AjaxResult getRoleDept(@PathVariable String companyId)
    {
        //获取部门信息
        SysDept sysDept = new SysDept();
        sysDept.setCompanyId(companyId);
        sysDept.setStatus("0");
        sysDept.setDelFlag("0");
        List<SysDept> deptList = deptService.selectDeptList(sysDept);
        List<TreeSelect> deptTreeSelect = deptService.buildDeptTreeSelect(deptList);
        //获取角色信息
        SysRole sysRole = new SysRole();
        sysRole.setIsAuto("0");
        sysRole.setCompanyId(companyId);
        sysRole.setStatus("0");
        sysRole.setDelFlag("0");
        List<SysRole> roleList = roleService.selectRoleList(sysRole);
        //传入前台
        AjaxResult ajax = AjaxResult.success();
        ajax.put("deptList", deptTreeSelect);
        ajax.put("roleList", roleList);
        return ajax;
    }

}