package cn.stylefeng.guns.modular.business.controller;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.StrUtil;
import cn.stylefeng.guns.modular.business.dto.SysUserEditPostTipDTO;
import cn.stylefeng.guns.modular.business.dto.request.SysUserEditPwdRequest;
import cn.stylefeng.guns.modular.business.dto.request.SysUserResetPwdByIdRequest;
import cn.stylefeng.guns.modular.business.dto.request.SysUserResetPwdRequest;
import cn.stylefeng.guns.modular.business.entity.CounsellingInfo;
import cn.stylefeng.guns.modular.business.entity.CounsellingSetMeal;
import cn.stylefeng.guns.modular.business.entity.MentalAnalysisTimeConfig;
import cn.stylefeng.guns.modular.business.service.ICounsellingInfoService;
import cn.stylefeng.guns.modular.business.service.ICounsellingSetMealService;
import cn.stylefeng.guns.modular.business.service.IMentalAnalysisTimeConfigService;
import cn.stylefeng.guns.modular.business.service.ISysUserBusinessService;
import cn.stylefeng.guns.utils.GeneralUtil;
import cn.stylefeng.roses.kernel.auth.api.context.LoginContext;
import cn.stylefeng.roses.kernel.auth.api.password.PasswordStoredEncryptApi;
import cn.stylefeng.roses.kernel.auth.api.pojo.login.LoginUser;
import cn.stylefeng.roses.kernel.customer.modular.entity.Customer;
import cn.stylefeng.roses.kernel.customer.modular.request.CustomerRequest;
import cn.stylefeng.roses.kernel.customer.modular.service.CustomerService;
import cn.stylefeng.roses.kernel.db.api.pojo.page.PageResult;
import cn.stylefeng.roses.kernel.rule.annotation.BusinessLog;
import cn.stylefeng.roses.kernel.rule.constants.RuleConstants;
import cn.stylefeng.roses.kernel.rule.enums.*;
import cn.stylefeng.roses.kernel.rule.pojo.dict.SimpleDict;
import cn.stylefeng.roses.kernel.rule.pojo.request.BaseRequest;
import cn.stylefeng.roses.kernel.rule.pojo.response.ErrorResponseData;
import cn.stylefeng.roses.kernel.rule.pojo.response.ResponseData;
import cn.stylefeng.roses.kernel.rule.pojo.response.SuccessResponseData;
import cn.stylefeng.roses.kernel.scanner.api.annotation.ApiResource;
import cn.stylefeng.roses.kernel.scanner.api.annotation.GetResource;
import cn.stylefeng.roses.kernel.scanner.api.annotation.PostResource;
import cn.stylefeng.roses.kernel.sms.modular.service.SysSmsInfoService;
import cn.stylefeng.roses.kernel.system.api.exception.SystemModularException;
import cn.stylefeng.roses.kernel.system.api.exception.enums.user.SysUserExceptionEnum;
import cn.stylefeng.roses.kernel.system.api.expander.SystemConfigExpander;
import cn.stylefeng.roses.kernel.system.api.pojo.role.dto.SysRoleDTO;
import cn.stylefeng.roses.kernel.system.api.pojo.user.SysUserDTO;
import cn.stylefeng.roses.kernel.system.api.pojo.user.UserSelectTreeNode;
import cn.stylefeng.roses.kernel.system.api.pojo.user.request.*;
import cn.stylefeng.roses.kernel.system.modular.role.service.SysRoleService;
import cn.stylefeng.roses.kernel.system.modular.user.entity.SysUser;
import cn.stylefeng.roses.kernel.system.modular.user.entity.SysUserRole;
import cn.stylefeng.roses.kernel.system.modular.user.service.SysUserRoleService;
import cn.stylefeng.roses.kernel.system.modular.user.service.SysUserService;
import cn.stylefeng.roses.kernel.system.modular.user.wrapper.UserExpandWrapper;
import cn.stylefeng.roses.kernel.wrapper.api.annotation.Wrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.SneakyThrows;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 用户管理控制器
 *
 * @author luojie
 * @date 2020/11/6 09:47
 */
@Api(tags = "员工管理")
@RestController
@ApiResource(name = "员工管理", resBizType = ResBizTypeEnum.SYSTEM)
@RequestMapping("/sysUserBusiness")
public class SysUserBusinessController {

    @Resource
    private SysUserService sysUserService;

    @Resource
    private SysSmsInfoService sysSmsInfoService;

