szwlServer/src/main/java/com/szwl/controller/TAdminController.java

package com.szwl.controller;


import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.szwl.annotation.Audit;
import com.szwl.constant.AuditEnum;
import com.szwl.constant.ResponseCodesEnum;
import com.szwl.exception.BizException;
import com.szwl.feign.bean.PayFeign;
import com.szwl.manager.TokenManager;
import com.szwl.model.bo.R;
import com.szwl.model.bo.ResponseModel;
import com.szwl.model.bo.UserDetailBO;
import com.szwl.model.dto.RegisterParamDTO;
import com.szwl.model.entity.*;
import com.szwl.model.param.AddLoginUserParam;
import com.szwl.model.param.LoginParam;
import com.szwl.model.param.UpdateLoginUserParam;
import com.szwl.model.utils.AdminUtils;
import com.szwl.service.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.util.*;
import java.util.regex.Pattern;

/**
 * <p>
 * 前端控制器
 * </p>
 *
 * @author wuhs
 * @since 2024-07-01
 */
@Slf4j
@Api(value = "/tAdmin", tags = {"账户"})
@RestController
@RequestMapping("/tAdmin")
public class TAdminController {

    SysRoleService sysRoleService;

    SysUserRoleService sysUserRoleService;

    TokenManager tokenManager;

    TAdminService tAdminService;

    TAdminEquipmentService tAdminEquipmentService;

    TMessageCodeService tMessageCodeService;

    TAirwallexWalletService airwallexWalletService;

    PayFeign payFeign;

    @Autowired
    TWechatService wechatService;

    @Autowired
    TAreaService areaService;

    @Autowired
    CitiesService citiesService;

    @Autowired
    private CountriesService countriesService;

    public TAdminController(SysRoleService sysRoleService, SysUserRoleService sysUserRoleService, TokenManager tokenManager, TAdminService tAdminService, TAdminEquipmentService tAdminEquipmentService, TMessageCodeService tMessageCodeService, TAirwallexWalletService airwallexWalletService, PayFeign payFeign) {
        this.sysRoleService = sysRoleService;
        this.sysUserRoleService = sysUserRoleService;
        this.tokenManager = tokenManager;
        this.tAdminService = tAdminService;
        this.tAdminEquipmentService = tAdminEquipmentService;
        this.tMessageCodeService = tMessageCodeService;
        this.airwallexWalletService = airwallexWalletService;
        this.payFeign = payFeign;
    }


    private static final Logger logger = LoggerFactory.getLogger(TAdminController.class);

    @ApiOperation(value = "通过username查看用户的id和ifForeign")
    @GetMapping("/getIdIfForeign")
    public ResponseModel<TAdmin> getIdIfForeign(@RequestParam String username) {
        if (StringUtils.isEmpty(username)) {
            return R.fail("username为空");
        }
        LambdaQueryWrapper<TAdmin> lqw = Wrappers.lambdaQuery();
        lqw.eq(TAdmin::getUsername, username);
        List<TAdmin> list = tAdminService.list(lqw);
        if (list.isEmpty()) {
            return R.fail("username有误");
        } else if (list.size() > 1) {
            return R.fail("username不唯一");
        } else {
            TAdmin tAdmin = list.get(0);
            tAdmin.setPassword("");
            return R.ok(tAdmin);
        }
    }


    @ApiOperation(value = "获取账户类型")
    @GetMapping("/getAdminType")
    public ResponseModel<Integer> getAdminType(@RequestParam Long adminId) {
        if (adminId != null) {
            LambdaQueryWrapper<TAdmin> wrapper = Wrappers.lambdaQuery();
            wrapper.eq(TAdmin::getId, adminId);
            TAdmin tAdmin = tAdminService.getOne(wrapper);
            Integer type = tAdmin.getType();
            return R.ok(type);
        }
        return R.fail("adminId无效");
    }


    @ApiOperation(value = "判断是否海外用户")
    @GetMapping("/getIfForeign/{adminId}")
    public ResponseModel<?> getIfForeign(@PathVariable Long adminId) {
        if (adminId != null) {
            LambdaQueryWrapper<TAdmin> wrapper = Wrappers.lambdaQuery();
            wrapper.eq(TAdmin::getId, adminId);
            TAdmin one = tAdminService.getOne(wrapper);
            String ifForeign = one.getIfForeign();
            return R.ok(ifForeign);
        }
        return R.fail("未登录");
    }

    @ApiOperation(value = "添加子账号")
    @PostMapping("/addLoginUser")
    @Transactional
    @Audit(type = AuditEnum.INSERT, content = "#loginUser.name + '添加账号'")
    public ResponseModel<?> addLoginUser(@RequestBody @Valid AddLoginUserParam param) {
        if (param.getRoleList().size() < 1) {
            return R.fail(ResponseCodesEnum.A0001, "角色不能为空");
        }
        // 保存用户实体
        Date now = new Date();
        Long parentId = param.getAdminId();
        if (parentId == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        param.setAdminId(null);
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getUsername, param.getUsername());
        TAdmin admin = tAdminService.getOne(query);
        if (admin != null) {
            return R.fail(ResponseCodesEnum.A0201);
        }
        TAdmin entity = BeanUtil.copyProperties(param, TAdmin.class);
        entity.setParentId(parentId);
        if (param.getType() != null) {
            entity.setType(param.getType());
        } else {
            entity.setType(3);
        }
        entity.setIsAdmined(false);
        entity.setCreateDate(now);
        entity.setModifyDate(now);
        entity.setIsLocked(false);
        entity.setIsEnabled(true);
        entity.setLoginFailureCount(0);
        entity.setEmail(param.getEmail());
        entity.setPhone(param.getPhone());
        entity.setCompanyType(param.getCompanyType());
        entity.setPayPlatform(param.getCompanyType());
        //获取父账号信息
        TAdmin parentAdmin = tAdminService.getById(parentId);
        entity.setIfForeign(parentAdmin.getIfForeign());
        tAdminService.save(entity);
        String ifForeign = parentAdmin.getIfForeign();
        if ("1".equals(ifForeign)) {
            TAirwallexWallet wallet = new TAirwallexWallet();
            wallet.setAdminId(entity.getId());
            payFeign.saveAirwallexWallet(wallet);
        }

        // 管理的机器 需要再建立一个关系表 type区分全部还是部分
        String equipmentIds = param.getEquipmentIds();
        if (StringUtils.isNotEmpty(equipmentIds) && equipmentIds.equals("all")) {
            //管理全部机器
            TAdminEquipment tAdminEquipment = new TAdminEquipment();
            tAdminEquipment.setAdminId(entity.getId());
            tAdminEquipment.setType("0");
            tAdminEquipmentService.save(tAdminEquipment);
        } else {
            //部分机器或者没有机器
            TAdminEquipment tAdminEquipment = new TAdminEquipment();
            tAdminEquipment.setAdminId(entity.getId());
            tAdminEquipment.setType("1");
            tAdminEquipment.setEquipmentIds(param.getEquipmentIds());
            tAdminEquipmentService.save(tAdminEquipment);
        }

        List<String> roleList = param.getRoleList();
        if (roleList.size() > 0) {
            for (String role : roleList) {
                SysUserRole sysUserRole = new SysUserRole();
                sysUserRole.setRoleId(role);
                sysUserRole.setUserId(String.valueOf(entity.getId()));
                sysUserRoleService.save(sysUserRole);
            }
        }

        return R.ok(entity);
    }

