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

package com.szwl.controller;


import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.UUID;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.manager.TokenManager;
import com.szwl.model.bo.R;
import com.szwl.model.bo.ResponseModel;
import com.szwl.model.bo.UserDetailBO;
import com.szwl.model.entity.*;
import com.szwl.model.param.AddLoginUserParam;
import com.szwl.model.param.UpdateLoginUserParam;
import com.szwl.model.param.UpdateSysRoleParam;
import com.szwl.service.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 短信验证码 前端控制器
 * </p>
 *
 * @author wuhs
 * @since 2022-04-14
 */
@Slf4j
@Api(value = "/tAdmin", tags = {"账户"})
@RestController
@RequestMapping("/tAdmin")
public class TAdminController {
    @Autowired
    SysRoleService sysRoleService;
    @Autowired
    SysUserRoleService sysUserRoleService;
    @Autowired
    TokenManager tokenManager;
    @Autowired
    TAdminService tAdminService;
    @Autowired
    TAdminEquipmentService tAdminEquipmentService;
    @Autowired
    TMessageCodeService tMessageCodeService;

    @ApiOperation(value = "添加子账号")
    @PostMapping("/addLoginUser")
    @Transactional
    @Audit(type = AuditEnum.INSERT,content = "#loginUser.name + '添加账号'")
    public ResponseModel<?> addLoginUser(@RequestBody @Valid AddLoginUserParam param) {
//    public ResponseModel<?> addLoginUser(@RequestBody  AddLoginUserParam param) {
        //获取当前操作人员
        UserDetailBO loginUser = tokenManager.getLoginUserDetails();
        // 保存用户实体
        Date now = new Date();
        Long parentId = param.getAdminId();
        if(parentId==null){
            return R.fail(ResponseCodesEnum.A0001);
        }
        param.setAdminId(null);
        TAdmin entity = BeanUtil.copyProperties(param,TAdmin.class);
        entity.setParentId(parentId);
        if(parentId.toString().equals("1")){
            entity.setType(1);
        }else {
            entity.setType(3);
        }
//        entity.setParentId(34l);
        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());
        tAdminService.save(entity);
        // 管理的机器 需要再建立一个关系表 type区分全部还是部分
        String equipmentIds = param.getEquipmentIds();
        if(StringUtils.isNotEmpty(equipmentIds)){
            if(equipmentIds.equals("all")){
                //管理全部机器
                TAdminEquipment tAdminEquipment = new TAdminEquipment();
                tAdminEquipment.setAdminId(entity.getId());
                //0:全部机器，1：部分机器
                tAdminEquipment.setType("0");
                tAdminEquipmentService.save(tAdminEquipment);
            }else {
                //部分机器
                TAdminEquipment tAdminEquipment = new TAdminEquipment();
                tAdminEquipment.setAdminId(entity.getId());
                //0:全部机器，1：部分机器
                tAdminEquipment.setType("1");
                tAdminEquipment.setEquipmentIds(param.getEquipmentIds());
                tAdminEquipmentService.save(tAdminEquipment);
            }
        }

        log.debug("添加账号 id:{},TAdmin:{}",entity.getId(),entity);
        // 保存用户角色关系
        List<SysUserRole> userRoleList = param.getRoleList()
                .stream()
                .map(e -> new SysUserRole().setRoleId(e).setUserId(String.valueOf(entity.getId())) )
                .collect(Collectors.toList());