    @Resource
    private SysUserRoleService sysUserRoleService;

    @Resource
    private SysRoleService sysRoleService;

    @Resource
    private CustomerService customerService;

    @Resource
    private ISysUserBusinessService sysUserBusinessService;

    @Resource
    private PasswordStoredEncryptApi passwordStoredEncryptApi;

    @Resource
    private ICounsellingInfoService counsellingInfoService;

    @Resource
    private IMentalAnalysisTimeConfigService mentalAnalysisTimeConfigService;

    @Resource
    private ICounsellingSetMealService counsellingSetMealService;

    /**
     * 增加用户
     *
     * @author luojie
     * @date 2020/11/6 13:50
     */
    @ApiOperation("工作人员_增加")
    @PostResource(name = "工作人员_增加", path = "/sysUser/add")
    @BusinessLog
    public ResponseData<?> add(@RequestBody @Validated(BaseRequest.add.class) SysUserAddUpdateRequest req) {
        long userCount = sysUserService.count(
                Wrappers.<SysUser>lambdaQuery()
                        .eq(SysUser::getAccount, req.getAccount())
                        .eq(SysUser::getDelFlag, YesOrNotEnum.N.getCode())
        );
        Assert.isTrue(userCount == 0, "账号已存在");
        long customerCount = customerService.count(
                Wrappers.<Customer>lambdaQuery()
                        .eq(Customer::getAccount, req.getAccount())
                        .eq(Customer::getUserType, CustomerUserTypeEnum.WORKER.getCode())
        );
        Assert.isTrue(customerCount == 0, "C端账号已存在");

        SysUserRequest sysUserRequest = BeanUtil.toBean(req, SysUserRequest.class);

        String password;
        if (sysUserRequest.getAccount().length() >= 6) {
            // 密码设置为手机号后六位
            password = StrUtil.sub(sysUserRequest.getAccount(), -6, sysUserRequest.getAccount().length());
        } else {
            // 默认密码
            password = SystemConfigExpander.getDefaultPassWord();
        }
        sysUserRequest.setPassword(password);

        // 统一的工作人员昵称
        String nickName = GeneralUtil.getUnifyNickName(req.getNickName(), req.getRealName());
        sysUserRequest.setNickName(nickName);
        sysUserRequest.setRealName(nickName);

        SysUser sysUser = sysUserService.add(sysUserRequest);
        sysUserRequest.setUserId(sysUser.getUserId());

        // 注册C端用户信息
        regCustomer(sysUserRequest, req.getPostTypes(), req.getPostIds());

        // 工作人员_授权角色
        this.grantRole(sysUserRequest);

        return new SuccessResponseData<>();
    }

    public void regCustomer(SysUserRequest sysUserRequest, String postTypes, String postIds) {
        CustomerRequest regRequest = new CustomerRequest();
        regRequest.setAccount(sysUserRequest.getAccount());
        regRequest.setEmail(GeneralUtil.generateEmail(sysUserRequest.getPhone()));
        regRequest.setPassword(sysUserRequest.getPassword());

        regRequest.setUserType(CustomerUserTypeEnum.WORKER.getCode());
        regRequest.setSysUserId(sysUserRequest.getUserId());
        while (true) {
            // 六位数字员工号，唯一
            String workerNo = GeneralUtil.generateWorkNo();
            long count = customerService.count(Wrappers.<Customer>lambdaQuery().eq(Customer::getWorkerNo, workerNo));
            if (count == 0) {
                regRequest.setWorkerNo(workerNo);
                break;
            }
        }
        // 统一的工作人员昵称
        String nickName = GeneralUtil.getUnifyNickName(sysUserRequest.getNickName(), sysUserRequest.getRealName());
        regRequest.setNickName(nickName);
        regRequest.setRealName(nickName);
        // 员工信息
        regRequest.setAvatar(sysUserRequest.getAvatar());
        regRequest.setTelephone(sysUserRequest.getPhone());
        regRequest.setPostTypes(postTypes);
        regRequest.setPostIds(postIds);

        // C端用户注册
        customerService.reg(regRequest);
    }