    @ApiOperation(value = "修改子账号")
    @PostMapping("/updateLoginUser")
    @Transactional
    @Audit(type = AuditEnum.UPDATE, content = "#loginUser.name + '修改账号'")
    public ResponseModel<?> updateLoginUser(@RequestBody @Valid UpdateLoginUserParam param) {
        Long parentId = param.getAdminId();
        if (parentId == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        param.setAdminId(null);
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getParentId, parentId);
        query.eq(TAdmin::getId, param.getId());
        TAdmin admin = tAdminService.getOne(query);
        if (admin != null) {
            // 管理的机器 需要再建立一个关系表 type区分全部还是部分
            String equipmentIds = param.getEquipmentIds();
            LambdaQueryWrapper<TAdminEquipment> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(TAdminEquipment::getAdminId, admin.getId());
            TAdminEquipment adminEquipment = tAdminEquipmentService.getOne(queryWrapper);
            if (adminEquipment != null) {
                if (StringUtils.isNotEmpty(equipmentIds) && equipmentIds.equals("all")) {
                    //管理全部机器
                    //0:全部机器，1：部分机器
                    adminEquipment.setType("0");
                    adminEquipment.setEquipmentIds(null);
                } else {
                    //部分机器或者没有机器
                    //0:全部机器，1：部分机器
                    adminEquipment.setType("1");
                    adminEquipment.setEquipmentIds(param.getEquipmentIds());
                }
                tAdminEquipmentService.updateById(adminEquipment);
            } else {
                TAdminEquipment tAdminEquipment = new TAdminEquipment();
                tAdminEquipment.setAdminId(admin.getId());
                if (StringUtils.isNotEmpty(equipmentIds) && equipmentIds.equals("all")) {
                    //管理全部机器
                    //0:全部机器，1：部分机器
                    tAdminEquipment.setType("0");
                    tAdminEquipment.setEquipmentIds(null);
                } else {
                    //部分机器或者没有机器
                    //0:全部机器，1：部分机器
                    tAdminEquipment.setType("1");
                    tAdminEquipment.setEquipmentIds(param.getEquipmentIds());
                }
                tAdminEquipmentService.save(tAdminEquipment);
            }

            LambdaQueryWrapper<SysUserRole> query1 = Wrappers.lambdaQuery();
            query1.eq(SysUserRole::getUserId, admin.getId());
            SysUserRole sysUserRole = sysUserRoleService.getOne(query1);
            List<String> roleList = param.getRoleList();
            if (roleList.size() > 0) {
                for (String role : roleList) {
                    sysUserRole.setRoleId(role);
                    sysUserRoleService.updateById(sysUserRole);
                }
            }
            admin.setName(param.getName());
            admin.setIsEnabled(param.getIsEnabled());
            admin.setPhone(param.getPhone());
            admin.setEmail(param.getEmail());
            admin.setIsEnabled(param.getIsEnabled());
            if (StringUtils.isNotEmpty(param.getPassword())) {
                admin.setPassword(param.getPassword());
            }
            tAdminService.updateById(admin);
            return R.ok(admin);
        }
        return R.fail(ResponseCodesEnum.A0100);
    }

    @ApiOperation(value = "删除子账号")
    @PostMapping("/deleteLoginUser")
    @Transactional
    @Audit(type = AuditEnum.DELETE, content = "#loginUser.name + '删除账号'")
    public ResponseModel<?> deleteLoginUser(@RequestBody @Valid UpdateLoginUserParam param) {
        Long parentId = param.getAdminId();
        if (parentId == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        param.setAdminId(null);
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.like(TAdmin::getParentId, parentId);
        query.like(TAdmin::getId, param.getId());
        List<TAdmin> list = tAdminService.list(query);
        if (list.size() > 0) {
            TAdmin admin = list.get(0);
            // 管理的机器 需要再建立一个关系表 type区分全部还是部分
            String equipmentIds = param.getEquipmentIds();
            if (StringUtils.isNotEmpty(equipmentIds)) {
                LambdaQueryWrapper<TAdminEquipment> query1 = Wrappers.lambdaQuery();
                query1.eq(TAdminEquipment::getAdminId, admin.getId());
                List<TAdminEquipment> list1 = tAdminEquipmentService.list(query1);
                if (list1.size() > 0) {
                    TAdminEquipment tAdminEquipment1 = list1.get(0);
                    tAdminEquipmentService.removeById(tAdminEquipment1.getAdminId());
                }
            }
            // 用户角色关系
            LambdaQueryWrapper<SysUserRole> query2 = Wrappers.lambdaQuery();
            query2.eq(SysUserRole::getUserId, admin.getId());
            SysUserRole sysUserRole = sysUserRoleService.getOne(query2);
            sysUserRoleService.removeById(sysUserRole.getId());
            tAdminService.removeById(admin.getId());
//            log.debug("删除账号 id:{},TAdmin:{}", admin.getId(), admin);
            return R.ok(admin);
        }
        return R.fail(ResponseCodesEnum.A0100);
    }


    @ApiOperation(value = "获取所有子账号信息")
    @GetMapping("/getChildDrenAdminList")
    public ResponseModel<?> getChildDrenAdminList(String adminId, String userName, String name) {
        List<AddLoginUserParam> returnList = new ArrayList<>();
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getParentId, adminId);
        if (StringUtils.isNotEmpty(userName)) {
            query.eq(TAdmin::getUsername, userName);
        }
        if (StringUtils.isNotEmpty(name)) {
            query.like(TAdmin::getName, name);
        }
        if (StringUtils.isNotEmpty(adminId)) {
            if (adminId.equals("18")) {
                query.eq(TAdmin::getType, "1").or().eq(TAdmin::getType, "4");
            } else {
                query.eq(TAdmin::getType, "3");
            }
        } else {
            return R.fail(ResponseCodesEnum.A0100);
        }
        query.eq(TAdmin::getIsAdmined, false);
        List<TAdmin> list = tAdminService.list(query);
        if (!list.isEmpty()) {

            for (TAdmin admin : list) {
                AddLoginUserParam addLoginUserParam = new AddLoginUserParam();
                addLoginUserParam.setUsername(admin.getUsername());
                addLoginUserParam.setName(admin.getName());
                addLoginUserParam.setEmail(admin.getEmail());
                addLoginUserParam.setPhone(admin.getPhone());
                addLoginUserParam.setIsEnabled(admin.getIsEnabled());
                addLoginUserParam.setId(admin.getId());
                LambdaQueryWrapper<TAdminEquipment> query2 = Wrappers.lambdaQuery();
                query2.eq(TAdminEquipment::getAdminId, admin.getId());
                List<TAdminEquipment> list1 = tAdminEquipmentService.list(query2);
                if (!list1.isEmpty()) {
                    TAdminEquipment tAdminEquipment1 = list1.get(0);
                    if (tAdminEquipment1.getType().equals("0")) {
                        //管理全部机器
                        //0:全部机器，1：部分机器
                        tAdminEquipment1.setType("0");
                        tAdminEquipment1.setEquipmentIds(null);
                        addLoginUserParam.setEquipmentIds("all");
                    } else {
                        //部分机器
                        //0:全部机器，1：部分机器
                        tAdminEquipment1.setType("1");
                        addLoginUserParam.setEquipmentIds(tAdminEquipment1.getEquipmentIds());
                    }
                }
                LambdaQueryWrapper<SysUserRole> query1 = Wrappers.lambdaQuery();
                query1.eq(SysUserRole::getUserId, admin.getId());
                List<SysUserRole> roleList = sysUserRoleService.list(query1);
                List<String> ids = new ArrayList<>();
                StringBuilder roleName = new StringBuilder();
                if (!roleList.isEmpty()) {
                    for (int i = 0; i < roleList.size(); i++) {
                        SysUserRole sysUserRole = roleList.get(0);
                        ids.add(sysUserRole.getRoleId());
                        SysRole sysRole = sysRoleService.getById(sysUserRole.getRoleId());
                        if (i < roleList.size() - 1) {
                            roleName.append(sysRole.getRoleName()).append(",");
                        } else {
                            roleName.append(sysRole.getRoleName());
                        }
                    }

                }
                addLoginUserParam.setRoleName(roleName.toString());
                addLoginUserParam.setRoleList(ids);
                addLoginUserParam.setType(admin.getType());
                returnList.add(addLoginUserParam);
            }

        }
        return R.ok(returnList);
    }