        if(CollUtil.isNotEmpty(userRoleList)){
            sysUserRoleService.saveBatch(userRoleList);
        }
        return R.ok(entity);
    }
    @ApiOperation(value = "修改子账号")
    @PostMapping("/updateLoginUser")
    @Transactional
    @Audit(type = AuditEnum.UPDATE,content = "#loginUser.name + '修改账号'")
    public ResponseModel<?> updateLoginUser(@RequestBody @Valid UpdateLoginUserParam param) {
//    public ResponseModel<?> addLoginUser(@RequestBody  AddLoginUserParam param) {
        //获取当前操作人员
        UserDetailBO loginUser = tokenManager.getLoginUserDetails();
        // 保存用户实体
        Date now = new Date();
        Long parentId = param.getAdminId();
        if(parentId==null){
            return R.fail(ResponseCodesEnum.A0001);
        }
        param.setAdminId(null);
//        TAdmin entity = BeanUtil.copyProperties(param,TAdmin.class);
//        entity.setParentId(parentId);
////        entity.setParentId(34l);
//        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());
//        tAdminService.save(entity);
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getParentId,parentId);
        query.eq(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);
                    if(equipmentIds.equals("all")){
                        //管理全部机器
                        //0:全部机器，1：部分机器
                        tAdminEquipment1.setType("0");
                        tAdminEquipment1.setEquipmentIds(null);
                    }else {
                        //部分机器
                        //0:全部机器，1：部分机器
                        tAdminEquipment1.setType("1");
                        tAdminEquipment1.setEquipmentIds(param.getEquipmentIds());
                    }
                    tAdminEquipmentService.updateById(tAdminEquipment1);
                }

            }
            LambdaQueryWrapper<SysUserRole> query1 = Wrappers.lambdaQuery();
            query1.eq(SysUserRole::getUserId,admin.getId());
            List<SysUserRole> list1 = sysUserRoleService.list(query1);
            if(list1.size()>0){
                for(SysUserRole sysUserRole:list1){
                    sysUserRoleService.removeById(sysUserRole.getId());
                }

            }
            // 保存用户角色关系
            List<SysUserRole> userRoleList = param.getRoleList()
                    .stream()
                    .map(e -> new SysUserRole().setRoleId(e).setUserId(String.valueOf(admin.getId())) )
                    .collect(Collectors.toList());

            if(CollUtil.isNotEmpty(userRoleList)){
                sysUserRoleService.saveBatch(userRoleList);
            }
            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);
            log.debug("修改账号 id:{},TAdmin:{}",admin.getId(),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) {
//    public ResponseModel<?> addLoginUser(@RequestBody  AddLoginUserParam param) {
        //获取当前操作人员
        UserDetailBO loginUser = tokenManager.getLoginUserDetails();
        // 保存用户实体
        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.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());
            List<SysUserRole> list2 = sysUserRoleService.list(query2);
            if(list2.size()>0){
                SysUserRole sysUserRole = list2.get(0);
                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.eq(TAdmin::getName,name);
        }
        if(StringUtils.isNotEmpty(adminId)){
            if(adminId.equals("1")){
//                query.in(TAdmin::getType,"1","3");
                query.eq(TAdmin::getType,"1");
            }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.size()>0){

            for(TAdmin admin:list){
                AddLoginUserParam addLoginUserParam = new AddLoginUserParam();
                JSONObject jsonObject = new JSONObject();
                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.size()>0){
                    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.size()>0){
                    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);
//                    List<String> list2 = Arrays.asList(sysRole.getMenuCodesJson().split(","));
//                    addLoginUserParam.setRoleList(list2);
                    }

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

        }
        return R.ok(returnList);
    }
    @ApiOperation(value = "注册")
    @PostMapping("/save")
    @Transactional
    @Audit(type = AuditEnum.INSERT,content = "#loginUser.name + '注册账号'")
    public ResponseModel<?> save(@RequestBody TAdmin admin) {
        if(StringUtils.isEmpty(admin.getUsername())||StringUtils.isEmpty(admin.getName())||StringUtils.isEmpty(admin.getPassword())){
            return R.fail(ResponseCodesEnum.A0100,"数据有空！");
        }
        if(admin.getIfForeign().equals("0")){
            //国内用户注册
            if(StringUtils.isEmpty(admin.getPhone())){
                return R.fail(ResponseCodesEnum.A0100,"手机号为空！");
            }
        }else {
            //国外用户注册
            if(StringUtils.isEmpty(admin.getEmail())){
                return R.fail(ResponseCodesEnum.A0100,"邮箱为空！");
            }
        }
        if (StringUtils.isEmpty(admin.getCode())){
            return R.fail(ResponseCodesEnum.A0100,"验证码为空！");
        }
        //校验是否有重复的
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getUsername,admin.getUsername());
        List<TAdmin> list = tAdminService.list(query);
        if(list.size()>0){
            return R.fail(ResponseCodesEnum.A0201,"用户登录名已存在");
        }
        LambdaQueryWrapper<TAdmin> query1 = Wrappers.lambdaQuery();
        if(admin.getIfForeign().equals("0")){
            query1.eq(TAdmin::getPhone,admin.getPhone());
        }else {
            query1.eq(TAdmin::getEmail,admin.getEmail());
        }
        List<TAdmin> list1 = tAdminService.list(query1);
        if(list1.size()>0){
            return R.fail(ResponseCodesEnum.A0203,"用户手机/邮箱已存在");
        }
        //校验验证码是否正确
        LambdaQueryWrapper<TMessageCode> query2 = Wrappers.lambdaQuery();
        if(admin.getIfForeign().equals("0")){
            query2.eq(TMessageCode::getPhone,admin.getPhone());
        }else {
            query2.eq(TMessageCode::getPhone,admin.getEmail());
        }
        query2.eq(TMessageCode::getType,"0");//0，代表注册验证码
        query2.eq(TMessageCode::getStatus,"0");
        List<TMessageCode> messageCodeList = tMessageCodeService.list(query2);
        if(messageCodeList.size()>0){
            TMessageCode tMessageCode = messageCodeList.get(messageCodeList.size() - 1);
            if(!tMessageCode.getCode().equals(admin.getCode())){
                return R.fail(ResponseCodesEnum.A0002,"验证码错误");
            }
            tMessageCode.setStatus("1");
            admin.setCreateDate(new Date());
            admin.setModifyDate(new Date());
            admin.setIsAdmined(false);
            admin.setIsEnabled(true);
            admin.setLoginFailureCount(0);
            admin.setIsLocked(false);
            //默认是商家
            admin.setType(2);
            admin.setIsAdmined(true);
            admin.setPassword(DigestUtils.md5Hex(admin.getPassword()));
            boolean b = tAdminService.save(admin);
            //todo 绑定商家角色
            tMessageCode.setModifyDate(new Date());
            tMessageCodeService.saveOrUpdate(tMessageCode);
            if(b){
                admin.setManagerId(admin.getManager());
                tAdminService.getById(admin);
            }
            return R.ok(b);

        }else {
            return R.fail(ResponseCodesEnum.A0002,"没有找到验证码");
        }

    }
    @ApiOperation(value = "登录")
    @PostMapping("/login")
    @Audit(type = AuditEnum.LOGIN,content = "#username + '请求登录'")
    public ResponseModel<UserDetailBO> login(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);
        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));
        UserDetailBO userDetailBO = BeanUtil.copyProperties(tAdmin,UserDetailBO.class);

        String token = IdUtil.simpleUUID();
        userDetailBO.setCurrentToken(token);
        // 获取拥有的权限菜单
        Set<String> menuList = sysRoleService.listAuthMenuByUserId(userDetailBO.getId());
        userDetailBO.setMenuCodeList(CollUtil.newArrayList(menuList));
        // 抹除密码
        userDetailBO.setPassword(null);
        // 保存到redis
        tokenManager.saveAuthentication(token,userDetailBO);
        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.size()>0){
            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) {
        TAdmin tAdmin = tAdminService.getById(id);
        return R.ok(tAdmin);
    }

    @ApiOperation(value = "获取账号列表 分页")
    @GetMapping("/pageAdmin")
    public ResponseModel<IPage<?>> pageAdmin(String id,String name,String userName,String ifForeign,long current,long size ) {
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        if(StringUtils.isNotEmpty(name)){
            query.eq(TAdmin::getName,name);
        }
        if(StringUtils.isNotEmpty(userName)){
            query.like(TAdmin::getUsername,userName);
        }
        if(StringUtils.isNotEmpty(ifForeign)){
            query.like(TAdmin::getIfForeign,ifForeign);
        }
        if(StringUtils.isNotEmpty(id)){
            query.like(TAdmin::getRelationAdminId,id);
        }
        Page<TAdmin> page = new Page<>(current, size, true);
        IPage<TAdmin> iPage = tAdminService.page(page, query);
        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);
        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) {
        //校验是否有重复的
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getUsername,admin.getUsername());
        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(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())){
            oldAdmin.setPhone(admin.getPhone());
        }
        if(StringUtils.isNotEmpty(admin.getEmail())){
            oldAdmin.setEmail(admin.getEmail());
        }
        if(admin.getApplyStartTime()!=null){
            oldAdmin.setApplyStartTime(admin.getApplyStartTime());
        }
        if(admin.getApplyEndTime()!=null){
            oldAdmin.setApplyEndTime(admin.getApplyEndTime());
        }
        oldAdmin.setModifyDate(new Date());
        tAdminService.updateById(oldAdmin);
        return R.ok();
    }

    @ApiOperation(value = "绑定上级账户")
    @PostMapping("/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();
    }

    @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(String adminId) {
        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
        query.eq(TAdmin::getRelationAdminId,adminId);
        List<TAdmin> list = tAdminService.list(query);
        return R.ok(list);
    }
    @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);
        TAdmin tAdmin = list.get(0);
        return R.ok(tAdmin);
    }
    @ApiOperation(value = "获取上级账号名")
    @GetMapping("/getRelationAdminUsername")
    public String getRelationAdminUsername(String relationAdminId) {
        TAdmin admin = tAdminService.getById(relationAdminId);
        return admin.getUsername();
    }
}