    /**
     * 删除工作人员
     *
     * @author luojie
     * @date 2020/11/6 13:50
     */
    @ApiOperation("删除工作人员")
    @PostResource(name = "工作人员_删除", path = "/sysUser/delete")
    @BusinessLog
    public ResponseData<?> delete(@RequestBody @Validated(SysUserRequest.delete.class) SysUserDeleteRequest req) {

        List<CounsellingInfo> list = counsellingInfoService.list(Wrappers.lambdaQuery(CounsellingInfo.class).eq(CounsellingInfo::getListingStatus, 1).eq(CounsellingInfo::getIsDelete, 0));
        if (!list.isEmpty()){
            throw new SystemModularException(SysUserExceptionEnum.USER_CAN_NOT_DELETE_INFO);

        }


        SysUserRequest sysUserRequest = BeanUtil.toBean(req, SysUserRequest.class);
        boolean del = sysUserService.del(sysUserRequest);
        if (del) {
            // 更新C端用户为删除
            Customer user = customerService.getOne(
                    Wrappers.<Customer>lambdaQuery().eq(Customer::getSysUserId, sysUserRequest.getUserId())
            );
            Customer customer = new Customer();
            customer.setCustomerId(user.getCustomerId());
            customer.setAccount("DD_" + user.getAccount());
            customer.setTelephone("DD_" + user.getTelephone());
            customer.setStatusFlag(StatusEnum.DISABLE.getCode());
            customerService.updateCustomerRemoveCache(customer);
        }
        return new SuccessResponseData<>();
    }

    /**
     * 批量删除工作人员
     *
     * @author fengshuonan
     * @date 2021/4/7 16:12
     */
    @ApiOperation("批量删除工作人员")
    @PostResource(name = "工作人员_批量删除工作人员", path = "/sysUser/batchDelete")
    @BusinessLog
    public ResponseData<?> batchDelete(@RequestBody @Validated(SysUserRequest.batchDelete.class) SysUserDeleteRequest req) {
        SysUserRequest sysUserRequest = BeanUtil.toBean(req, SysUserRequest.class);
        sysUserService.batchDelete(sysUserRequest);

        for (Long userId : sysUserRequest.getUserIds()) {
            // 更新C端用户为删除
            Customer user = customerService.getOne(
                    Wrappers.<Customer>lambdaQuery().eq(Customer::getSysUserId, userId)
            );
            Customer customer = new Customer();
            customer.setCustomerId(user.getCustomerId());
            customer.setAccount("DD_" + user.getAccount());
            customer.setTelephone("DD_" + user.getTelephone());
            customer.setStatusFlag(StatusEnum.DISABLE.getCode());
            customerService.updateCustomerRemoveCache(customer);
        }
        return new SuccessResponseData<>();
    }

    @ApiOperation("工作人员_编辑岗位提示")
    @GetResource(name = "工作人员_编辑岗位提示", path = "/sysUser/editPostTip")
    public ResponseData<SysUserEditPostTipDTO> sysUserEditPostTip(Long customerId) {
        SysUserEditPostTipDTO dto = new SysUserEditPostTipDTO();

        // 咨询师-是否配置
        CounsellingInfo counsellingInfo = counsellingInfoService.getOne(Wrappers.<CounsellingInfo>lambdaQuery().eq(CounsellingInfo::getUserId, customerId).last("LIMIT 1"));
        long setPo22Count = counsellingSetMealService.count(
                Wrappers.<CounsellingSetMeal>lambdaQuery()
                        .eq(CounsellingSetMeal::getIsDelete, DeleteEnum.NOT_DELETE.getCode())
                        .eq(CounsellingSetMeal::getCounsellingInfoId, counsellingInfo != null ? counsellingInfo.getId() : 0)
        );
        dto.setSetPo22(setPo22Count > 0);

        // 性格分析时间配置
        long setPo31Count = mentalAnalysisTimeConfigService.count(
                Wrappers.<MentalAnalysisTimeConfig>lambdaQuery()
                        .eq(MentalAnalysisTimeConfig::getIsDelete, DeleteEnum.NOT_DELETE.getCode())
                        .eq(MentalAnalysisTimeConfig::getCounsellingInfoId, customerId)
        );
        dto.setSetPo31(setPo31Count > 0);

        return new SuccessResponseData<>(dto);
    }

