package com.tievd.cube.modules.system.controller;

import cn.dev33.satoken.annotation.SaCheckRole;
import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.databind.JsonNode;
import com.tievd.cube.commons.annotations.AutoLog;
import com.tievd.cube.commons.annotations.DictApi;
import com.tievd.cube.commons.annotations.DictMethod;
import com.tievd.cube.commons.base.CubeController;
import com.tievd.cube.commons.base.Result;
import com.tievd.cube.commons.constant.CommonConst;
import com.tievd.cube.commons.easyexcel.model.ImportExcel;
import com.tievd.cube.commons.enums.OperateLogType;
import com.tievd.cube.commons.mybatisplus.QueryGenerator;
import com.tievd.cube.commons.utils.SystemContextUtil;
import com.tievd.cube.commons.utils.crypto.PasswordUtil;
import com.tievd.cube.commons.utils.spring.RedisUtil;
import com.tievd.cube.commons.utils.web.HttpServletUtil;
import com.tievd.cube.modules.system.entity.*;
import com.tievd.cube.modules.system.model.DepartIdModel;
import com.tievd.cube.modules.system.model.LoginUser;
import com.tievd.cube.modules.system.model.SysUserSysDepartModel;
import com.tievd.cube.modules.system.model.api.request.AddSysUserRoleRequest;
import com.tievd.cube.modules.system.model.api.request.EditSysDepartWithUserRequest;
import com.tievd.cube.modules.system.model.api.request.UpdateMobileRequest;
import com.tievd.cube.modules.system.service.*;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 用户管理
 *
 * @author xinwuy
 * @version V1.0.0
 * @since 2021-05-28
 */
@Slf4j
@Tag(name = "用户管理相关接口")
@DictApi
@RestController
@RequestMapping("/sys/user")
public class SysUserController extends CubeController<SysUser, ISysUserService> {

    @Autowired
    private ISysDepartService sysDepartService;
    @Autowired
    private ISysUserRoleService sysUserRoleService;
    @Autowired
    private ISysUserDepartService sysUserDepartService;
    @Autowired
    private ISysDepartRoleUserService departRoleUserService;
    @Autowired
    private ISysDepartRoleService departRoleService;
    @Autowired
    private RedisUtil redisUtil;

    /**
     * 获取用户列表数据
     *
     * @param user     查询条件
     * @param pageNo   页码
     * @param pageSize 每页条数
     */
    @DictMethod
    @GetMapping("/list")
    public Result<IPage<SysUser>> queryPageList(SysUser user, @RequestParam(defaultValue = "1") Integer pageNo, @RequestParam(defaultValue = "10") Integer pageSize, HttpServletRequest req) {
        QueryWrapper<SysUser> queryWrapper = QueryGenerator.initQueryWrapper(user, req.getParameterMap());
        queryWrapper.ne("username", "_reserve_user_external");
        Page<SysUser> page = new Page<>(pageNo, pageSize);
        IPage<SysUser> pageList = service.page(page, queryWrapper);
        // 批量查询用户的所属部门
        List<String> userIds = pageList.getRecords().stream().map(SysUser::getId).collect(Collectors.toList());
        if (userIds.size() > 0) {
            Map<String, String> useDepNames = service.getDepNamesByUserIds(userIds);
            pageList.getRecords().forEach(item -> item.setOrgCodeTxt(useDepNames.get(item.getId())));
        }
        return Result.ok(pageList);
    }

    /**
     * 新增用户
     *
     * @param params 新增参数
     */
    @AutoLog("用户管理-新增用户")
    @PostMapping("/add")
    public Result<?> add(@RequestBody JsonNode params) {
        JsonNode roles = params.get("selectedroles");
        JsonNode departs = params.get("selecteddeparts");
        String selectedRoles = roles != null ? roles.asText() : null;
        String selectedDeparts = departs != null ? departs.asText() : null;
        SysUser user = JSONUtil.toBean(params.toString(), SysUser.class);
        service.add(user, selectedRoles, selectedDeparts);
        return Result.ok();
    }