    @ApiOperation(value = "注册账号/用户注册")
    @PostMapping("/save")
    @Transactional
    @Audit(type = AuditEnum.INSERT, content = "#registerParam.username + '注册账号'")
    public ResponseModel<?> save(@RequestBody RegisterParamDTO registerParam) {
        if (StringUtils.isEmpty(registerParam.getUsername()) || StringUtils.isEmpty(registerParam.getName()) || StringUtils.isEmpty(registerParam.getPassword())) {
            return R.fail(ResponseCodesEnum.A0001);
        }

        String phoneOrEmail = registerParam.getPhoneOrEmail();
        // 定义国内手机号和邮箱的正则表达式
        String phoneReg = "^1[3-9]\\d{9}$";
        String emailReg = "^[a-zA-Z0-9_-]+([a-zA-Z0-9_.-]*[a-zA-Z0-9])*@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$";

        if (registerParam.getIfForeign().isEmpty()) {
            return R.fail(ResponseCodesEnum.A0001, "是否国内外为空！");
        }
        String relationAdminId = "";
        if (StringUtils.isNotEmpty(registerParam.getInviteCode())) {
            // 验证邀请码
            relationAdminId = String.valueOf(AdminUtils.decrypt(false, registerParam.getInviteCode()));
            TAdmin admin = tAdminService.getById(relationAdminId);
            if (admin == null) {
                return R.fail(ResponseCodesEnum.R0001);
            }
            if (admin.getType() != 4) {
                return R.fail(ResponseCodesEnum.R0001);
            }
        }
        // 国内用户注册
        if (registerParam.getIfForeign().equals("0")) {
            // 判断 phoneOrEmail 是手机号还是邮箱
            if (Pattern.matches(phoneReg, phoneOrEmail)) {
                if (StringUtils.isEmpty(registerParam.getPhoneOrEmail())) {
                    return R.fail(ResponseCodesEnum.R0002);
                }
            } else if (Pattern.matches(emailReg, phoneOrEmail)) {
                if (StringUtils.isEmpty(registerParam.getPhoneOrEmail())) {
                    return R.fail(ResponseCodesEnum.R0003);
                }
            } else {
                return R.fail(ResponseCodesEnum.R0004);
            }
        } else {
            //海外用户注册
            if (StringUtils.isEmpty(registerParam.getPhoneOrEmail())) {
                return R.fail(ResponseCodesEnum.R0003);
            }
        }

        // 增加地区
        Long areaId = null;
        if (StringUtils.isNotEmpty(registerParam.getCities())) {
            if (registerParam.getIfForeign().equals("0")) {
                // 国内
                LambdaQueryWrapper<TArea> query = Wrappers.lambdaQuery();
                query.eq(TArea::getFullName, registerParam.getCities());
                TArea area = areaService.getOne(query);
                if (area != null) {
                    areaId = area.getId();
                }
            } else {
                // 国外
                LambdaQueryWrapper<Countries> queryCountry = Wrappers.lambdaQuery();
                queryCountry.eq(Countries::getCode, registerParam.getCountry());
                Countries countries = countriesService.getOne(queryCountry);
                if (countries != null) {
                    LambdaQueryWrapper<Cities> query = Wrappers.lambdaQuery();
                    query.eq(Cities::getCountryId, countries.getId());
                    query.eq(Cities::getCode, registerParam.getCities());
                    Cities cities = citiesService.getOne(query);
                    if (cities != null) {
                        areaId = cities.getId();
                    }
                }
            }
        }

        if (StringUtils.isEmpty(registerParam.getCode())) {
            return R.fail(ResponseCodesEnum.R0005);
        }

        //校验是否有重复的
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getUsername, registerParam.getUsername());
        List<TAdmin> list = tAdminService.list(query);
        if (!list.isEmpty()) {
            return R.fail(ResponseCodesEnum.A0201);
        }
        LambdaQueryWrapper<TAdmin> query1 = Wrappers.lambdaQuery();
        if (registerParam.getIfForeign().equals("0")) {
            // 国内分两种
            if (Pattern.matches(phoneReg, phoneOrEmail)) {
                query1.eq(TAdmin::getPhone, registerParam.getPhoneOrEmail());
            } else {
                query1.eq(TAdmin::getEmail, registerParam.getPhoneOrEmail());
            }
        } else {
            query1.eq(TAdmin::getEmail, registerParam.getPhoneOrEmail());
        }
        List<TAdmin> list1 = tAdminService.list(query1);
        if (!list1.isEmpty()) {
            return R.fail(ResponseCodesEnum.A0203);
        }

        //校验验证码是否正确
        LambdaQueryWrapper<TMessageCode> query2 = Wrappers.lambdaQuery();
        if (registerParam.getIfForeign().equals("0")) {
            //  国内分两种
            if (Pattern.matches(phoneReg, phoneOrEmail)) {
                query2.eq(TMessageCode::getPhone, registerParam.getPhoneOrEmail());
            } else {
                query2.eq(TMessageCode::getPhone, registerParam.getPhoneOrEmail());
            }
        } else {
            query2.eq(TMessageCode::getPhone, registerParam.getPhoneOrEmail());
        }