    /**
     * 编辑工作人员
     *
     * @author luojie
     * @date 2020/11/6 13:50
     */
    @ApiOperation("工作人员_编辑")
    @PostResource(name = "工作人员_编辑", path = "/sysUser/edit")
    @BusinessLog
    public ResponseData<?> edit(@RequestBody @Validated(SysUserRequest.edit.class) SysUserAddUpdateRequest req) {
        SysUserRequest sysUserRequest = BeanUtil.toBean(req, SysUserRequest.class);
        // 统一的工作人员昵称
        String nickName = GeneralUtil.getUnifyNickName(req.getNickName(), req.getRealName());
        sysUserRequest.setNickName(nickName);
        sysUserRequest.setRealName(nickName);
        sysUserService.edit(sysUserRequest);

        // C端用户更新
        Customer user = customerService.getOne(Wrappers.<Customer>lambdaQuery().eq(Customer::getSysUserId, sysUserRequest.getUserId()).last("LIMIT 1"));
        Customer customer = new Customer();
        customer.setCustomerId(user.getCustomerId());

        // 员工信息
        customer.setNickName(nickName);
        customer.setRealName(nickName);
        customer.setAvatar(sysUserRequest.getAvatar());

        if (!user.getAccount().equals(sysUserRequest.getPhone())) {
            // 修改手机号，强一致更新账号
            customer.setTelephone(sysUserRequest.getPhone());
            sysUserService.changeSysUserPhone(req.getUserId(), sysUserRequest.getPhone());
            customerService.changeCustomerPhone(req.getUserId(), sysUserRequest.getPhone());
        }

        customer.setPostTypes(req.getPostTypes());
        // 岗位类型选”其他“，岗位ID置""
        if (StrUtil.isNotBlank(req.getPostTypes()) && PostTypeEnum.OTHER.getCode().toString().equals(req.getPostTypes())) {
            req.setPostIds("");
        }
        customer.setPostIds(req.getPostIds());

        // 性格分析师上下架状态：1上架，2下架，3无岗位
        Integer customerMentalAnalysisStatus = customerService.getCustomerMentalAnalysisStatus(req.getUserId(), user.getPostIds(), req.getPostIds());
        customer.setMentalAnalysisStatus(customerMentalAnalysisStatus);

        Integer workStatus = null;
        if (customerMentalAnalysisStatus != null && customerMentalAnalysisStatus.equals(CustomerMentalAnalysisStatusEnum.OFF_WORK.getCode())) {
            // 更改了性格分析师岗位，下班
            workStatus = 2;
        }

        // 更改了咨询师岗位
        if ((StrUtil.isBlank(req.getPostIds()) || (StrUtil.isNotBlank(req.getPostIds()) && req.getPostIds().indexOf(PostIdEnum.PO_22.getCode().toString()) == -1))
                && (StrUtil.isNotBlank(user.getPostIds()) && user.getPostIds().indexOf(PostIdEnum.PO_22.getCode().toString()) != -1)) {
            this.counsellingInfoService.update(new LambdaUpdateWrapper<CounsellingInfo>().eq(CounsellingInfo::getUserId, customer.getCustomerId()).set(CounsellingInfo::getListingStatus, 2));

            // 更改了咨询师岗位，下班
            workStatus = 2;
        }
        if (StrUtil.isNotBlank(req.getPostIds())) {
            String targetCode = PostIdEnum.PO_22.getCode().toString();
            boolean existP22 = Arrays.stream(req.getPostIds().split(",")).anyMatch(pid -> targetCode.equals(pid));
            if (existP22) {
                // 存在咨询师岗位，下班
                workStatus = 2;
            }
        }

        customer.setWorkStatus(workStatus);
        customerService.updateCustomerRemoveCache(customer);

        this.grantRole(sysUserRequest);
        return new SuccessResponseData<>();
    }

    /**
     * 修改状态
     *
     * @author luojie
     * @date 2020/11/6 13:50
     */
    @ApiOperation("工作人员_修改状态")
    @PostResource(name = "工作人员_修改状态", path = "/sysUser/changeStatus")
    @BusinessLog
    public ResponseData<?> changeStatus(@RequestBody @Validated(SysUserRequest.changeStatus.class) SysUserRequest sysUserRequest) {
        sysUserService.editStatus(sysUserRequest);

        Customer customer = new Customer();
        customer.setCustomerId(sysUserRequest.getUserId());
        customer.setStatusFlag(sysUserRequest.getStatusFlag());
        customerService.updateCustomerRemoveCache(customer);

        return new SuccessResponseData<>();
    }
    @ApiOperation("工作人员_修改上下班状态")
    @PostResource(name = "工作人员_修改上下班状态", path = "/sysUser/changeWorkStatus")
    @BusinessLog
    public ResponseData<?> changeWorkStatus(@RequestBody SysUserWorkStatusRequest sysUserRequest) {
        // C端用户更新
        Customer user = customerService.getOne(Wrappers.<Customer>lambdaQuery().eq(Customer::getSysUserId, sysUserRequest.getUserId()).last("LIMIT 1"));
        Customer customer = new Customer();
        customer.setCustomerId(user.getCustomerId());
        customer.setWorkStatus(sysUserRequest.getWorkStatus());
        customerService.updateCustomerRemoveCache(customer);

        return new SuccessResponseData<>();
    }