    /**
     * 更新
     *
     * @param jsonObject 参数
     */
    @PutMapping("/edit")
    public Result<?> edit(@RequestBody JsonNode jsonObject) {
        SysUser sysUser = service.getById(jsonObject.get("id").asText());
        if (sysUser == null) {
            return Result.error("未找到对应实体！");
        }
        SysUser user = JSONUtil.toBean(jsonObject.toString(), SysUser.class);
        user.setUpdateTime(new Date());
        //String passwordEncode = PasswordUtil.encrypt(user.getUsername(), user.getPassword(), sysUser.getSalt());
        user.setPassword(sysUser.getPassword());
        String roles = jsonObject.get("selectedroles").asText();
        String departs = jsonObject.get("selecteddeparts").asText();
        service.editUserWithRole(user, roles);
        service.editUserWithDepart(user, departs);
        service.updateNullPhoneEmail();
        SystemContextUtil.log("编辑用户，id： " + jsonObject.get("id").asText(), OperateLogType.UPDATE);
        return Result.ok();
    }

    /**
     * 删除用户
     *
     * @param id 主键id
     */
    @DeleteMapping("/delete")
    public Result<?> delete(@RequestParam String id) {
        service.deleteUser(id);
        return Result.ok();
    }

    /**
     * 批量删除用户
     *
     * @param ids 主键id（多个逗号分隔）
     */
    @DeleteMapping("/deleteBatch")
    public Result<?> deleteBatch(@RequestParam String ids) {
        service.deleteBatchUsers(ids);
        return Result.ok();
    }

    /**
     * 冻结或解冻用户
     *
     * @param jsonObject status (1 解冻 、2 冻结)
     */
    @AutoLog("用户管理-冻结/解冻用户")
    @PutMapping("/frozenBatch")
    public Result<SysUser> frozenBatch(@RequestBody JsonNode jsonObject) {
        String ids = jsonObject.get("ids").asText();
        String status = jsonObject.get("status").asText();
        String[] arr = ids.split(",");
        for (String id : arr) {
            if (StrUtil.isNotEmpty(id)) {
                service.update(new SysUser().setStatus(Integer.parseInt(status)), new UpdateWrapper<SysUser>().lambda().eq(SysUser::getId, id));
            }
        }
        return Result.ok();
    }

    /**
     * 根据id查询用户角色
     *
     * @param userId 用户id
     */
    @GetMapping("/queryUserRole")
    public Result<List<String>> queryUserRole(@RequestParam String userId) {
        List<String> list = new ArrayList<>();
        List<SysUserRole> userRole = sysUserRoleService.list(new QueryWrapper<SysUserRole>().lambda().eq(SysUserRole::getUserId, userId));
        if (userRole == null || userRole.size() <= 0) {
            return Result.error("未找到用户相关角色信息！");
        }
        for (SysUserRole sysUserRole : userRole) {
            list.add(sysUserRole.getRoleId());
        }
        return Result.ok(list);
    }

    /**
     * 校验用户账号是否唯一
     *
     * @param sysUser 用户信息
     */
    @GetMapping("/checkOnlyUser")
    public Result<?> checkOnlyUser(SysUser sysUser) {
        //通过传入信息查询新的用户信息
        SysUser user = service.getOne(new QueryWrapper<>(sysUser));
        if (user != null) {
            return Result.error("用户账号已存在！");
        }
        return Result.ok(true);
    }