        // 0，代表注册验证码
        query2.eq(TMessageCode::getType, "0");
        query2.eq(TMessageCode::getStatus, "0");
        List<TMessageCode> messageCodeList = tMessageCodeService.list(query2);
        TAdmin admin = new TAdmin();
        if (!messageCodeList.isEmpty()) {
            TMessageCode tMessageCode = messageCodeList.get(messageCodeList.size() - 1);
            if (!tMessageCode.getCode().equals(registerParam.getCode())) {
                return R.fail(ResponseCodesEnum.R0006);
            }
            tMessageCode.setStatus("1");
//            admin.setId(IDGenerator.commonID()); // admin 表改回原来的自增ID
            admin.setCreateDate(new Date());
            admin.setModifyDate(new Date());
            admin.setIsAdmined(true);
            admin.setIsEnabled(true);
            admin.setLoginFailureCount(0);
            admin.setIsLocked(false);
            //默认是商家
            admin.setType(2);
            admin.setPassword(registerParam.getPassword());
            admin.setUsername(registerParam.getUsername());
            admin.setName(registerParam.getName());
            admin.setIfForeign(registerParam.getIfForeign());
            // 地区ID
            admin.setAreaId(areaId);
            if (registerParam.getIfForeign().equals("1")) {
                admin.setPromoCodeOpen("0");
            }
            // 邀请码，即上级账号
            if (StringUtils.isNotEmpty(relationAdminId)) {
                admin.setRelationAdminId(relationAdminId);
            }
            admin.setCompanyType(registerParam.getCompanyType());
            if (Pattern.matches(phoneReg, phoneOrEmail)) {
                admin.setPhone(registerParam.getPhoneOrEmail());
            } else if (Pattern.matches(emailReg, phoneOrEmail)) {
                admin.setEmail(registerParam.getPhoneOrEmail());
            } else {
                return R.fail(ResponseCodesEnum.R0004);
            }
            if (registerParam.getCompanyType().equals("1")) { // 如果是七云平台
                admin.setTradeMerchantNo("777138500523174"); //七云商户报备号
                admin.setPayPlatform("1");
            } else {
                admin.setPayPlatform("0");
            }
            boolean b = tAdminService.save(admin);

            tMessageCodeService.saveOrUpdate(tMessageCode);
            if (b) {
                // 绑定商家角色
                LambdaQueryWrapper<SysRole> query4 = Wrappers.lambdaQuery();
                query4.eq(SysRole::getAdminId, 18L);
                query4.eq(SysRole::getRoleName, "商家");
                List<SysRole> list2 = sysRoleService.list(query4);
                if (list2.size() > 0) {
                    SysRole sysRole = list2.get(0);
                    SysRole newSysRole = new SysRole();
                    newSysRole.setAdminId(admin.getId());
                    newSysRole.setMenuCodesJson(sysRole.getMenuCodesJson());
                    newSysRole.setControlCodesJson(sysRole.getControlCodesJson());
                    newSysRole.setRoleName("商家");
                    sysRoleService.save(newSysRole);
                    SysUserRole sysUserRole = new SysUserRole();
                    sysUserRole.setRoleId(newSysRole.getRoleId());
                    sysUserRole.setUserId(String.valueOf(admin.getId()));
                    sysUserRoleService.save(sysUserRole);
                }
                tMessageCode.setModifyDate(new Date());
                if (admin.getId() != null) {
                    String managerId = AdminUtils.encrypt(false, admin.getId());
                    admin.setManagerId(managerId);
                    tAdminService.getById(admin);

                }
            }
            return R.ok(b);

        } else {
            return R.fail(ResponseCodesEnum.R0007);
        }

    }

    @ApiOperation(value = "登录")
    @PostMapping("/login")
    @Audit(type = AuditEnum.LOGIN, content = "#username + '请求登录'")
    public ResponseModel<UserDetailBO> login(String username, String password, String hostName, HttpServletRequest request) {
        if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password)) {
            return R.fail(ResponseCodesEnum.A0001, "参数有空");
        }

        //验证用户名登录
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getPassword, password);
        query.and(wrapper -> wrapper.eq(TAdmin::getUsername, username).or().eq(TAdmin::getPhone, username));
        TAdmin tAdmin = Optional.ofNullable(tAdminService.getOnly(query))
                .orElseThrow(() -> new BizException(ResponseCodesEnum.L0002));

        // 判断是为申泽用户还是七云用户
        String companyType = tAdmin.getCompanyType();
        String sZ = "Sunzee";
        String sC = "Sevencloud";
        // 如果不为管理员
        if (tAdmin.getType() >= 1) {
            if (sZ.equals(hostName)) {
                // 如果companyType不为空，且不等于“0”
                if (StringUtils.isNotEmpty(companyType) && !companyType.equals("0")) {
                    return R.fail(ResponseCodesEnum.L0002);
                }
            }
            if (sC.equals(hostName)) {
                // 如果companyType为空，或者不等于“1”
                if (StringUtils.isEmpty(companyType) || !(companyType.equals("1"))) {
                    return R.fail(ResponseCodesEnum.L0002);
                }
            }
        }
        // 添加系统id
        if (StringUtils.isEmpty(tAdmin.getManagerId())) {
            String managerId = AdminUtils.encrypt(false, tAdmin.getId());
            tAdmin.setManagerId(managerId);
        }
        // 设置登录时间
        tAdmin.setLoginDate(new Date());
        // 登录IP
        String ipAddress;
        // 获取通过代理服务器传递的真实IP地址
        String xForwardedForHeader = request.getHeader("X-Forwarded-For");
        if (xForwardedForHeader == null) {
            ipAddress = request.getRemoteAddr();
        } else {
            // 多次反向代理后会有多个IP值，第一个IP才是真实IP
            String[] ips = xForwardedForHeader.split(",");
            ipAddress = ips[0].trim();
        }
        tAdmin.setLoginIp(ipAddress);
        tAdminService.updateById(tAdmin);
        UserDetailBO userDetailBO = tAdminService.getUserDetailBO(tAdmin);
        return R.ok(userDetailBO);
    }

    @ApiOperation(value = "登录")
    @PostMapping("/loginSys")
    @Audit(type = AuditEnum.LOGIN, content = "#loginParam.username + '请求登录'")
    public ResponseModel<UserDetailBO> loginSys(@RequestBody LoginParam loginParam, HttpServletRequest request) {
        String username = loginParam.getUsername();
        String password = loginParam.getPassword();
        String hostName = loginParam.getHostName();

        if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password)) {
            return R.fail(ResponseCodesEnum.A0001, "参数有空");
        }

        //验证用户名/手机/邮箱
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getPassword, password);
        query.and(wrapper -> wrapper.eq(TAdmin::getUsername, username).or().eq(TAdmin::getPhone, username).or().eq(TAdmin::getEmail, username));
        TAdmin tAdmin = Optional.ofNullable(tAdminService.getOnly(query))
                .orElseThrow(() -> new BizException(ResponseCodesEnum.L0002));

        // 判断是为申泽用户还是七云用户
        String companyType = tAdmin.getCompanyType();
        String sZ = "Sunzee";
        String sC = "Sevencloud";
        // 如果不为管理员
        if (tAdmin.getType() >= 1) {
            if (sZ.equals(hostName)) {
                // 如果companyType不为空，且不等于“0”
                if (StringUtils.isNotEmpty(companyType) && !companyType.equals("0")) {
                    return R.fail(ResponseCodesEnum.L0002);
                }
            }
            if (sC.equals(hostName)) {
                // 如果companyType为空，或者不等于“1”
                if (StringUtils.isEmpty(companyType) || !(companyType.equals("1"))) {
                    return R.fail(ResponseCodesEnum.L0002);
                }
            }
        }
        // 添加系统id
        if (StringUtils.isEmpty(tAdmin.getManagerId())) {
            String managerId = AdminUtils.encrypt(false, tAdmin.getId());
            tAdmin.setManagerId(managerId);
        }
        // 设置登录时间
        tAdmin.setLoginDate(new Date());
        // 登录IP
        String ipAddress;
        // 获取通过代理服务器传递的真实IP地址
        String xForwardedForHeader = request.getHeader("X-Forwarded-For");
        if (xForwardedForHeader == null) {
            ipAddress = request.getRemoteAddr();
        } else {
            // 多次反向代理后会有多个IP值，第一个IP才是真实IP
            String[] ips = xForwardedForHeader.split(",");
            ipAddress = ips[0].trim();
        }
        tAdmin.setLoginIp(ipAddress);
        tAdminService.updateById(tAdmin);
        UserDetailBO userDetailBO = tAdminService.getUserDetailBO(tAdmin);
        return R.ok(userDetailBO);
    }

    @ApiOperation("PC端登录")
    @PostMapping("/pcLogin")
    public ResponseModel<?> pcLogin(@RequestBody LoginParam loginParam, HttpServletRequest request) {
        String username = loginParam.getUsername();
        String password = loginParam.getPassword();
        String hostName = loginParam.getHostName();

        if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password)) {
            return R.fail(ResponseCodesEnum.A0001, "参数有空");
        }

        //验证用户名/手机/邮箱
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getPassword, password);
        query.and(wrapper -> wrapper.eq(TAdmin::getUsername, username).or().eq(TAdmin::getPhone, username).or().eq(TAdmin::getEmail, username));
        TAdmin tAdmin = Optional.ofNullable(tAdminService.getOnly(query))
                .orElseThrow(() -> new BizException(ResponseCodesEnum.L0002));

        // 判断是为申泽用户还是七云用户
        String companyType = tAdmin.getCompanyType();
        String sZ = "Sunzee";
        String sC = "Sevencloud";
        // 如果不为管理员
        if (tAdmin.getType() >= 1) {
            if (sZ.equals(hostName)) {
                // 如果companyType不为空，且不等于“0”
                if (StringUtils.isNotEmpty(companyType) && !companyType.equals("0")) {
                    return R.fail(ResponseCodesEnum.L0002);
                }
            }
            if (sC.equals(hostName)) {
                // 如果companyType为空，或者不等于“1”
                if (StringUtils.isEmpty(companyType) || !(companyType.equals("1"))) {
                    return R.fail(ResponseCodesEnum.L0002);
                }
            }
        }
        // 添加系统id
        if (StringUtils.isEmpty(tAdmin.getManagerId())) {
            String managerId = AdminUtils.encrypt(false, tAdmin.getId());
            tAdmin.setManagerId(managerId);
        }
        // 设置登录时间
        tAdmin.setLoginDate(new Date());
        // 登录IP
        String ipAddress;
        // 获取通过代理服务器传递的真实IP地址
        String xForwardedForHeader = request.getHeader("X-Forwarded-For");
        if (xForwardedForHeader == null) {
            ipAddress = request.getRemoteAddr();
        } else {
            // 多次反向代理后会有多个IP值，第一个IP才是真实IP
            String[] ips = xForwardedForHeader.split(",");
            ipAddress = ips[0].trim();
        }
        tAdmin.setLoginIp(ipAddress);
        tAdminService.updateById(tAdmin);
        // 添加token和刷新token

        return R.ok();
    }

    @ApiOperation(value = "切换自动登录")
    @GetMapping("/autoLogin")
    @Audit(type = AuditEnum.LOGIN, content = "切换登录'")
    public ResponseModel<UserDetailBO> autoLogin(@RequestParam String id) {
        if (StringUtils.isEmpty(id)) {
            return R.fail(ResponseCodesEnum.A0001, "参数有空");
        }

        //验证用户名登录
        Long adminId = Long.valueOf(id);
        TAdmin admin = tAdminService.getById(adminId);
        TAdmin tAdmin = Optional.ofNullable(admin)
                .orElseThrow(() -> new BizException(ResponseCodesEnum.L0002));

        // 添加系统id
        if (StringUtils.isEmpty(tAdmin.getManagerId())) {
            String managerId = AdminUtils.encrypt(false, tAdmin.getId());
            tAdmin.setManagerId(managerId);
            tAdminService.getById(tAdmin);
        }
        UserDetailBO userDetailBO = tAdminService.getUserDetailBO(tAdmin);
        return R.ok(userDetailBO);
    }

    @ApiOperation(value = "修改密码")
    @PostMapping("/updatePassword")
    public ResponseModel<?> updatePassword(String username, String password) {
        if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password)) {
            return R.fail(ResponseCodesEnum.A0001, "参数有空");
        }
        //查找用户名
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getUsername, username);
        List<TAdmin> list = tAdminService.list(query);
        if (!list.isEmpty()) {
            TAdmin admin = list.get(0);
            admin.setPassword(password);
            boolean b = tAdminService.saveOrUpdate(admin);
            return R.ok(b);
        }

        return R.fail(ResponseCodesEnum.A0001, "修改失败");
    }

    @ApiOperation(value = "获取账号信息")
    @GetMapping("/getAdmin")
    public ResponseModel<TAdmin> getAdmin(@RequestParam String id) {
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getId, id);
        TAdmin tAdmin = Optional.ofNullable(tAdminService.getOnly(query))
                .orElseThrow(() -> new BizException(ResponseCodesEnum.L0002));
        if (StringUtils.isEmpty(tAdmin.getManagerId())) {
            String managerId = AdminUtils.encrypt(false, tAdmin.getId());
            tAdmin.setManagerId(managerId);
            tAdminService.getById(tAdmin);
        }
        UserDetailBO userDetailBO = BeanUtil.copyProperties(tAdmin, UserDetailBO.class,
                "password", "loginIp");
        return R.ok(userDetailBO);
    }

    @ApiOperation(value = "获取账号列表 分页")
    @GetMapping("/pageAdmin")
    public ResponseModel<IPage<?>> pageAdmin(String id, String name, String userName,
                                             String ifForeign, String type, long current, long size) {
        if (StringUtils.isEmpty(id)) {
            return R.fail(ResponseCodesEnum.A0001, "null参数");
        }
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        if (StringUtils.isNotEmpty(name)) {
            query.like(TAdmin::getName, name);
        }
        if (StringUtils.isNotEmpty(userName)) {
            query.like(TAdmin::getUsername, userName);
        }
        if (StringUtils.isNotEmpty(ifForeign)) {
            query.eq(TAdmin::getIfForeign, ifForeign);
        }
        if (StringUtils.isNotEmpty(id)) {
            TAdmin admin = tAdminService.getById(id);
            if (admin == null || admin.getId() == null) {
                return R.fail(ResponseCodesEnum.A0001, "没有找到商家");
            }
            // 申泽平台管理员
            if (admin.getId() == 2738) {
                query.isNull(TAdmin::getCompanyType).or()
                        .eq(TAdmin::getCompanyType, "0");
            }
            // 七云平台管理员
            if (admin.getId() == 2739) {
                query.eq(TAdmin::getCompanyType, "1");
            }
            if (admin.getType() > 1) {
                query.eq(TAdmin::getRelationAdminId, id);
            }
        }
        if (StringUtils.isNotEmpty(type)) {
            query.eq(TAdmin::getType, type);
        } else {
            query.eq(TAdmin::getType, "2");
        }
        query.orderByDesc(TAdmin::getCreateDate);
        Page<TAdmin> page = new Page<>(current, size, true);
        IPage<TAdmin> iPage = tAdminService.page(page, query);
        iPage.getRecords().forEach(e -> e.setPassword(""));  // 密码置空
        return R.ok(iPage);
    }

    @ApiOperation(value = "获取账号列表 分页")
    @GetMapping("/pageAdmin2")
    public ResponseModel<IPage<TAdmin>> pageAdmin2(@RequestParam(value = "current") long current,
                                                   @RequestParam(value = "size") long size) {
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        Page<TAdmin> page = new Page<>(current, size, true);
        IPage<TAdmin> iPage = tAdminService.page(page, query);

        iPage.getRecords().forEach(e -> e.setPassword(""));
        return R.ok(iPage);
    }

    @ApiOperation(value = "获取账号列表")
    @GetMapping("/listAdmin")
    public ResponseModel<?> listAdmin(String adminId) {
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        if (StringUtils.isNotEmpty(adminId)) {
            query.like(TAdmin::getRelationAdminId, adminId);
        }
        List<TAdmin> list = tAdminService.list(query);
        return R.ok(list);
    }

    @ApiOperation(value = "修改账号")
    @PostMapping("/update")
    @Transactional
    public ResponseModel<?> update(@RequestBody TAdmin admin) {
        if (StringUtils.isEmpty(admin.getUsername()) && admin.getId() == null) {
            return R.fail(ResponseCodesEnum.A0001, "参数空");
        }
        //校验是否有重复的
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        if (StringUtils.isNotEmpty(admin.getUsername())) {
            query.eq(TAdmin::getUsername, admin.getUsername());
        }
        if (admin.getId() != null) {
            query.eq(TAdmin::getId, admin.getId());
        }
        List<TAdmin> list = tAdminService.list(query);
        TAdmin oldAdmin = list.get(0);
        if (StringUtils.isNotEmpty(admin.getPassword())) {
            oldAdmin.setPassword(admin.getPassword());
        }
        if (StringUtils.isNotEmpty(admin.getName())) {
            oldAdmin.setName(admin.getName());
        }
        if (admin.getAreaId() != null) {
            oldAdmin.setAreaId(admin.getAreaId());
        }
        if (StringUtils.isNotEmpty(admin.getIfForeign())) {
            oldAdmin.setIfForeign(admin.getIfForeign());
        }
        if (StringUtils.isNotEmpty(admin.getTradeMerchantNo())) {
            oldAdmin.setTradeMerchantNo(admin.getTradeMerchantNo());
        }
        if (StringUtils.isNotEmpty(admin.getPayPlatform())) {
            oldAdmin.setPayPlatform(admin.getPayPlatform());
        }
        if (StringUtils.isNotEmpty(admin.getPromoCodeOpen())) {
            oldAdmin.setPromoCodeOpen(admin.getPromoCodeOpen());
        }
        if (StringUtils.isNotEmpty(admin.getPhone())) {
            // 如果手机号不同，则验证手机号是否存在
            if (!admin.getPhone().equals(oldAdmin.getPhone())) {
                LambdaQueryWrapper<TAdmin> query2 = Wrappers.lambdaQuery();
                query2.eq(TAdmin::getPhone, admin.getPhone());
                TAdmin admin1 = tAdminService.getOne(query2);
                if (admin1 != null) {
                    return R.fail(ResponseCodesEnum.A0001, "手机号已存在");
                }
            }
            oldAdmin.setPhone(admin.getPhone());
        }
        if (StringUtils.isNotEmpty(admin.getEmail())) {
            if (!admin.getEmail().equals(oldAdmin.getEmail())) {
                LambdaQueryWrapper<TAdmin> query2 = Wrappers.lambdaQuery();
                query2.eq(TAdmin::getEmail, admin.getEmail());
                TAdmin admin1 = tAdminService.getOne(query2);
                if (admin1 != null) {
                    return R.fail(ResponseCodesEnum.A0001, "邮箱已存在");
                }
            }
            oldAdmin.setEmail(admin.getEmail());
        }
        if (StringUtils.isNotEmpty(admin.getCurrencySymbol())) {
            oldAdmin.setCurrencySymbol(admin.getCurrencySymbol());
        } else {
            oldAdmin.setCurrencySymbol("￥");
        }
        if (StringUtils.isNotEmpty(admin.getTimeZone())) {
            oldAdmin.setTimeZone(admin.getTimeZone());
        }
        if (admin.getApplyStartTime() != null) {
            oldAdmin.setApplyStartTime(admin.getApplyStartTime());
        }
        if (admin.getApplyEndTime() != null) {
            oldAdmin.setApplyEndTime(admin.getApplyEndTime());
        }
        if (StringUtils.isNotEmpty(admin.getRelationAdminId())) {
            oldAdmin.setRelationAdminId(admin.getRelationAdminId());
        }
        if (StringUtils.isNotEmpty(admin.getIsDistribution())) {
            oldAdmin.setIsDistribution(admin.getIsDistribution());
        }
        oldAdmin.setModifyDate(new Date());
        tAdminService.updateById(oldAdmin);
        return R.ok(null, "修改成功");
    }

    @ApiOperation(value = "设置关联上级")
    @PostMapping("/setRelationAdminId")
    public ResponseModel<?> setRelationAdminId(@RequestBody Map<String, String> params) {
        String managerId = params.get("managerId");
        String username = params.get("username");
        String relationUsername = params.get("relationUsername");
        if (StringUtils.isEmpty(managerId) || StringUtils.isEmpty(username)) {
            return R.fail(ResponseCodesEnum.A0001, "参数不能为空");
        }
        LambdaQueryWrapper<TAdmin> lqw = Wrappers.lambdaQuery();
        lqw.eq(TAdmin::getUsername, username);
        TAdmin admin = tAdminService.getOne(lqw);
        if (Objects.isNull(admin)) {
            return R.fail(ResponseCodesEnum.A0206, "用户不存在");
        }
        String managerId1 = admin.getManagerId();

        if (!managerId1.equals(managerId)) {
            return R.fail(ResponseCodesEnum.B0001, "用户名或系统id不匹配");
        }
        if (username.equals(relationUsername)) {
            return R.fail(ResponseCodesEnum.B0001, "同一账户不能构成上下级");
        }
        if (StringUtils.isEmpty(relationUsername) || "".equals(relationUsername)) { // 无上级，或取消上级
            admin.setRelationAdminId("");
        } else {
            LambdaQueryWrapper<TAdmin> wrapper = Wrappers.lambdaQuery();
            wrapper.eq(TAdmin::getUsername, relationUsername);
            TAdmin relationAdmin = tAdminService.getOne(wrapper);
            Long relationAdminId = relationAdmin.getId();
            admin.setRelationAdminId(String.valueOf(relationAdminId));
        }
        tAdminService.saveOrUpdate(admin);
        return R.ok("关联成功");
    }

    @ApiOperation(value = "绑定上级账户")
    @GetMapping("/setRelationAdmin")
    @Transactional
    public ResponseModel<?> setRelationAdmin(Long adminId, String username) {
        TAdmin admin = tAdminService.getById(adminId);
        if (StringUtils.isNotEmpty(username)) {
            if (StringUtils.isNotEmpty(admin.getRelationAdminId())) {
                return R.fail("已有绑定关系");
            }
            LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
            query.eq(TAdmin::getUsername, username);
            List<TAdmin> list = tAdminService.list(query);
            if (list.size() > 0) {
                TAdmin parentAdmin = list.get(0);
                if (StringUtils.isNotEmpty(parentAdmin.getRelationAdminId()) && parentAdmin.getRelationAdminId().equals(admin.getId().toString())) {
                    return R.fail("不能互为绑定关系");
                } else {
                    admin.setRelationAdminId(String.valueOf(parentAdmin.getId()));
                    tAdminService.updateById(admin);
                }
            } else {
                return R.fail("找不到账户");
            }

        } else {
            return R.fail(ResponseCodesEnum.A0001);
        }
        return R.ok(null, "绑定成功");
    }

    @ApiOperation(value = "获取所有关联(下级)账号信息")
    @GetMapping("/getAdminIdList")
    public ResponseModel<List<Long>> getAdminIdList(@RequestParam String adminId) {
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getRelationAdminId, adminId);
        List<TAdmin> list = tAdminService.list(query);
        List<Long> idList = new ArrayList<>();
        for (TAdmin admin : list) {
            idList.add(admin.getId());
        }
        return R.ok(idList);
    }

    @ApiOperation(value = "获取所有关联(下级)账号信息")
    @GetMapping("/getAdminList")
    public ResponseModel<?> getAdminList() {
        UserDetailBO userDetailBO = Optional.ofNullable(tokenManager.getLoginUserDetails())
                .orElseThrow(() -> new BizException(ResponseCodesEnum.L0001));
        String adminId = userDetailBO.getId().toString();
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getRelationAdminId, adminId);
        List<TAdmin> list = tAdminService.list(query);
        return R.ok(list);
    }

    @ApiOperation(value = "获取admin信息")
    @GetMapping("/getAdminOne/{adminId}")
    public ResponseModel<TAdmin> getAdminOne(@PathVariable Long adminId) {
        TAdmin admin = tAdminService.getById(adminId);
        if (Objects.isNull(admin)) {
            return R.fail("当前用户不存在");
        }
        return R.ok(admin);
    }

    @ApiOperation(value = "获取账号信息byname")
    @GetMapping("/getAdminByUsername")
    public ResponseModel<TAdmin> getAdminByUsername(@RequestParam String username) {
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getUsername, username);
        List<TAdmin> list = tAdminService.list(query);
        if (list.size() > 0) {
            TAdmin tAdmin = list.get(0);
            tAdmin.setPassword("");
            return R.ok(tAdmin);
        }
        return R.ok();
    }

    @ApiOperation(value = "通过 adminId 获取上级账号信息")
    @GetMapping("/getRelation")
    public ResponseModel<TAdmin> getRelation() {
        UserDetailBO userDetailBO = Optional.ofNullable(tokenManager.getLoginUserDetails())
                .orElseThrow(() -> new BizException(ResponseCodesEnum.L0001));
        String adminId = userDetailBO.getId().toString();
        LambdaQueryWrapper<TAdmin> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(TAdmin::getId, adminId);
        TAdmin admin = tAdminService.getOne(wrapper);
        if (Objects.nonNull(admin)) {
            String relationAdminId = admin.getRelationAdminId();
            if (StringUtils.isNotEmpty(relationAdminId) && !"".equals(relationAdminId)) {
                TAdmin relationAdmin = tAdminService.getById(relationAdminId);
                return R.ok(relationAdmin);
            }
        }
        return R.ok();
    }

    @ApiOperation(value = "通过 username 获取账号的 id")
    @GetMapping("/getRelationAdminId")
    public ResponseModel<String> getRelationAdminId(String relationUsername) {
        LambdaQueryWrapper<TAdmin> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(TAdmin::getUsername, relationUsername);
        TAdmin admin = tAdminService.getOne(wrapper);
        if (Objects.nonNull(admin)) {
            Long adminId = admin.getId();
            return R.ok(String.valueOf(adminId));
        }
        return R.ok();
    }

    @ApiOperation(value = "获取上级账号名")
    @GetMapping("/getRelationAdminUsername")
    public String getRelationAdminUsername(String relationAdminId) {
        TAdmin admin = tAdminService.getById(relationAdminId);
        return admin.getUsername();
    }

    @ApiOperation(value = "批量设置账户的角色")
    @GetMapping("/setRole")
    public ResponseModel<?> setRole() {
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getType, "2");
        List<TAdmin> list = tAdminService.list(query);
        if (list.size() > 0) {
            for (TAdmin admin : list) {
                // 绑定商家角色
                LambdaQueryWrapper<SysRole> query4 = Wrappers.lambdaQuery();
                query4.eq(SysRole::getAdminId, 18L);
                query4.eq(SysRole::getRoleName, "商家");
                List<SysRole> list2 = sysRoleService.list(query4);
                if (list2.size() > 0) {
                    SysRole sysRole = list2.get(0);
                    SysRole newSysRole = new SysRole();
                    newSysRole.setAdminId(admin.getId());
                    newSysRole.setMenuCodesJson(sysRole.getMenuCodesJson());
                    newSysRole.setRoleName("商家");
                    sysRoleService.save(newSysRole);
                    SysUserRole sysUserRole = new SysUserRole();
                    sysUserRole.setRoleId(newSysRole.getRoleId());
                    sysUserRole.setUserId(String.valueOf(admin.getId()));
                    sysUserRoleService.save(sysUserRole);
                }
            }
        }

        return R.ok();
    }

    @ApiOperation(value = "批量设置账户的关联上级")
    @GetMapping("/setRelation")
    public ResponseModel<?> setRelation() {
        List<TAdmin> list = tAdminService.list();
        if (list.size() > 0) {
            for (TAdmin admin : list) {
                if (admin.getParentId() != null) {
                    admin.setRelationAdminId(admin.getParentId().toString());
                    tAdminService.updateById(admin);
                }
            }
        }
        return R.ok();
    }

    @ApiOperation(value = "批量修改支付平台")
    @GetMapping("/updatePayPlatform")
    public ResponseModel<?> updatePayPlatform(@RequestParam String id, @RequestParam String payPlatform) {
        Integer adminId = Integer.valueOf(id);
        UpdateWrapper<TAdmin> updateWrapper = new UpdateWrapper<>();
        // 申泽管理员
        if (adminId == 2738) {
            updateWrapper.isNull("company_type").or().eq("company_type", 0);
        }
        // 七云管理员
        if (adminId == 2739) {
            updateWrapper.eq("company_type", 1);
        }
        updateWrapper.set("pay_platform", payPlatform);
        tAdminService.update(null, updateWrapper);
        return R.ok();
    }

    @ApiOperation(value = "一键迁移")
    @GetMapping("/oneKeyMigration")
    public ResponseModel<?> oneKeyMigration(Long adminId) {
        LambdaQueryWrapper<SysRole> query4 = Wrappers.lambdaQuery();
        query4.eq(SysRole::getAdminId, 18L);
        query4.eq(SysRole::getRoleName, "商家");
        List<SysRole> list2 = sysRoleService.list(query4);
        if (list2.size() > 0) {
            SysRole sysRole = list2.get(0);
            SysRole newSysRole = new SysRole();
            newSysRole.setAdminId(adminId);
            newSysRole.setMenuCodesJson(sysRole.getMenuCodesJson());
            newSysRole.setRoleName("商家");
            sysRoleService.save(newSysRole);
            SysUserRole sysUserRole = new SysUserRole();
            sysUserRole.setRoleId(newSysRole.getRoleId());
            sysUserRole.setUserId(String.valueOf(adminId));
            sysUserRoleService.save(sysUserRole);
            return R.ok("success");
        }
        return R.fail(ResponseCodesEnum.A0001, "fail");
    }

    @ApiOperation(value = "检验用户名是否存在")
    @GetMapping("/checkUserName")
    public ResponseModel<?> checkUserName(String username) {
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getUsername, username);
        TAdmin admin = tAdminService.getOne(query);
        if (admin != null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        return R.ok();
    }

    @ApiOperation(value = "切换订单通知开关")
    @GetMapping("/updateOrderNotice")
    public ResponseModel<?> updateOrderNotice(String adminId, String orderNotice) {
        if (StringUtils.isEmpty(adminId) || StringUtils.isEmpty(orderNotice)) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        // 查询是否有绑定微信
        if (orderNotice.equals("1")) {
            LambdaQueryWrapper<TWechat> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(TWechat::getAdminId, adminId);
            TWechat wechat = wechatService.getOne(wrapper);
            if (wechat == null) {
                return R.fail(ResponseCodesEnum.A0001, "请先绑定微信");
            }
        }
        TAdmin admin = tAdminService.getById(adminId);
        admin.setOrderNotice(orderNotice);
        tAdminService.updateById(admin);
        return R.ok();
    }

    @ApiOperation(value = "切换设备上下线通知开关")
    @GetMapping("/updateOnOffNotice")
    public ResponseModel<?> updateOnOffNotice(String adminId, String onOffNotice) {
        if (StringUtils.isEmpty(adminId) || StringUtils.isEmpty(onOffNotice)) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        TAdmin admin = tAdminService.getById(adminId);
        // 查询是否有绑定微信
        if (onOffNotice.equals("1")) {
            // 如果是国内用户才需要查询
            if (StringUtils.isNotEmpty(admin.getIfForeign()) && admin.getIfForeign().equals("0")) {
                LambdaQueryWrapper<TWechat> wrapper = new LambdaQueryWrapper<>();
                wrapper.eq(TWechat::getAdminId, adminId);
                TWechat wechat = wechatService.getOne(wrapper);
                if (wechat == null) {
                    return R.fail(ResponseCodesEnum.A0001, "请先绑定微信");
                }
            }
        }

        admin.setOnOffNotice(onOffNotice);
        tAdminService.updateById(admin);
        return R.ok();
    }

    @ApiOperation("校验apiKey")
    @GetMapping("/validateApiKey")
    public ResponseModel<?> validateApiKey(String apiKey, Long adminId) {
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getApiKey, apiKey);
        query.eq(TAdmin::getId, adminId);
        TAdmin admin = tAdminService.getOne(query);
        return R.ok(admin);
    }

    @ApiOperation("获取用户信息")
    @GetMapping("/getAdminVo")
    public ResponseModel<?> getAdminVo(String adminId) {
        TAdmin admin = tAdminService.getById(adminId);
        TAdmin tAdmin = new TAdmin();
        if (admin != null) {
            tAdmin.setId(admin.getId());
            tAdmin.setUsername(admin.getUsername());
            tAdmin.setName(admin.getName());
            tAdmin.setPhone(admin.getPhone());
            tAdmin.setEmail(admin.getEmail());
            tAdmin.setCompanyType(admin.getCompanyType());
            tAdmin.setIfForeign(admin.getIfForeign());
            tAdmin.setType(admin.getType());
            tAdmin.setAreaId(admin.getAreaId());
            return R.ok(tAdmin);
        }
        return R.ok();
    }

    @ApiOperation("修改地区")
    @GetMapping("/updateArea")
    public ResponseModel<?> updateArea(String adminId, String areaValue, String country) {
        TAdmin admin = tAdminService.getById(adminId);
        if (admin != null) {
            if (StringUtils.isNotEmpty(admin.getIfForeign()) && admin.getIfForeign().equals("1")) {
                // 国外
                LambdaQueryWrapper<Countries> query = Wrappers.lambdaQuery();
                query.eq(Countries::getCode, country);
                Countries countries = countriesService.getOne(query);
                if (countries != null) {
                    LambdaQueryWrapper<Cities> cityQuery = Wrappers.lambdaQuery();
                    cityQuery.eq(Cities::getCountryId, countries.getId());
                    cityQuery.eq(Cities::getCode, areaValue);
                    Cities cities = citiesService.getOne(cityQuery);
                    if (cities != null) {
                        admin.setAreaId(cities.getId());
                    }
                }
            } else {
                // 国内
                LambdaQueryWrapper<TArea> query = Wrappers.lambdaQuery();
                query.eq(TArea::getFullName, areaValue);
                TArea area = areaService.getOne(query);
                if (area != null) {
                    admin.setAreaId(area.getId());
                }
            }
            tAdminService.updateById(admin);
        }
        return R.ok();
    }

    @ApiOperation("国内账号获取所属地区")
    @GetMapping("/getAreaById")
    public ResponseModel<?> getAreaById(Long areaId) {
        TArea area = areaService.getById(areaId);
        return R.ok(area);
    }


    @ApiOperation("海外账号获取所属地区")
    @GetMapping("/getCitiesById")
    public ResponseModel<?> getCitiesById(Long areaId) {
        String areaName = "";
        Cities cities = citiesService.getById(areaId);
        if (cities != null) {
            Long countryId = cities.getCountryId();
            String cityCode = cities.getCode();
            Countries countries = countriesService.getById(countryId);
            String countryCode = countries.getCode();
            areaName = cityCode + "/" + countryCode;
        }
        return R.ok(areaName);
    }

    @ApiOperation("获取用户信息")
    @GetMapping("/changeArea")
    public ResponseModel<?> changeArea() {
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getIfForeign, "0");
        List<TAdmin> list = tAdminService.list(query);
        for (TAdmin admin : list) {
            Long areaId = admin.getAreaId();
            if (areaId != null) {
                TArea area = areaService.getById(areaId);
                if (area != null) {
                    String treePath = area.getTreePath();
                    String[] split = treePath.split(",");
                    if (split.length > 2) {
                        admin.setAreaId(Long.valueOf(split[2]));
                        tAdminService.updateById(admin);
                    }
                }
            }
        }
        return R.ok();
    }

    @ApiOperation("获取账号公司平台")
    @GetMapping("/getCompanyTypeById")
    public ResponseModel<?> getCompanyTypeById(String adminId) {
        TAdmin admin = tAdminService.getById(adminId);
        String companyType = "";
        if (admin != null) {
            companyType = admin.getCompanyType();
        }
        return R.ok(companyType);
    }

    @ApiOperation("获取权限")
    @GetMapping("/getPermission")
    public ResponseModel<?> getPermission(String adminId) {
        LambdaQueryWrapper<SysUserRole> query = Wrappers.lambdaQuery();
        query.eq(SysUserRole::getUserId, adminId);
        SysUserRole sysUserRole = sysUserRoleService.getOne(query);
        if (sysUserRole != null) {
            String roleId = sysUserRole.getRoleId();
            SysRole sysRole = sysRoleService.getById(roleId);
            if (sysRole != null) {
                return R.ok(sysRole);
            }
        }
        return R.ok();
    }

    @ApiOperation(value = "发送忘记密码验证码")
    @PostMapping("/sentForgetCode")
    public ResponseModel<?> sentForgetCode(@RequestBody LoginParam param) {
        String phoneOrEmail = param.getPhoneOrEmail();
        String hostName = param.getHostName();
        // 定义国内手机号和邮箱的正则表达式
        String phoneReg = "^1[3-9]\\d{9}$";
        String emailReg = "^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$";

        // 判断 phoneOrEmail 是手机号还是邮箱
        if (Pattern.matches(phoneReg, phoneOrEmail)) {
            //检测是否已有手机号注册
            LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
            query.eq(TAdmin::getPhone, phoneOrEmail);
            TAdmin admin = tAdminService.getOne(query);
            if (admin == null) {
                // 说明手机未注册
                return R.fail(ResponseCodesEnum.R0010);
            }
            //国内发送短信
            String result = tMessageCodeService.sentMessage("1", phoneOrEmail, admin.getCompanyType(), admin.getId());
            return R.ok(result);
        } else if (Pattern.matches(emailReg, phoneOrEmail)) {
            //检测是否已有邮箱注册
            LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
            query.eq(TAdmin::getEmail, phoneOrEmail);
            TAdmin admin = tAdminService.getOne(query);
            if (admin == null) {
                // 邮箱未注册
                return R.fail(ResponseCodesEnum.R0011);
            }
            // 发邮件
            String result = tMessageCodeService.sentEmail("1", phoneOrEmail, admin.getId(), hostName);
            return R.ok(result);
        }
        return R.fail(ResponseCodesEnum.R0004);
    }

    @ApiOperation(value = "校验验证码")
    @PostMapping("/checkForgetCode")
    public ResponseModel<?> checkForgetCode(@RequestBody LoginParam param) {
        String phoneOrEmail = param.getPhoneOrEmail();
        String code = param.getCode();
        LambdaQueryWrapper<TMessageCode> query = Wrappers.lambdaQuery();
        query.eq(TMessageCode::getPhone, phoneOrEmail);
        query.eq(TMessageCode::getCode, code);
        query.eq(TMessageCode::getType, "1");
        query.eq(TMessageCode::getStatus, "0");
        TMessageCode messageCode = tMessageCodeService.getOne(query);
        if (messageCode != null) {
            messageCode.setStatus("1");
            messageCode.setModifyDate(new Date());
            tMessageCodeService.updateById(messageCode);
            TAdmin admin = tAdminService.getById(messageCode.getAdminId());
            return R.ok(admin.getUsername());
        }
        return R.fail(ResponseCodesEnum.R0007);
    }

    @ApiOperation(value = "发送登录验证码")
    @PostMapping("/sentLoginCode")
    public ResponseModel<?> sentLoginCode(@RequestBody LoginParam param) {
        String phoneOrEmail = param.getPhoneOrEmail();
        String hostName = param.getHostName();
        // 定义国内手机号和邮箱的正则表达式
        String phoneReg = "^1[3-9]\\d{9}$";
        String emailReg = "^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$";

        // 判断 phoneOrEmail 是手机号还是邮箱
        if (Pattern.matches(phoneReg, phoneOrEmail)) {
            //检测是否已有手机号注册
            LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
            query.eq(TAdmin::getPhone, phoneOrEmail);
            TAdmin admin = tAdminService.getOne(query);
            if (admin == null) {
                // 说明手机未注册
                return R.fail(ResponseCodesEnum.R0010);
            }
            // 判断是为申泽用户还是七云用户
            String companyType = admin.getCompanyType();
            String sZ = "Sunzee";
            String sC = "Sevencloud";

            // 如果不为管理员
            if (admin.getType() >= 1) {
                if (sZ.equals(hostName)) {
                    // 如果companyType不为空，且不等于“0”
                    if (StringUtils.isNotEmpty(companyType) && !companyType.equals("0")) {
                        return R.fail(ResponseCodesEnum.R0010);
                    }
                }
                if (sC.equals(hostName)) {
                    // 如果companyType为空，或者不等于“1”
                    if (StringUtils.isEmpty(companyType) || !(companyType.equals("1"))) {
                        return R.fail(ResponseCodesEnum.R0010);
                    }
                }
            }
            //国内发送短信
            String result = tMessageCodeService.sentLoginMessage(phoneOrEmail, admin.getCompanyType());
            return R.ok(result);
        } else if (Pattern.matches(emailReg, phoneOrEmail)) {
            //检测是否已有邮箱注册
            LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
            query.eq(TAdmin::getEmail, phoneOrEmail);
            TAdmin admin = tAdminService.getOne(query);
            if (admin == null) {
                // 邮箱未注册
                return R.fail(ResponseCodesEnum.R0011);
            }
            // 判断是为申泽用户还是七云用户
            String companyType = admin.getCompanyType();
            String sZ = "Sunzee";
            String sC = "Sevencloud";

            // 如果不为管理员
            if (admin.getType() >= 1) {
                if (sZ.equals(hostName)) {
                    // 如果companyType不为空，且不等于“0”
                    if (StringUtils.isNotEmpty(companyType) && !companyType.equals("0")) {
                        return R.fail(ResponseCodesEnum.R0011);
                    }
                }
                if (sC.equals(hostName)) {
                    // 如果companyType为空，或者不等于“1”
                    if (StringUtils.isEmpty(companyType) || !(companyType.equals("1"))) {
                        return R.fail(ResponseCodesEnum.R0011);
                    }
                }
            }
            // 发邮件
            String result = tMessageCodeService.sentLoginEmail(phoneOrEmail, hostName);
            return R.ok(result);
        }
        return R.fail(ResponseCodesEnum.R0004);
    }

    @ApiOperation(value = "验证码登录")
    @PostMapping("/loginByCode")
    public ResponseModel<?> loginByCode(@RequestBody LoginParam param, HttpServletRequest request) {
        String phoneOrEmail = param.getPhoneOrEmail();
        String code = param.getCode();

        String loginCode = tokenManager.getLoginCode(phoneOrEmail);
        if (loginCode != null && loginCode.equals(code)) {
            tokenManager.deleteLoginCode(phoneOrEmail);
            LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
            query.eq(TAdmin::getPhone, phoneOrEmail).or().eq(TAdmin::getEmail, phoneOrEmail);
            TAdmin admin = tAdminService.getOne(query);
            // 添加系统id
            if (StringUtils.isEmpty(admin.getManagerId())) {
                String managerId = AdminUtils.encrypt(false, admin.getId());
                admin.setManagerId(managerId);
            }
            // 设置登录时间
            admin.setLoginDate(new Date());
            // 登录IP
            String ipAddress;
            // 获取通过代理服务器传递的真实IP地址
            String xForwardedForHeader = request.getHeader("X-Forwarded-For");
            if (xForwardedForHeader == null) {
                ipAddress = request.getRemoteAddr();
            } else {
                // 多次反向代理后会有多个IP值，第一个IP才是真实IP
                String[] ips = xForwardedForHeader.split(",");
                ipAddress = ips[0].trim();
            }
            admin.setLoginIp(ipAddress);
            tAdminService.updateById(admin);
            UserDetailBO userDetailBO = tAdminService.getUserDetailBO(admin);
            return R.ok(userDetailBO);
        }
        return R.fail(ResponseCodesEnum.R0007);
    }

}