    /**
     * 重置密码
     */
    @ApiOperation("工作人员_重置密码")
    @PostResource(name = "工作人员_重置密码", path = RuleConstants.NOT_LOGIN + "/sysUser/resetPwd", requiredPermission = false)
    @BusinessLog
    public ResponseData<?> resetPwd(@RequestBody SysUserResetPwdRequest req) {
        return sysUserBusinessService.resetPwd(req);
    }
    @ApiOperation("工作人员_ID重置密码")
    @PostResource(name = "工作人员_ID重置密码", path = "/sysUser/resetPwdById", requiredPermission = false)
    @BusinessLog
    public ResponseData<?> resetPwdById(@RequestBody SysUserResetPwdByIdRequest req) {
        return sysUserBusinessService.resetPwdById(req);
    }

    /**
     * 修改密码
     */
    @SneakyThrows
    @ApiOperation("工作人员_修改密码")
    @PostResource(name = "工作人员_修改密码", path = "/sysUser/updatePwd", requiredPermission = false)
    @BusinessLog
    public ResponseData<?> updatePwd(@RequestBody SysUserEditPwdRequest req) {
        // 验证码通过
        sysSmsInfoService.validateSmsInfo(req);

        SysUser sysUser = sysUserService.getOne(
                Wrappers.<SysUser>lambdaQuery()
                        .and(w -> w.eq(SysUser::getAccount, req.getPhone())
                                .or().eq(SysUser::getPhone, req.getPhone())
                        )
                        .eq(SysUser::getStatusFlag, StatusEnum.ENABLE.getCode())
                        .eq(SysUser::getDelFlag, DeleteEnum.NOT_DELETE.getCode())
                        .last("LIMIT 1")
        );
        if (sysUser == null || (!req.getPhone().equals(sysUser.getAccount()) && !req.getPhone().equals(sysUser.getPhone()))) {
            return new ErrorResponseData<>("手机号验证错误");
        }

        SysUserRequest sysUserRequest = BeanUtil.toBean(req, SysUserRequest.class);
        sysUserService.editPassword(sysUserRequest);

        // C端用户更新
        Customer user = customerService.getOne(Wrappers.<Customer>lambdaQuery().eq(Customer::getSysUserId, sysUserRequest.getUserId()).last("LIMIT 1"));
        Customer customer = new Customer();
        customer.setCustomerId(user.getCustomerId());

        String password = req.getNewPassword();
        customer.setPassword(passwordStoredEncryptApi.encrypt(password));
        customerService.updateCustomerRemoveCache(customer);

        return new SuccessResponseData<>();
    }

    /**
     * 授权角色
     *
     * @author luojie
     * @date 2020/11/6 13:50
     */
    @ApiOperation("工作人员_授权角色")
    @PostResource(name = "工作人员_授权角色", path = "/sysUser/grantRole")
    @BusinessLog
    public ResponseData<?> grantRole(@RequestBody @Validated(SysUserRequest.grantRole.class) SysUserRequest sysUserRequest) {
        sysUserService.grantRole(sysUserRequest);
        return new SuccessResponseData<>();
    }

    /**
     * 授权数据
     *
     * @author luojie
     * @date 2020/11/6 13:50
     */
    //@ApiOperation("工作人员_授权数据")
    @PostResource(name = "工作人员_授权数据", path = "/sysUser/grantData")
    @BusinessLog
    public ResponseData<?> grantData(@RequestBody @Validated(SysUserRequest.grantData.class) SysUserRequest sysUserRequest) {
        sysUserService.grantData(sysUserRequest);
        return new SuccessResponseData<>();
    }