    /**
     * 管理员修改密码
     */
    @SaCheckRole("admin")
    @PutMapping("/changePassword")
    public Result<?> changePassword(@RequestBody SysUser sysUser) {
        SysUser user = service.getOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUsername, sysUser.getUsername()));
        if (user == null) {
            return Result.error("用户不存在！");
        }
        sysUser.setId(user.getId());
        return service.changePassword(sysUser);
    }

    /**
     * 查询指定用户和部门关联的数据
     *
     * @param userId 用户id
     */
    @GetMapping("/userDepartList")
    public Result<List<DepartIdModel>> getUserDepartsList(@RequestParam String userId) {
        List<DepartIdModel> depIdModelList = sysUserDepartService.queryDepartIdsOfUser(userId);
        if (depIdModelList == null || depIdModelList.size() == 0) {
            return Result.error("未绑定部门！");
        }
        return Result.ok("查找成功！", depIdModelList);
    }

    /**
     * 生成在添加用户情况下没有主键的问题
     *
     * @return 返回给前端根据该id绑定部门数据
     */
    @GetMapping("/generateUserId")
    public Result<?> generateUserId() {
        String userId = UUID.randomUUID().toString().replace("-", "");
        return Result.ok(userId);
    }

    /**
     * 根据部门id查询用户信息
     *
     * @param id       部门id
     * @param realname 用户真实姓名
     */
    @GetMapping("/queryUserByDepId")
    public Result<List<SysUser>> queryUserByDepId(@RequestParam String id, @RequestParam(required = false) String realname) {
        SysDepart sysDepart = sysDepartService.getById(id);
        List<SysUser> userList = sysUserDepartService.queryUserByDepCode(sysDepart.getOrgCode(), realname);
        //批量查询用户的所属部门
        //step.1 先拿到全部的 useids
        //step.2 通过 useids，一次性查询用户的所属部门名字
        List<String> userIds = userList.stream().map(SysUser::getId).collect(Collectors.toList());
        if (userIds.size() > 0) {
            Map<String, String> useDepNames = service.getDepNamesByUserIds(userIds);
            userList.forEach(item -> {
                //TODO 临时借用这个字段用于页面展示
                item.setOrgCodeTxt(useDepNames.get(item.getId()));
            });
        }
        return Result.ok(userList);
    }

    /**
     * 导出用户数据为Excel
     *
     * @param sysUser 查询条件
     */
    @GetMapping("/exportXls")
    public void exportXls(SysUser sysUser, HttpServletRequest request, HttpServletResponse response) throws IOException, IllegalAccessException {
        QueryWrapper<SysUser> queryWrapper = QueryGenerator.initQueryWrapper(sysUser, request.getParameterMap());
        String selections = request.getParameter("selections");
        if (StrUtil.isNotEmpty(selections)) {
            queryWrapper.in("id", ListUtil.toList(selections.split(",")));
        }
        List<SysUser> sysUsers = service.list(queryWrapper);
        //导出文件名称
        String date = DateUtil.format(new Date(), "yyyyMMddHHmmss");
        HttpServletUtil.addDownloadHeader(response, "用户数据-" + date + easyExcel.getExtension());
        easyExcel.export(sysUsers, response.getOutputStream(), SystemContextUtil.dictTranslator());
    }

    /**
     * 通过Excel导入用户数据
     */
    @PostMapping("/importExcel")
    @AutoLog("用户管理-通过Excel导入用户数据")
    public Result<?> importExcel(HttpServletRequest request) throws Exception {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        // 错误信息
        List<String> errorMessages = new ArrayList<>();
        int successLines = 0, errorLines = 0;
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            MultipartFile file = entity.getValue();// 获取上传文件对象
            try (InputStream inputStream = file.getInputStream()) {
                ImportExcel excel = new ImportExcel();
                excel.setInputStream(inputStream);
                List<SysUser> sysUsers = easyExcel.read(SysUser.class, excel, SystemContextUtil.dictTranslator());
                for (int i = 0; i < sysUsers.size(); i++) {
                    SysUser sysUser = sysUsers.get(i);
                    if (StrUtil.isBlank(sysUser.getPassword())) {
                        sysUser.setPassword(PasswordUtil.DEFAULT_PASSWORD);
                    }
                    // 密码加密加盐
                    if (StrUtil.isBlank(sysUser.getSalt())) {
                        String salt = RandomUtil.randomString(8);
                        sysUser.setPassword(salt);
                    }
                    String passwordEncode = PasswordUtil.encrypt(sysUser.getUsername(), sysUser.getPassword(), sysUser.getSalt());
                    sysUser.setPassword(passwordEncode);
                    try {
                        service.save(sysUser);
                        successLines++;
                    } catch (Exception e) {
                        errorLines++;
                        String message = e.getMessage();
                        int lineNumber = i + 1;
                        // 通过索引名判断出错信息
                        if (message.contains(CommonConst.SQL_INDEX_UNIQ_SYS_USER_USERNAME)) {
                            errorMessages.add("第 " + lineNumber + " 行：用户名已经存在，忽略导入。");
                        } else if (message.contains(CommonConst.SQL_INDEX_UNIQ_SYS_USER_WORK_NO)) {
                            errorMessages.add("第 " + lineNumber + " 行：工号已经存在，忽略导入。");
                        } else if (message.contains(CommonConst.SQL_INDEX_UNIQ_SYS_USER_PHONE)) {
                            errorMessages.add("第 " + lineNumber + " 行：手机号已经存在，忽略导入。");
                        } else if (message.contains(CommonConst.SQL_INDEX_UNIQ_SYS_USER_EMAIL)) {
                            errorMessages.add("第 " + lineNumber + " 行：电子邮件已经存在，忽略导入。");
                        } else {
                            errorMessages.add("第 " + lineNumber + " 行：其他错误，忽略导入。【" + e.getMessage() + "】");
                        }
                    }
                    // 批量将部门和用户信息建立关联关系
                    String departIds = sysUser.getDepartIds();
                    if (StrUtil.isNotBlank(departIds)) {
                        String userId = sysUser.getId();
                        String[] departIdArray = departIds.split(",");
                        List<SysUserDepart> userDepartList = new ArrayList<>(departIdArray.length);
                        for (String departId : departIdArray) {
                            userDepartList.add(new SysUserDepart(userId, departId));
                        }
                        sysUserDepartService.saveBatch(userDepartList);
                    }
                }
            }
        }
        JSONObject returnData = JSONUtil.createObj();
        returnData.set("errorLines", errorLines);
        returnData.set("successLines", successLines);
        returnData.set("errorMessages", errorMessages);
        return Result.ok(returnData);
    }

    /**
     * 根据id批量查询
     *
     * @param userIds 用户id（多个逗号分隔）
     */
    @AutoLog("根据id批量查询")
    @GetMapping("/queryByIds")
    public Result<List<SysUser>> queryByIds(@RequestParam String userIds) {
        String[] userId = userIds.split(",");
        List<SysUser> userRole = service.listByIds(Arrays.asList(userId));
        return Result.ok(userRole);
    }

    /**
     * 用户自己修改密码
     */
    @AutoLog("用户自己修改密码")
    @PutMapping("/updatePassword")
    public Result<?> changPassword(@RequestBody JsonNode params) {
        String oldPassword = params.get("oldpassword").asText();
        String newPassword = params.get("password").asText();
        String confirmPassword = params.get("confirmpassword").asText();
        return service.changePassword(oldPassword, newPassword, confirmPassword);
    }

    /**
     * 根据角色和用户名查询用户
     *
     * @param pageNo   页码
     * @param pageSize 每页数量
     */
    @DictMethod
    @AutoLog("根据角色和用户名查询用户")
    @GetMapping("/userRoleList")
    public Result<IPage<SysUser>> userRoleList(@RequestParam(defaultValue = "1") Integer pageNo, @RequestParam(defaultValue = "10") Integer pageSize, HttpServletRequest req) {
        Page<SysUser> page = new Page<>(pageNo, pageSize);
        String roleId = req.getParameter("roleId");
        String username = req.getParameter("username");
        IPage<SysUser> pageList = service.getUserByRoleId(page, roleId, username);
        return Result.ok(pageList);
    }

    /**
     * 给指定角色添加用户
     *
     * @param addSysUserRoleRequest 参数
     */
    @AutoLog("给指定角色添加用户")
    @PostMapping("/addSysUserRole")
    public Result<?> addSysUserRole(@RequestBody AddSysUserRoleRequest addSysUserRoleRequest) {
        String sysRoleId = addSysUserRoleRequest.getRoleId();
        for (String sysUserId : addSysUserRoleRequest.getUserIdList()) {
            SysUserRole sysUserRole = new SysUserRole(sysUserId, sysRoleId);
            QueryWrapper<SysUserRole> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("role_id", sysRoleId).eq("user_id", sysUserId);
            SysUserRole one = sysUserRoleService.getOne(queryWrapper);
            if (one == null) {
                sysUserRoleService.save(sysUserRole);
            }
        }
        return Result.ok();
    }

    /**
     * 删除指定角色的用户关系
     *
     * @param roleId 角色id
     * @param userId 用户id
     */
    @AutoLog("删除指定角色的用户关系")
    @DeleteMapping("/deleteUserRole")
    public Result<?> deleteUserRole(@RequestParam String roleId, @RequestParam String userId) {
        QueryWrapper<SysUserRole> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("role_id", roleId).eq("user_id", userId);
        sysUserRoleService.remove(queryWrapper);
        return Result.ok();
    }

    /**
     * 批量删除指定角色的用户关系
     *
     * @param roleId  角色id
     * @param userIds 用户id（多个逗号分隔）
     */
    @AutoLog("批量删除指定角色的用户关系")
    @DeleteMapping("/deleteUserRoleBatch")
    public Result<?> deleteUserRoleBatch(@RequestParam String roleId, @RequestParam String userIds) {
        QueryWrapper<SysUserRole> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("role_id", roleId).in("user_id", Arrays.asList(userIds.split(",")));
        sysUserRoleService.remove(queryWrapper);
        return Result.ok();
    }

    /**
     * 部门用户列表
     *
     * @param pageNo   页码
     * @param pageSize 每页数量
     */
    @DictMethod
    @AutoLog("部门用户列表")
    @GetMapping("/departUserList")
    public Result<IPage<SysUser>> departUserList(@RequestParam(defaultValue = "1") Integer pageNo, @RequestParam(defaultValue = "10") Integer pageSize, HttpServletRequest req) {
        Page<SysUser> page = new Page<>(pageNo, pageSize);
        String depId = req.getParameter("depId");
        String username = req.getParameter("username");
        //根据部门ID查询,当前和下级所有的部门IDS
        List<String> subDepids = new ArrayList<>();
        //部门id为空时，查询我的部门下所有用户
        if (StrUtil.isEmpty(depId)) {
            LoginUser user = SystemContextUtil.currentLoginUser();
            int userIdentity = user.getUserIdentity() != null ? user.getUserIdentity() : CommonConst.USER_IDENTITY_1;
            if (userIdentity == CommonConst.USER_IDENTITY_2) {
                subDepids = sysDepartService.getMySubDepIdsByDepId(user.getDepartIds());
            }
        } else {
            subDepids = sysDepartService.getSubDepIdsByDepId(depId);
        }
        IPage<SysUser> pageList = null;
        if (subDepids != null && subDepids.size() > 0) {
            pageList = service.getUserByDepIds(page, subDepids, username);
            //批量查询用户的所属部门
            //step.1 先拿到全部的 useids
            //step.2 通过 useids，一次性查询用户的所属部门名字
            List<String> userIds = pageList.getRecords().stream().map(SysUser::getId).collect(Collectors.toList());
            if (userIds.size() > 0) {
                Map<String, String> useDepNames = service.getDepNamesByUserIds(userIds);
                pageList.getRecords().forEach(item -> {
                    //批量查询用户的所属部门
                    item.setOrgCode(useDepNames.get(item.getId()));
                });
            }
        }
        return Result.ok(pageList);
    }

    /**
     * 根据orgCode查询用户
     *
     * @param pageNo     页码
     * @param pageSize   每页数量
     * @param orgCode    部门编码
     * @param userParams 查询参数
     * @apiNote 包括子部门下的用户，若某个用户包含多个部门，则会显示多条记录，可自行处理成单条记录
     */
    @GetMapping("/queryByOrgCode")
    public Result<IPage<SysUserSysDepartModel>> queryByDepartId(@RequestParam(defaultValue = "1") Integer pageNo, @RequestParam(defaultValue = "10") Integer pageSize, @RequestParam String orgCode, SysUser userParams) {
        IPage<SysUserSysDepartModel> pageList = new Page<>(pageNo, pageSize);
        pageList.setRecords(service.queryUserByOrgCode(orgCode, userParams, pageList));
        return Result.ok(pageList);
    }

    /**
     * 根据orgCode查询用户
     *
     * @param pageNo     页码
     * @param pageSize   每页数量
     * @param orgCode    部门编码
     * @param userParams 查询参数
     * @apiNote 包括子部门下的用户，针对通讯录模块做的接口，将多个部门的用户合并成一条记录，并转成对前端友好的格式
     */
    @GetMapping("/queryByOrgCodeForAddressList")
    public Result<IPage<SysUserSysDepartModel>> queryByOrgCodeForAddressList(@RequestParam(defaultValue = "1") Integer pageNo, @RequestParam(defaultValue = "10") Integer pageSize, @RequestParam(required = false) String orgCode, SysUser userParams) {
        IPage<SysUserSysDepartModel> pageList = new Page<>(pageNo, pageSize);
        // 处理%_特殊字符串
        if (StrUtil.isNotBlank(userParams.getRealname())) {
            userParams.setRealname(QueryGenerator.specialStrConvert(userParams.getRealname()));
        }
        if (StrUtil.isNotBlank(userParams.getWorkNo())) {
            userParams.setWorkNo(QueryGenerator.specialStrConvert(userParams.getWorkNo()));
        }
        pageList.setRecords(service.queryUserByOrgCode(orgCode, userParams, pageList));
        return Result.ok(pageList);
    }

    /**
     * 给指定部门添加对应的用户
     *
     * @param editSysDepartWithUserRequest 查询参数
     */
    @AutoLog("给指定部门添加对应的用户")
    @PostMapping("/editSysDepartWithUser")
    public Result<?> editSysDepartWithUser(@RequestBody EditSysDepartWithUserRequest editSysDepartWithUserRequest) {
        String sysDepId = editSysDepartWithUserRequest.getDepId();
        for (String sysUserId : editSysDepartWithUserRequest.getUserIdList()) {
            SysUserDepart sysUserDepart = new SysUserDepart(null, sysUserId, sysDepId);
            QueryWrapper<SysUserDepart> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("dep_id", sysDepId).eq("user_id", sysUserId);
            SysUserDepart one = sysUserDepartService.getOne(queryWrapper);
            if (one == null) {
                sysUserDepartService.save(sysUserDepart);
            }
        }
        return Result.ok();
    }

    /**
     * 删除指定部门的用户关系
     *
     * @param depId  部门id
     * @param userId 用户id
     */
    @AutoLog("删除指定机构的用户关系")
    @DeleteMapping("/deleteUserInDepart")
    public Result<?> deleteUserInDepart(@RequestParam String depId, @RequestParam String userId) {
        QueryWrapper<SysUserDepart> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("dep_id", depId).eq("user_id", userId);
        boolean result = sysUserDepartService.remove(queryWrapper);
        if (!result) {
            return Result.error("当前选中部门与用户无关联关系！");
        }
        List<SysDepartRole> sysDepartRoleList = departRoleService.list(new QueryWrapper<SysDepartRole>().eq("depart_id", depId));
        List<String> roleIds = sysDepartRoleList.stream().map(SysDepartRole::getId).collect(Collectors.toList());
        if (roleIds.size() > 0) {
            QueryWrapper<SysDepartRoleUser> query = new QueryWrapper<>();
            query.eq("user_id", userId).in("drole_id", roleIds);
            departRoleUserService.remove(query);
        }
        return Result.ok();
    }

    /**
     * 批量删除指定部门的用户关系
     *
     * @param depId   部门id
     * @param userIds 用户id（多个逗号分隔）
     */
    @AutoLog("批量删除指定机构的用户关系")
    @DeleteMapping("/deleteUserInDepartBatch")
    public Result<?> deleteUserInDepartBatch(@RequestParam String depId, @RequestParam String userIds) {
        QueryWrapper<SysUserDepart> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("dep_id", depId).in("user_id", Arrays.asList(userIds.split(",")));
        boolean result = sysUserDepartService.remove(queryWrapper);
        if (result) {
            departRoleUserService.removeDeptRoleUser(Arrays.asList(userIds.split(",")), depId);
        }
        return Result.ok();
    }

    /**
     * 查询当前用户的所有部门和部门编码
     */
    @GetMapping("/getCurrentUserDeparts")
    public Result<?> getCurrentUserDeparts() {
        LoginUser sysUser = SystemContextUtil.currentLoginUser();
        List<SysDepart> list = sysDepartService.queryUserDeparts(sysUser.getId());
        Map<String, Object> returnData = new HashMap<>();
        returnData.put("list", list);
        returnData.put("orgCode", sysUser.getOrgCode());
        return Result.ok(returnData);
    }

    /**
     * 用户注册接口
     *
     * @param jsonObject 注册参数
     * @param user       用户信息
     */
    @AutoLog("用户注册接口")
    @PostMapping("/register")
    public Result<?> userRegister(@RequestBody JsonNode jsonObject, SysUser user) {
        String phone = jsonObject.get("phone").asText();
        String smscode = jsonObject.get("smscode").asText();
        Object code = redisUtil.get(phone);
        String username = jsonObject.get("username").asText();
        //未设置用户名，则用手机号作为用户名
        if (StrUtil.isEmpty(username)) {
            username = phone;
        }
        //未设置密码，则随机生成一个密码
        String password = jsonObject.get("password").asText();
        if (StrUtil.isEmpty(password)) {
            password = RandomUtil.randomString(8);
        }
        String email = jsonObject.get("email").asText();
        SysUser usernameCheck = service.getUserByName(username);
        if (usernameCheck != null) {
            return Result.error("用户名已注册！");
        }
        SysUser phoneCheck = service.getUserByPhone(phone);
        if (phoneCheck != null) {
            return Result.error("该手机号已注册！");
        }
        if (StrUtil.isNotEmpty(email)) {
            SysUser emailCheck = service.getUserByEmail(email);
            if (emailCheck != null) {
                return Result.error("邮箱已被注册！");
            }
        }
        if (null == code) {
            return Result.error("手机验证码失效，请重新获取！");
        }
        if (!smscode.equals(code)) {
            return Result.error("手机验证码错误！");
        }
        user.setCreateTime(new Date());// 设置创建时间
        String salt = RandomUtil.randomString(8);
        String passwordEncode = PasswordUtil.encrypt(username, password, salt);
        user.setSalt(salt);
        user.setUsername(username);
        user.setRealname(username);
        user.setPassword(passwordEncode);
        user.setEmail(email);
        user.setPhone(phone);
        user.setStatus(CommonConst.USER_UNFREEZE);
        user.setDelFlag(0);
        user.setFirstLogin(true);
        service.addUserWithRole(user, "1456085100369317890");//默认角色user
        return Result.ok();
    }

    /**
     * 根据用户名或手机号查询用户信息
     *
     * @param sysUser 查询参数
     */
    @GetMapping("/querySysUser")
    public Result<?> querySysUser(SysUser sysUser) {
        String phone = sysUser.getPhone();
        String username = sysUser.getUsername();
        Map<String, Object> returnData = new HashMap<>();
        if (StrUtil.isNotEmpty(phone)) {
            SysUser user = service.getUserByPhone(phone);
            if (user != null) {
                returnData.put("username", user.getUsername());
                returnData.put("phone", user.getPhone());
                return Result.ok(returnData);
            }
        }
        if (StrUtil.isNotEmpty(username)) {
            SysUser user = service.getUserByName(username);
            if (user != null) {
                returnData.put("username", user.getUsername());
                returnData.put("phone", user.getPhone());
                return Result.ok(returnData);
            }
        }
        return Result.error("未查询到结果！");
    }

    /**
     * 用户手机号验证
     *
     * @param jsonObject 参数
     */
    @PostMapping("/phoneVerification")
    public Result<?> phoneVerification(@RequestBody JsonNode jsonObject) {
        String phone = jsonObject.get("phone").asText();
        String smscode = jsonObject.get("smscode").asText();
        Object code = redisUtil.get(phone);
        if (!smscode.equals(code)) {
            return Result.error("手机验证码错误！");
        }
        //设置有效时间
        redisUtil.set(phone, smscode, 600);
        //新增查询用户名
        LambdaQueryWrapper<SysUser> query = new LambdaQueryWrapper<>();
        query.eq(SysUser::getPhone, phone);
        SysUser user = service.getOne(query);
        Map<String, String> returnData = new HashMap<>();
        returnData.put("smscode", smscode);
        returnData.put("username", user.getUsername());
        return Result.ok(returnData);
    }

    /**
     * 重置密码
     *
     * @param username 用户名
     * @param password 新密码
     * @param smscode  验证码
     * @param phone    手机号
     */
    @AutoLog("重置密码")
    @GetMapping("/passwordChange")
    public Result<?> passwordChange(@RequestParam String username, @RequestParam String password, @RequestParam String smscode, @RequestParam String phone) {
        SysUser sysUser;
        if (StrUtil.isEmpty(username) || StrUtil.isEmpty(password) || StrUtil.isEmpty(smscode) || StrUtil.isEmpty(phone)) {
            return Result.error("重置密码失败！");
        }
        Object object = redisUtil.get(phone);
        if (null == object) {
            return Result.error("短信验证码失效！");
        }
        if (!smscode.equals(object)) {
            return Result.error("短信验证码不匹配！");
        }
        sysUser = service.getOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUsername, username).eq(SysUser::getPhone, phone));
        if (sysUser == null) {
            return Result.error("未找到用户！");
        }
        String salt = RandomUtil.randomString(8);
        sysUser.setSalt(salt);
        String passwordEncode = PasswordUtil.encrypt(sysUser.getUsername(), password, salt);
        sysUser.setPassword(passwordEncode);
        service.updateById(sysUser);
        return Result.ok();
    }

    /**
     * 获取被逻辑删除的用户列表
     */
    @GetMapping("/recycleBin")
    public Result<List<SysUser>> getRecycleBin() {
        List<SysUser> logicDeletedUserList = service.queryLogicDeleted();
        if (logicDeletedUserList.size() > 0) {
            // 批量查询用户的所属部门
            // step.1 先拿到全部的 userIds
            List<String> userIds = logicDeletedUserList.stream().map(SysUser::getId).collect(Collectors.toList());
            // step.2 通过 userIds，一次性查询用户的所属部门名字
            Map<String, String> useDepNames = service.getDepNamesByUserIds(userIds);
            logicDeletedUserList.forEach(item -> item.setOrgCode(useDepNames.get(item.getId())));
        }
        return Result.ok(logicDeletedUserList);
    }

    /**
     * 还原被逻辑删除的用户
     *
     * @param jsonObject 参数
     */
    @AutoLog("还原被逻辑删除的用户")
    @PutMapping("/putRecycleBin")
    public Result<?> putRecycleBin(@RequestBody JsonNode jsonObject) {
        String userIds = jsonObject.get("userIds").asText();
        if (StrUtil.isNotBlank(userIds)) {
            SysUser updateUser = new SysUser();
            updateUser.setUpdateBy(StpUtil.getLoginIdAsString());
            updateUser.setUpdateTime(new Date());
            service.revertLogicDeleted(Arrays.asList(userIds.split(",")), updateUser);
        }
        return Result.ok();
    }

    /**
     * 彻底删除用户
     *
     * @param userIds 用户id（多个逗号分隔）
     */
    @SaCheckRole("admin")
    @AutoLog("彻底删除用户")
    @DeleteMapping("/deleteRecycleBin")
    public Result<?> deleteRecycleBin(@RequestParam String userIds) {
        if (StrUtil.isNotBlank(userIds)) {
            service.removeLogicDeleted(Arrays.asList(userIds.split(",")));
        }
        return Result.ok();
    }

    /**
     * 根据userId获取用户信息和部门员工信息
     *
     * @param userId 用户id
     */
    @Deprecated
    @GetMapping("/queryChildrenByUsername")
    public Result<?> queryChildrenByUsername(@RequestParam String userId) {
        //获取用户信息
        Map<String, Object> returnData = new HashMap<>();
        SysUser sysUser = service.getById(userId);
        String username = sysUser.getUsername();
        Integer identity = sysUser.getUserIdentity();
        returnData.put("sysUser", sysUser);
        if (identity != null && identity == 2) {
            //获取部门用户信息
            String departIds = sysUser.getDepartIds();
            if (StrUtil.isNotBlank(departIds)) {
                List<String> departIdList = Arrays.asList(departIds.split(","));
                List<SysUser> childrenUser = service.queryByDepIds(departIdList, username);
                returnData.put("children", childrenUser);
            }
        }
        return Result.ok(returnData);
    }

    /**
     * 更换手机号
     */
    @PutMapping("/updateMobile")
    @Operation(summary = "更换手机号")
    public Result<?> changMobile(@RequestBody UpdateMobileRequest request) {
        Object object = redisUtil.get(request.getPhone());
        if (null == object) {
            return Result.error("短信验证码失效！");
        }
        if (!object.equals(request.getCode())) {
            return Result.error("短信验证码错误！");
        }
        SysUser user = service.getUserByName(StpUtil.getLoginIdAsString());
        user.setPhone(request.getPhone());
        service.updateById(user);
        return Result.ok();
    }
}