    /**
     * 查看工作人员
     *
     * @author luojie
     * @date 2020/11/6 13:50
     */
    @ApiOperation("工作人员_详情")
    @GetResource(name = "工作人员_详情", path = "/sysUser/detail")
    public ResponseData<SysUserDTO> detail(Long userId) {
        SysUserDTO sysUserDTO = sysUserService.getWorkerDetail(userId);

        List<Long> sysUserRoleList = this.sysUserRoleService.findRoleIdsByUserId(sysUserDTO.getUserId());
        if (CollectionUtil.isNotEmpty(sysUserRoleList)){
            sysUserDTO.setGrantRoleIdList(sysUserRoleList);
            List<SysRoleDTO> sysRoles = this.sysRoleService.getRolesByIds(sysUserRoleList);
            sysUserDTO.setRoleNames(sysRoles.stream().map(SysRoleDTO::getRoleName).collect(Collectors.joining()));
        }

        if (StrUtil.isNotBlank(sysUserDTO.getPostTypes())) {
            sysUserDTO.setPostTypeStr(Arrays.stream(sysUserDTO.getPostTypes().split(","))
                    .map(o -> PostTypeEnum.codeToName(Integer.valueOf(o)))
                    .collect(Collectors.joining(","))
            );
        }

        if (StrUtil.isNotBlank(sysUserDTO.getPostIds())) {
            sysUserDTO.setPostIdStr(Arrays.stream(sysUserDTO.getPostIds().split(","))
                    .map(o -> PostIdEnum.codeToName(Integer.valueOf(o)))
                    .collect(Collectors.joining(","))
            );
        }
        return new SuccessResponseData<>(sysUserDTO);
    }

    /**
     * 获取当前登录用户的信息
     *
     * @author fengshuonan
     * @date 2021/1/1 19:01
     */
    @ApiOperation("获取当前登录用户的信息")
    @GetResource(name = "获取当前登录用户的信息", path = "/sysUser/currentUserInfo", requiredPermission = false)
    public ResponseData<SysUserDTO> currentUserInfo() {
        LoginUser loginUser = LoginContext.me().getLoginUser();

        SysUserRequest sysUserRequest = new SysUserRequest();
        sysUserRequest.setUserId(loginUser.getUserId());
        return new SuccessResponseData<>(sysUserService.detail(sysUserRequest));
    }

    @ApiOperation("工作人员_分页查询")
    @GetResource(name = "工作人员_分页查询", path = "/sysUser/page")
    @Wrapper(UserExpandWrapper.class)
    public ResponseData<PageResult<SysUserDTO>> page(SysUserPageRequest req) {
        PageResult<SysUserDTO> userDTOPageResult = sysUserService.getWorkerPage(req);
        if (CollectionUtil.isNotEmpty(userDTOPageResult.getRows())){
            userDTOPageResult.getRows().forEach(sysUserDTO -> {
                List<Long> sysUserRoleList = this.sysUserRoleService.findRoleIdsByUserId(sysUserDTO.getUserId());
                if (CollectionUtil.isNotEmpty(sysUserRoleList)){
                    sysUserDTO.setGrantRoleIdList(sysUserRoleList);
                    try {
                        List<SysRoleDTO> sysRoles = this.sysRoleService.getRolesByIds(sysUserRoleList);
                        sysUserDTO.setRoleNames(sysRoles.stream().map(SysRoleDTO::getRoleName).collect(Collectors.joining()));
                    } catch (Exception e) {}
                }

                if (StrUtil.isNotBlank(sysUserDTO.getPostTypes())) {
                    sysUserDTO.setPostTypeStr(Arrays.stream(sysUserDTO.getPostTypes().split(","))
                            .map(o -> PostTypeEnum.codeToName(Integer.valueOf(o)))
                            .collect(Collectors.joining(","))
                    );
                }

                if (StrUtil.isNotBlank(sysUserDTO.getPostIds())) {
                    sysUserDTO.setPostIdStr(Arrays.stream(sysUserDTO.getPostIds().split(","))
                            .map(o -> PostIdEnum.codeToName(Integer.valueOf(o)))
                            .collect(Collectors.joining(","))
                    );
                }
            });
        }
        return new SuccessResponseData<>(userDTOPageResult);
    }

    @ApiOperation("工作人员_选择")
    @GetResource(name = "工作人员_选择", path = "/sysUser/getWorkerList")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "nickName", value = "昵称", dataTypeClass = String.class),
            @ApiImplicitParam(name = "realName", value = "姓名", dataTypeClass = String.class),
            @ApiImplicitParam(name = "postTypes", value = "岗位类型（逗号拼接）", dataTypeClass = String.class),
            @ApiImplicitParam(name = "postIds", value = "岗位（逗号拼接）", dataTypeClass = String.class),
    })
    public ResponseData<List<SimpleDict>> getWorkerList(String nickName, String realName, String postTypes, String postIds) {
        List<SimpleDict> list = customerService.list(
                        Wrappers.<Customer>lambdaQuery()
                                .select(Customer::getCustomerId, Customer::getNickName, Customer::getRealName, Customer::getPostTypes, Customer::getPostIds)
                                .eq(Customer::getUserType, CustomerUserTypeEnum.WORKER.getCode())
                                .eq(Customer::getStatusFlag, StatusEnum.ENABLE.getCode())
                                .eq(StrUtil.isNotEmpty(nickName), Customer::getNickName, nickName)
                                .eq(StrUtil.isNotEmpty(realName), Customer::getRealName, realName)
                ).stream()
                .filter(o -> {
                    boolean postTypeFlag = true;
                    if (StrUtil.isNotEmpty(postTypes)) {
                        postTypeFlag = false;
                        if (StrUtil.isNotEmpty(o.getPostTypes())) {
                            String[] array1 = o.getPostTypes().split(",");
                            String[] array2 = postTypes.split(",");
                            // 判断2个数组是否有交集
                            postTypeFlag = CollUtil.containsAny(CollUtil.newArrayList(array1), CollUtil.newArrayList(array2));
                        }
                    }

                    boolean postIdFlag = true;
                    if (StrUtil.isNotEmpty(postIds)) {
                        postIdFlag = false;
                        if (StrUtil.isNotEmpty(o.getPostIds())) {
                            String[] array1 = o.getPostIds().split(",");
                            String[] array2 = postIds.split(",");
                            // 判断2个数组是否有交集
                            postIdFlag = CollUtil.containsAny(CollUtil.newArrayList(array1), CollUtil.newArrayList(array2));
                        }
                    }
                    if (postTypeFlag && postIdFlag) {
                        return true;
                    } else {
                        return false;
                    }
                })
                .map(o -> {
                    SimpleDict vo = new SimpleDict();
                    vo.setId(o.getCustomerId());
                    vo.setName(o.getNickName());
                    return vo;
                }).collect(Collectors.toList());
        return new SuccessResponseData<>(list);
    }

    /**
     * 导出用户
     *
     * @author luojie
     * @date 2020/11/6 13:57
     */
    //@ApiOperation("工作人员_导出")
    @GetResource(name = "工作人员_导出", path = "/sysUser/export")
    @BusinessLog
    public void export(HttpServletResponse response) {
        sysUserService.export(response);
    }

    /**
     * 获取用户选择树数据（用在系统通知，选择发送人的时候）
     *
     * @author liuhanqing
     * @date 2021/1/15 8:28
     */
    //@ApiOperation("获取用户选择树数据（用在系统通知，选择发送人的时候）")
    @GetResource(name = "获取用户选择树数据（用在系统通知，选择发送人的时候）", path = "/sysUser/getUserSelectTree")
    public ResponseData<List<UserSelectTreeNode>> getUserTree() {
        return new SuccessResponseData<>(this.sysUserService.userSelectTree(new SysUserRequest()));
    }

    /**
     * 获取用户数据范围列表
     *
     * @author luojie
     * @date 2020/11/6 13:51
     */
    //@ApiOperation("工作人员_获取用户数据范围列表")
    @GetResource(name = "工作人员_获取用户数据范围列表", path = "/sysUser/getUserDataScope")
    public ResponseData<List<Long>> ownData(@Validated(SysUserRequest.detail.class) SysUserRequest sysUserRequest) {
        List<Long> userBindDataScope = sysUserService.getUserBindDataScope(sysUserRequest.getUserId());
        return new SuccessResponseData<>(userBindDataScope);
    }

    /**
     * 获取用户的角色列表
     *
     * @author luojie
     * @date 2020/11/6 13:50
     */
    @ApiOperation("工作人员_获取用户的角色列表")
    @GetResource(name = "工作人员_获取用户的角色列表", path = "/sysUser/getUserRoles")
    public ResponseData<List<SysUserRole>> ownRole(@Validated(SysUserRequest.detail.class) SysUserRequest sysUserRequest) {
        Long userId = sysUserRequest.getUserId();
        return new SuccessResponseData<>(sysUserRoleService.findListByUserId(userId));
    }

    /**
     * 用户下拉列表，可以根据姓名搜索
     * <p>
     * 本接口不查询超级管理员
     *
     * @param sysUserRequest 请求参数：name 姓名(可选)
     * @return 返回除超级管理员外的用户列表
     * @author luojie
     * @date 2020/11/6 09:49
     */
    //@ApiOperation("工作人员_选择器")
    @GetResource(name = "工作人员_选择器", path = "/sysUser/selector")
    public ResponseData<List<SimpleDict>> selector(SysUserRequest sysUserRequest) {
        return new SuccessResponseData<>(sysUserService.selector(sysUserRequest));
    }

    /**
     * 用户下拉列表，用户权限下用户
     * <p>
     * 本接口不查询超级管理员
     *
     * @param sysUserRequest 请求参数：name 姓名(可选)
     * @return 返回除超级管理员外的用户列表
     * @author yx
     * @date 2023/02/21 09:49
     */
    //@ApiOperation("工作人员_选择器(权限)")
    @GetResource(name = "工作人员_选择器(权限)", path = "/sysUser/selectorByAuthority", requiredPermission = false)
    public ResponseData<List<SimpleDict>> selectorByAuthority(SysUserRequest sysUserRequest) {
        return new SuccessResponseData<>(sysUserService.selectorByAuthority(sysUserRequest));
    }

    /**
     * 用户下拉列表，可以根据姓名搜索
     * <p>
     * 本接口可查询到超级管理员，包含所有用户
     *
     * @param sysUserRequest 请求参数：name 姓名(可选)
     * @return 返回除超级管理员外的用户列表
     * @author luojie
     * @date 2020/11/6 09:49
     */
    //@ApiOperation("工作人员_选择器")
    @GetResource(name = "工作人员_选择器", path = "/sysUser/selectorAll")
    public ResponseData<List<SimpleDict>> selectorAll(SysUserRequest sysUserRequest) {
        return new SuccessResponseData<>(sysUserService.selectorWithAdmin(sysUserRequest));
    }

    /**
     * 获取所有用户ID和名称列表
     *
     * @author majianguo
     * @date 2022/1/17 14:24
     **/
    //@ApiOperation("获取所有用户ID和名称列表")
    @GetResource(name = "获取所有用户ID和名称列表", path = "/sysUser/getAllUserIdList")
    public ResponseData<List<SysUserRequest>> getAllUserIdList() {
        return new SuccessResponseData<>(sysUserService.getAllUserIdList());
    }

    /**
     * 运维平台接口检测
     *
     * @author majianguo
     * @date 2022/1/27 14:29
     **/
    @GetResource(name = "运维平台接口检测", path = "/sysUser/devopsApiCheck", requiredLogin = false, requiredPermission = false)
    public ResponseData<Integer> devopsApiCheck(SysUserRequest sysUserRequest) {
        return new SuccessResponseData<>(sysUserService.devopsApiCheck(sysUserRequest));
    }

    /**
     * 根据用户主键获取用户对应的token
     *
     * @author majianguo
     * @date 2022/1/17 14:24
     **/
    @ApiOperation("根据用户主键获取用户对应的token")
    @GetResource(name = "根据用户主键获取用户对应的token", path = "/sysUser/getTokenByUserId")
    public ResponseData<String> getTokenByUserId(Long userId) {
        return new SuccessResponseData<>(sysUserService.getTokenByUserId(userId));
    }

    /**
     * 根据条件筛选用户
     *
     * @author fengshuonan
     * @date 2022/6/17 14:46
     */
    //@ApiOperation("根据条件筛选用户")
    @GetResource(name = "根据条件筛选用户", path = "/sysUser/getUserListByConditions")
    public ResponseData<List<SimpleDict>> getUserListByConditions(SysUserRequest sysUserRequest) {
        return new SuccessResponseData<>(sysUserService.getUserListByConditions(sysUserRequest));
    }

    /**
     * 获取用户列表，通过用户id集合
     *
     * @author fengshuonan
     * @date 2022/9/25 10:27
     */
    //@ApiOperation("获取用户列表，通过用户id集合")
    @PostResource(name = "获取用户列表，通过用户id集合", path = "/sysUser/getUsersByUserIds")
    public ResponseData<List<SysUserDTO>> getUsersByUserIds(@RequestBody @Validated(SysUserRequest.getUserList.class) SysUserRequest sysUserRequest) {
        return new SuccessResponseData<>(sysUserService.getUserInfoList(sysUserRequest.getUserIds()));
    }

}