java-insagent-pc/src/main/java/com/ydtech/modules/partner/service/Impl/PartnerUserServiceImpl.java

package com.ydtech.modules.partner.service.Impl;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ydtech.core.page.HttpResult;
import com.ydtech.modules.admin.dao.SysUserMapper;
import com.ydtech.modules.admin.model.SysUser;
import com.ydtech.modules.admin.model.vo.AppUserInfoVo;
import com.ydtech.modules.admin.service.impl.SysUserServiceImpl;
import com.ydtech.modules.base.controller.BaseController;
import com.ydtech.modules.order.dao.InsUploadFilesMapper;
import com.ydtech.modules.order.entity.api.zhongmei.constants.TimeConstants;
import com.ydtech.modules.order.entity.po.InsUploadFiles;
import com.ydtech.modules.partner.dao.*;
import com.ydtech.modules.partner.model.*;
import com.ydtech.modules.partner.model.param.*;
import com.ydtech.modules.partner.model.vo.*;
import com.ydtech.modules.partner.service.PartnerCommissionService;
import com.ydtech.modules.partner.service.PartnerLiftingRecordService;
import com.ydtech.modules.partner.service.PartnerRuleService;
import com.ydtech.modules.partner.service.PartnerUserService;
import com.ydtech.modules.partner.utils.ConditionUtils;
import com.ydtech.modules.partner.utils.ExpiredCommissionUtils;
import com.ydtech.modules.partner.utils.PartnerDateUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.function.Function;
import java.util.stream.Collectors;

@Service
public class PartnerUserServiceImpl extends ServiceImpl<PartnerUserMapper, PartnerUser> implements PartnerUserService {


    @Autowired
    private PartnerRuleService ruleService;

    @Autowired
    private PartnerLiftingRecordService liftingRecordService;

    @Resource
    private SysUserMapper sysUserMapper;

    @Autowired
    private InsUploadFilesMapper uploadFilesMapper;

    @Autowired
    private PartnerPartnerAccountMapper partnerPartnerAccountMapper;

    @Autowired
    private PartnerPremiumDetailsMapper detailsMapper;

    @Autowired
    private PartnerLiftingRecordMapper liftingRecordMapper;

    @Autowired
    private PartnerPartnerAccountMapper accountMapper;

    @Autowired
    private PartnerCommissionService commissionService;

    @Autowired
    private PartnerRuleService partnerRuleService;

    @Autowired
    private PartnerExpiredCommissionMapper expiredCommissionMapper;

    @Value("${partner.expireDays}")
    private Long expireDays;

    @Override
    public IPage<PartnerUserVo> queryPage(QueryVo queryVo) {
        IPage<PartnerUserVo> page = baseMapper.queryPage(queryVo.getPage(),queryVo);
        return page;
    }

    @Override
    public List<RelationalVo>  relationalQuery(String id) {
        List<RelationalVo> list = new ArrayList<>();

        Integer grade = baseMapper.selectGradeMin(id);
        List<RelationalVo> partnerUsers = baseMapper.selectByUserId(id,grade);
        if (1 < grade){
            querySuperiors(list, grade,partnerUsers);
        }
        list.addAll(partnerUsers);
        querySubordinates(partnerUsers, grade,list);
        return list;
    }

    public void querySuperiors(List<RelationalVo> list,Integer grade,List<RelationalVo> partnerUsers){
        if (CollectionUtil.isEmpty(partnerUsers)){
            return;
        }
        String userId = partnerUsers.get(0).getUserId();
        grade --;
        List<RelationalVo> relationalVos = baseMapper.selectQuerySuperiors(userId,grade);
        list.addAll(relationalVos);
        querySuperiors( list, grade, relationalVos);
    }


    public void querySubordinates(List<RelationalVo> partnerUsers,Integer grade,List<RelationalVo> list){
        if (CollectionUtil.isEmpty(partnerUsers)){
            return;
        }
        String userId = partnerUsers.get(0).getUserId();
        grade ++;
        List<RelationalVo> relationalVos = baseMapper.selectByReferrerId(userId,grade);
        list.addAll(relationalVos);
        querySubordinates(relationalVos, grade,list);
    }


    @Override
    public List<Map<String, String>> selectRecommender(String level) {
        if (StringUtils.isEmpty(level)){
            return new ArrayList<>(0);
        }
        if (StringUtils.equals(level,"2")){
            level = "1";
        }else if (StringUtils.equals(level,"3")){
            level = "2";
        }else if (StringUtils.equals(level,"4")){
            level = "3";
        }
        return baseMapper.selectRecommender(level);
    }

    @Override
    public HttpResult verifyUpgradeConditions(UserGradeParam userGradeParam) {
        if (StringUtils.isBlank(userGradeParam.getGrade())){
            return HttpResult.error("参数不能为空");
        }
        String grade = userGradeParam.getGrade();
        if (StringUtils.equals("2",grade)){
            return HttpResult.error("当前用户无法升级");
        }
        QueryWrapper<PartnerUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id",userGradeParam.getId());
        queryWrapper.eq("grade",Integer.valueOf(grade) - 1 );
        Long count = baseMapper.selectCount(queryWrapper);
        QueryWrapper<PartnerLiftingRecord> wrapper = new QueryWrapper<>();
        wrapper.eq("user_id",userGradeParam.getId());
        wrapper.eq("audit_status",0);
        Long aLong = liftingRecordMapper.selectCount(wrapper);

        if (count > 0 || aLong > 0){
            return HttpResult.error("不满足升级条件");
        }
        if (ruleService.verifyUpgradeConditions(userGradeParam.getId(),userGradeParam.getGrade())){
            return HttpResult.ok("满足升级条件");
        }
        return HttpResult.error("不满足升级条件");
    }

    @Override
    public HttpResult submitLiftingRecord(UserGradeParam userGradeParam) {
        if (!StringUtils.equals("4",userGradeParam.getGrade())){
            userGradeParam.setGrade(String.valueOf(Integer.valueOf(userGradeParam.getGrade()) + 1));
        }
        if (StringUtils.equals("1",userGradeParam.getGrade())){
            return HttpResult.error("当前用户无法解锁");
        }
        QueryWrapper<PartnerLiftingRecord> wrapper = new QueryWrapper<>();
        wrapper.eq("user_id",userGradeParam.getId());
        wrapper.eq("audit_status",0);
        wrapper.eq("type",0);
        Long aLong = liftingRecordMapper.selectCount(wrapper);
        if (aLong > 0){
            return HttpResult.error("重复提交，等待管理员审批");
        }
        LambdaQueryWrapper<PartnerUser> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(PartnerUser::getUserId,userGradeParam.getId());
        lambdaQueryWrapper.eq(PartnerUser::getGrade,userGradeParam.getGrade());
        PartnerUser partnerUser = baseMapper.selectOne(lambdaQueryWrapper);
        if (Objects.isNull(partnerUser)){
            return HttpResult.error("用户不存在");
        }
        //   条件
        PartnerLiftingRecord record = new PartnerLiftingRecord();
        record.setName(partnerUser.getName());
        record.setMobile(partnerUser.getMobile());
        record.setUserId(partnerUser.getUserId());
        record.setDeptId(partnerUser.getDeptId());
        record.setDeptName(partnerUser.getDeptName());
        record.setType("0");
        record.setOriginalLevel(userGradeParam.getGrade());
        record.setUpgradeType(userGradeParam.getUpgradeType());
        record.setCreateTime(new Date());
        switch (userGradeParam.getGrade()) {
            case "1":
                record.setAfterChange("");
                break;
            case "2":
                record.setAfterChange("1");
                break;
            case "3":
                record.setAfterChange("2");
                break;
            case "4":
                record.setAfterChange("3");
                break;

        }
        record.setConditions(ConditionUtils.upgradeConditions(record.getOriginalLevel()));
        record.setRules(ConditionUtils.assessmentRules(record.getOriginalLevel()));
        return liftingRecordService.saveLiftingRecord(record);
    }


    public String getMessage(PartnerRuleEntity ruleEntity){
        String message = "";
        PartnerAttribute entityCycle = ruleEntity.getCycle();
        switch (entityCycle.getCycle()){
            case "1":
                message = "成为该等级后，无限期";
                break;
            case "2":
                message = "成为该等级后，限期" + entityCycle.getFixedDays() + "天";
                break;
            case "3":
                message = "成为该等级后，固定限期" + entityCycle.getMin() + "至" + entityCycle.getMax();
                break;
        }
        return message;
    }



    @Override
    public HttpResult getHomePage(AppHomeParams params) {
        if (StringUtils.isBlank(params.getUserId())){
            return HttpResult.error("参数不能为空");
        }
        Set<String> list = baseMapper.getLevelAllUserId(params.getUserId());
        params.setRelatedPerList(list);
        params.setCountCycle("Day");
        HomeVo homeVo = new HomeVo();
        TodayOverview overview = new TodayOverview();
        if (CollectionUtil.isNotEmpty(list)){
            overview = baseMapper.selectTodayOverview(params);
            homeVo.setTodayOverview(overview);
        }else {
            homeVo.setTodayOverview(overview);
        }
        //查询当前用户等级
        List<TeamOverviewVo> teamOverviewVos = baseMapper.selectTeamOverview(params);


        List<PartnerUser> partnerUsers = baseMapper.selectList(new LambdaQueryWrapper<>(PartnerUser.class)
                .eq(PartnerUser::getUserId,params.getUserId())
                .in(PartnerUser::getGrade, getGradeList(teamOverviewVos)));

        Map<Integer, PartnerUser> userMap = partnerUsers.stream()
                .collect(Collectors.toMap(PartnerUser::getGrade, Function.identity()));


        for (TeamOverviewVo overviewVo : teamOverviewVos) {
            PartnerUser partnerUser = userMap.get(Integer.valueOf(overviewVo.getGrade()));
            switch (overviewVo.getGrade()){
                case "1":
                    overviewVo.setVo1(baseMapper.selectStatistics(overviewVo.getGrade(), params));
                    break;
                case "2":
                    overviewVo.setVo2(baseMapper.selectStatistics(overviewVo.getGrade(), params));
                    break;
                case "3":
                    overviewVo.setVo3(baseMapper.selectStatistics(overviewVo.getGrade(), params));
                    break;
                case "4":
                    overviewVo.setVo4(baseMapper.selectStatistics(overviewVo.getGrade(), params));
                    break;
            }
            if (null == partnerUser){
                overviewVo.setParentStatus("0");
            }else {
                if (partnerUser.isIdentityStatus()){
                    overviewVo.setParentStatus("2");
                    overviewVo.setLockCommission(accountMapper.selectCashFee(partnerUser.getUserId(), partnerUser.getGrade()));
                    Long difference = calculateTimeDifference(partnerUser.getUserId(), partnerUser.getGrade());
                    overviewVo.setZeroDays(difference);
                    PartnerRuleEntity rule = partnerRuleService.selectByGrade(overviewVo.getGrade());
                    overviewVo.setFallAmount(rule.getFallAmount());
                    getRule(overviewVo, partnerUser);
                }else {
                    overviewVo.setParentStatus("1");
                }
            }
        }
        homeVo.setTeamOverview(teamOverviewVos);
        return HttpResult.ok(homeVo);
    }

    public List<String> getGradeList(List<TeamOverviewVo> teamOverviewVos) {
        return teamOverviewVos.stream()
                .map(TeamOverviewVo::getGrade)
                .distinct()
                .collect(Collectors.toList());
    }

    @Override
    public List<String> getUserGradeList(String userId) {
        QueryWrapper<PartnerUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        List<PartnerUser> partnerUsers = baseMapper.selectList(queryWrapper);
        return partnerUsers.stream()
                .map(user -> String.valueOf(user.getGrade()))
                .collect(Collectors.toList());
    }

    @Override
    public HttpResult addUserIdentity(Map<String, Object> map) {
        try {
            if (map.containsKey("userId")){
                String userId = (String) map.get("userId");
                PartnerUser partnerUsers = baseMapper.selectMaxGradeUserId(userId);
                if (partnerUsers == null){
                    return HttpResult.error("请选择用户");
                }
                if (StringUtils.equals("4",String.valueOf(partnerUsers.getGrade()))){
                    return HttpResult.error("请邀请团队长");
                }
                if (map.containsKey("gradeList")){
                    List<String> list = (ArrayList<String>)  map.get("gradeList");
                    List<String> gradeList = list.stream()
                            .sorted(Comparator.comparingInt(Integer::parseInt))
                            .collect(Collectors.toList());
                    if (partnerUsers != null && CollectionUtil.isNotEmpty(gradeList)){
                        SysUser sysUser = sysUserMapper.selectById(userId);
                        for (String s : gradeList) {
                            String deptId = sysUser.getDeptId();
                            if (StringUtils.equals("4",s)){
                                deptId = SpringUtil.getBean(SysUserServiceImpl.class).addDeptUser(sysUser,s);
                            }
                            PartnerUser partnerUser = new PartnerUser();
                            partnerUser.setName(sysUser.getName());
                            partnerUser.setMobile(sysUser.getMobile());
                            partnerUser.setUserId(sysUser.getId());
                            partnerUser.setDeptId(deptId);
                            partnerUser.setDeptName(sysUser.getDeptName());
                            partnerUser.setGrade(Integer.valueOf(s));
                            partnerUser.setReferrerId(partnerUsers.getUserId());
                            baseMapper.insert(partnerUser);
                        }
                    }
                }
            }
        }catch (Exception e){
            log.error("添加失败",e);
            return HttpResult.error();
        }
        return HttpResult.ok("添加成功");
    }

    @Override
    public HttpResult queryIdentityInformation(String userId) {
        List<PartnerRule> partnerRules = ruleService.selectAll();
        List<PartnerUser> partnerUsers = baseMapper.selectList(new LambdaQueryWrapper<>(PartnerUser.class).eq(PartnerUser::getUserId, userId));
        Map<Integer, PartnerUser> userMap = partnerUsers.stream()
                .collect(Collectors.toMap(
                        PartnerUser::getGrade,
                        user -> user
                ));

        List<MyUserLevel> list = getUserLevels(userId, partnerRules, userMap);
        list.sort((o1, o2) -> Integer.compare(o2.getGrade(), o1.getGrade()));
        return HttpResult.ok(list);
    }

    @Override
    public HttpResult queryDowngradeTask(String grade, String userId) {
        PartnerRuleEntity partnerRuleEntity = ruleService.selectByGrade(grade);
        partnerRuleEntity.setStrategyArray(null);
        CommissionValidityPeriod period = ruleService.getCommissionValidityPeriod(partnerRuleEntity.getCycle(), userId, grade);
        if (Objects.isNull( period) || period.getStartDate() == null){
            return HttpResult.error("时间范围不能为空");
        }
        partnerRuleEntity.setAssessmentEndDate(period.getEndDate().split(" ")[0]);
        BigDecimal bf = baseMapper.subordinateMembersInsurancePremiums(userId, grade, period);
        BigDecimal p = ruleService.getInviteData(userId, grade, period);
        BigDecimal ownBf = baseMapper.selectOwnSumPremium(userId, period);
        List<PartnerAttribute> requirement = partnerRuleEntity.getRequirement();
        return getAttribute(partnerRuleEntity,bf, p, ownBf, requirement);
    }

    private HttpResult getAttribute(PartnerRuleEntity partnerRuleEntity, BigDecimal bf, BigDecimal p, BigDecimal ownBf, List<PartnerAttribute> requirement) {
        requirement.get(0).setAchieve(String.valueOf(p));
        requirement.get(1).setAchieve(null != bf ? bf.toString() : BigDecimal.ZERO.toString());
        requirement.get(2).setAchieve(null != ownBf ? ownBf.toString() : BigDecimal.ZERO.toString());
        return HttpResult.ok( partnerRuleEntity);
    }

    @Override
    public HttpResult degradedTask(String grade, String userId) {
        PartnerRuleEntity partnerRuleEntity = ruleService.selectByGrade(grade);
        if (partnerRuleEntity == null){
            return HttpResult.error("等级不存在");
        }
        partnerRuleEntity.setRequirement(null);
        CommissionValidityPeriod period = baseMapper.selectUpgradeCycleStartTime(userId, Integer.valueOf(grade));
        period.setEndDate(SpringUtil.getBean(ExpiredCommissionUtils.class).generateDowngradeTime(grade,period.getStartDate()));
        partnerRuleEntity.setAssessmentEndDate(period.getEndDate().split(" ")[0]);
        BigDecimal bf = baseMapper.subordinateMembersInsurancePremiums(userId, grade, period);
        BigDecimal p = ruleService.getInviteData(userId, grade, period);
        BigDecimal ownBf = baseMapper.selectOwnSumPremium(userId, period);
        List<PartnerAttribute> strategyArray = partnerRuleEntity.getStrategyArray();

        return getAttribute(partnerRuleEntity, bf, p, ownBf, strategyArray);
    }

    @Override
    public Integer selectByUserIdMax(String referrerId) {
        return baseMapper.selectByUserIdMax(referrerId);
    }

    @Override
    public HttpResult selectByIdListData(String id) {
        if (StringUtils.isEmpty(id)) {
            return HttpResult.error("ID不能为空");
        }
        PartnerUser partnerUser = baseMapper.selectById(id);
        if (ObjectUtils.isEmpty(partnerUser)) {
            return HttpResult.error("人员不存在");
        }
        JSONObject referrerInfo = new JSONObject();
        referrerInfo.put("referrerGrade",baseMapper.selectByUserIdGrade(partnerUser.getUserId()));
        referrerInfo.put("referrerName",baseMapper.selectByUserIdUserName(partnerUser.getUserId()));
        referrerInfo.put("mobile",partnerUser.getMobile());
        referrerInfo.put("userName",partnerUser.getName());
        HashMap<String, Object> map = new HashMap<>();
        List<JSONObject> list = getLevelUserList(partnerUser.getUserId(), partnerUser.getGrade(), null, getRule());
        map.put("list",list);
        map.put("referrer",referrerInfo);
        map.put("parentStatus",partnerUser.isIdentityStatus() ? "2" : "1");
        return HttpResult.ok(map);
    }


    private List<MyUserLevel> getUserLevels(String userId, List<PartnerRule> partnerRules, Map<Integer, PartnerUser> userMap) {
        List<MyUserLevel> list = new ArrayList<>();

        // 输入参数校验
        if (partnerRules == null || userId == null || userMap == null) {
            return list;
        }

        for (PartnerRule rule : partnerRules) {
            Integer grade = rule.getGrade();
            PartnerUser partnerUser = userMap.get(grade);
            MyUserLevel level = createBasicUserLevel(rule);

            if (partnerUser == null) {
                handleUnregisteredUser(userId, userMap, grade, level);
            } else {
                handleRegisteredUser(userId, partnerUser, level);
            }

            list.add(level);
        }

        return list;
    }

    // 提取创建基础UserLevel的逻辑
    private MyUserLevel createBasicUserLevel(PartnerRule rule) {
        MyUserLevel level = new MyUserLevel();
        level.setFallAmount(rule.getFallAmount());
        level.setRatio(getProportion(rule.getGrade()));
        level.setGrade(rule.getGrade());
        level.setGradeName(rule.getGradeName());
        return level;
    }

    // 处理未注册用户的逻辑
    private void handleUnregisteredUser(String userId, Map<Integer, PartnerUser> userMap,
                                        Integer grade, MyUserLevel level) {
        level.setLockingState("0");
        level.setProgressBar(0);

        // 只有非1级才需要检查升级条件
        if (!grade.equals(1) && userMap.containsKey(grade + 1)) {
            boolean verified = ruleService.verifyUpgradeConditions(userId, String.valueOf(grade + 1));
            level.setProgressBar(verified ? 2 : 1);
            level.setUpgrade(verified);
        }

        // 检查降级记录
        if (liftingRecordService.selectDowngradeRecord(userId, grade, 0) > 0) {
            level.setUpgradeStatus(true);
        }
    }

    // 处理已注册用户的逻辑
    private void handleRegisteredUser(String userId, PartnerUser partnerUser, MyUserLevel level) {
        level.setUserId(userId);
        level.setUserName(partnerUser.getName());

        if (partnerUser.isIdentityStatus()) {
            handleActiveUser(partnerUser, level);
        } else {
            level.setLockingState("1");
        }

        level.setProgressBar(2);
    }

    // 处理活跃用户的逻辑
    private void handleActiveUser(PartnerUser partnerUser, MyUserLevel level) {
        level.setLockingState("2");
        level.setLockCommission(accountMapper.selectCashFee(partnerUser.getUserId(), partnerUser.getGrade()));
        Long difference = calculateTimeDifference(partnerUser.getUserId(), partnerUser.getGrade());
        level.setZeroDays(difference);
        Integer grade = partnerUser.getGrade();
        if (grade != 4){
            grade = grade + 1;
        }
        // 检查升级条件
        boolean verified = ruleService.verifyUpgradeConditions(
                partnerUser.getUserId(), String.valueOf(grade));
        level.setUpgrade(verified);

        // 检查降级记录
        if (liftingRecordService.selectDowngradeRecord(
                partnerUser.getUserId(), partnerUser.getGrade() + 1, 1) > 0) {
            level.setUpgradeStatus(true);
        }
    }

    public String getProportion(Integer grade){
        CommissionRulesVo rulesVo = commissionService.queryAll();
        if (grade == 1){
            return rulesVo.getOriginator();
        }else if (grade == 2){
            PartnerCommissionRules administrator = rulesVo.getAdministrator();

            List<PartnerRulesRatio> list = administrator.getRulesRatioList();
            return list.get(0).getKickback().stripTrailingZeros().toPlainString() + "-" + list.get(2).getKickback().stripTrailingZeros().toPlainString();
        }else if (grade == 3){
            PartnerCommissionRules partner = rulesVo.getPartner();

            List<PartnerRulesRatio> list = partner.getRulesRatioList();
            return list.get(0).getKickback().stripTrailingZeros().toPlainString() + "-" + list.get(2).getKickback().stripTrailingZeros().toPlainString();
        }else if (grade == 4){
            PartnerCommissionRules partner = rulesVo.getPartner();

            List<PartnerRulesRatio> list = partner.getRulesRatioList();
            return list.get(0).getKickback().stripTrailingZeros().toPlainString() + "-" + list.get(2).getKickback().stripTrailingZeros().toPlainString();
        }
        return "0";
    }


    @Override
    public void deleteByUserId(String id) {
        baseMapper.deleteByUserId(id);
    }

    @Override
    public HttpResult selectUser(AppHomeParams params) {
        return HttpResult.ok(baseMapper.selectUser(params));
    }

    public Integer queryLevel(Integer grade){
        if (!Objects.isNull(grade)){
            switch (grade){
                case 1:
                    return  2;
                case 2:
                    return 3;
                case 3:
                    return 4;
                case 4:
                    return 5;
            }
        }
        return 1;
    }

    public Map<Integer, String> getRule() {
        List<PartnerRule> partnerRules = ruleService.selectAll();
        Map<Integer, String> ruleMap = partnerRules.stream()
                .collect(Collectors.toMap(
                        PartnerRule::getGrade,
                        rule -> rule.getGradeName() != null ? rule.getGradeName() : "",
                        (existing, replacement) -> existing
                ));
        ruleMap.put(5, "团队长");
        ruleMap.put(6, "业务员");
        return ruleMap;
    }

    @Override
    public HttpResult userCountVo(AppHomeParams params) {
        return HttpResult.ok();
    }

    @Override
    public HttpResult selectByIdList(PartnerApp partnerApp) {
        if (StringUtils.isEmpty(partnerApp.getId())) {
            return HttpResult.error("ID不能为空");
        }
        PartnerUser partnerUser = baseMapper.selectById(partnerApp.getId());
        if (ObjectUtils.isEmpty(partnerUser)) {
            return HttpResult.error("人员不存在");
        }
        JSONObject referrerInfo = new JSONObject();
        referrerInfo.put("referrerGrade",baseMapper.selectByUserIdGrade(partnerUser.getUserId()));
        referrerInfo.put("referrerName",baseMapper.selectByUserIdUserName(partnerUser.getUserId()));
        referrerInfo.put("mobile",partnerUser.getMobile());
        referrerInfo.put("userName",partnerUser.getName());
        HashMap<String, Object> map = new HashMap<>();
        Page page = getLevelUser(partnerUser.getUserId(), partnerUser.getGrade(), partnerApp, getRule());
        map.put("list",getPage( page));
        map.put("referrer",referrerInfo);
        map.put("parentStatus",partnerUser.isIdentityStatus() ? "2" : "1");
        return HttpResult.ok(map);
    }


    @Override
    public HttpResult selectByGradeList(PartnerApp partnerApp) {
        if (StringUtils.isEmpty(partnerApp.getUserId()) || StringUtils.isEmpty(partnerApp.getGrade())) {
            return HttpResult.error("用户ID和等级不能为空");
        }
        AppHomeParams params = new AppHomeParams();
        params.setUserId(partnerApp.getUserId());
        List<TeamOverviewVo> teamOverviewVos = baseMapper.selectTeamOverview(params);
        List<Object> list = new ArrayList<>();
        Map<Integer, String> rule = getRule();
        List<String> grades = teamOverviewVos.stream()
                .map(TeamOverviewVo::getGrade)
                .distinct()
                .collect(Collectors.toList());
        List<PartnerUser> partnerUsers = baseMapper.selectList(new LambdaQueryWrapper<>(PartnerUser.class)
                .eq(PartnerUser::getUserId, partnerApp.getUserId())
                .in(PartnerUser::getGrade, grades));
        Map<Integer, PartnerUser> userMap = partnerUsers.stream()
                .collect(Collectors.toMap(PartnerUser::getGrade, Function.identity()));
        for (TeamOverviewVo overviewVo : teamOverviewVos) {
            JSONObject map = new JSONObject();
            map.put("grade",overviewVo.getGrade());
            map.put("gradeName",overviewVo.getGradeName());
            PartnerUser partnerUser = userMap.get(Integer.valueOf(overviewVo.getGrade()));
            HashMap<String, Object> hashMap = new HashMap<>();

            try {
                if (null == partnerUser) {
                    setDefaultValues(hashMap);
                    map.put("data", new JSONObject());
                    map.put("total", hashMap);
                    map.put("parentStatus", "0");
                } else {
                    Page page = getLevelUser(partnerUser.getUserId(), partnerUser.getGrade(), partnerApp, rule);

                    List<JSONObject> levelAllUser = getLevelAllUser(partnerUser.getUserId(), partnerUser.getGrade(), partnerApp, rule);
                    boolean hasRecords = CollectionUtil.isNotEmpty(levelAllUser);
                    hashMap.put("commission", hasRecords ? sumField(levelAllUser, "commission") : BigDecimal.ZERO);
                    hashMap.put("numberOrders", hasRecords ? levelAllUser.size() : 0);
                    hashMap.put("totalPremium", hasRecords ? sumField(levelAllUser, "premium") : BigDecimal.ZERO);

                    map.put("data", getPage(page));
                    map.put("total", hashMap);
                    map.put("parentStatus", partnerUser.isIdentityStatus() ? "2" : "1");
                    BigDecimal lockCommission = null;
                    Long zeroDays = null;
                    if (partnerUser.isIdentityStatus()){
                        lockCommission = accountMapper.selectCashFee(partnerUser.getUserId(), partnerUser.getGrade());
                        zeroDays = calculateTimeDifference(partnerUser.getUserId(), partnerUser.getGrade());
                    }
                    map.put("lockCommission",lockCommission);
                    map.put("zeroDays",zeroDays);
                    PartnerRuleEntity ruleEntity = partnerRuleService.selectByGrade(overviewVo.getGrade());
                    map.put("fallAmount",ruleEntity.getFallAmount());
                    getRule(overviewVo, partnerUser);

                    map.put("upgradeStatus", new JSONObject());
                }
            } catch (Exception e) {
                // 记录异常日志并跳过当前项
                log.error("处理团队概览数据时发生错误：{}",e.fillInStackTrace());
                continue;
            }

            list.add(map);
        }
        return HttpResult.ok(list);
    }


    public Long calculateTimeDifference(String userId,Integer grade){
        Date date = liftingRecordService.selectQueryDowngradeTime(userId, grade);
        if (null == date){
            return null;
        }
        LocalDate localDate = date.toInstant()
                .atZone(ZoneId.systemDefault())
                .toLocalDate().plusDays(expireDays);
        return PartnerDateUtils.dateDifference(localDate);
    }


    private void getRule(TeamOverviewVo overviewVo, PartnerUser partnerUser) {
        Integer grade = partnerUser.getGrade();
        if (grade != 4){
            grade = grade + 1;
        }
        boolean checked = partnerRuleService.verifyUpgradeConditions(partnerUser.getUserId(),String.valueOf(grade));
        overviewVo.setUpgradeStatus(checked ? 1 : 0);
        Long count = liftingRecordService.selectDowngradeRecord(partnerUser.getUserId(), partnerUser.getGrade(),1);
        if (count > 0){
            overviewVo.setUpgradeStatus(2);
        }
    }

    private void setDefaultValues(HashMap<String, Object> hashMap) {
        hashMap.put("commission", BigDecimal.ZERO);
        hashMap.put("numberOrders", BigDecimal.ZERO);
        hashMap.put("totalPremium", BigDecimal.ZERO);
    }


    public JSONObject getPage(Page page){
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("pageNum",page.getCurrent());
        jsonObject.put("records",page.getRecords());
        jsonObject.put("pageSize",page.getSize());
        jsonObject.put("totalSize",page.getTotal());
        jsonObject.put("totalPages",page.getPages());
        return jsonObject;
    }

    public static BigDecimal sumField(List<JSONObject> jsonList, String fieldName) {
        return jsonList.stream()
                .map(jsonObj -> {
                    try {
                        Object value = jsonObj.get(fieldName);
                        if (value instanceof BigDecimal) {
                            return (BigDecimal) value;
                        } else if (value instanceof Number) {
                            return BigDecimal.valueOf(((Number) value).doubleValue());
                        } else if (value instanceof String) {
                            return new BigDecimal((String) value);
                        }
                        return null;
                    } catch (Exception e) {
                        return null;
                    }
                })
                .filter(value -> value != null)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }


    @Override
    public Object myPerformance(PartnerApp partnerApp) {
        if (StringUtils.isBlank(partnerApp.getGrade())){
            return HttpResult.error("用户不能为空");
        }
        Page<JSONObject> page = baseMapper.queryDataList(partnerApp.getPage(),partnerApp);
        List<JSONObject> datalist = page.getRecords();
        HashMap<String, Object> hashMap = new HashMap<>();
        JSONObject totalMap = new JSONObject();
        totalMap.put("numberOrders",datalist.size());
        totalMap.put("totalPremium",sumField(datalist,"premium"));
        totalMap.put("commission",sumField(datalist,"commission"));
        hashMap.put("data",getPage(page));
        hashMap.put("total",totalMap);
        PartnerUser partnerUser = baseMapper.selectOne(new LambdaQueryWrapper<>(PartnerUser.class).eq(PartnerUser::getUserId,partnerApp.getUserId()).eq(PartnerUser::getGrade,partnerApp.getGrade()));
        if (null != partnerUser){
            hashMap.put("parentStatus",partnerUser.isIdentityStatus() ? "2" : "1");
            if (partnerUser.isIdentityStatus()){
                hashMap.put("lockData",isLockingState(partnerUser));
            }else {
                hashMap.put("lockData",null);
            }
        }else {
            hashMap.put("parentStatus", "1");
        }
        return hashMap;
    }

    public JSONObject isLockingState(PartnerUser partnerUser) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("lockCommission",new BigDecimal("126"));
        jsonObject.put("zeroDays",10);
        return jsonObject;
    }


    @Override
    public HttpResult myPerformanceDetails(String ordersNo,String userId) {


        List<PartnerPremiumDetails> details = detailsMapper.selectList(new LambdaQueryWrapper<>(PartnerPremiumDetails.class).eq(PartnerPremiumDetails::getOrderno, ordersNo)
                .eq(PartnerPremiumDetails::getUserId, userId).orderByAsc(PartnerPremiumDetails::getSource));

        PartnerPremiumDetails partnerPremiumDetails = new PartnerPremiumDetails();
        if (CollectionUtil.isNotEmpty( details)){
            partnerPremiumDetails = details.get(0);
        }
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("ordersNo",partnerPremiumDetails.getOrderno());
        jsonObject.put("carId",partnerPremiumDetails.getLicenseno());
        //收入类型
        jsonObject.put("incomeType",partnerPremiumDetails.getIndustrySector());
        //代理人
        jsonObject.put("agent",partnerPremiumDetails.getIssuerName());
        //所属团队
        jsonObject.put("belongingTeam",1);
        // 保费
        jsonObject.put("premium",partnerPremiumDetails.getSumpremium());
        BigDecimal reduce = details.stream().map(detail -> detail.getExtractFee()).reduce(BigDecimal.ZERO, BigDecimal::add);
        //佣金
        jsonObject.put("commission",reduce);
        //出单时间
        jsonObject.put("orderTime",partnerPremiumDetails.getCreateTime());
        //佣金比例
        jsonObject.put("commissionRatio",getObjects(details));
        return HttpResult.ok(jsonObject);
    }

    @Override
    public HttpResult avatarUpdate(PartnerUser partnerUser) {
        PartnerUser user = new PartnerUser();
        user.setPictureUrl(partnerUser.getPictureUrl());
        return baseMapper.update(user,new LambdaQueryWrapper<>(PartnerUser.class)
                .eq(PartnerUser::getUserId, partnerUser.getUserId())
        ) > 0 ? HttpResult.ok("保存成功") : HttpResult.error("保存失败");
    }

    @Override
    public HttpResult userCountStatisticsVo(AppHomeParams params) {
        Integer minGrade = baseMapper.selectGradeMin(params.getUserId());
        if (minGrade == null) {
            return HttpResult.error("人员不存在");
        }
        Map<Integer, String> rule = getRule();
        Map<String, Object> vo = new HashMap<>();
        vo.put("vo1", getV1(minGrade, params, rule));
        vo.put("vo2", getVo2(minGrade, params, rule));
        return HttpResult.ok(vo);
    }

    @Override
    public HttpResult userCountProportionVo(AppHomeParams params) {
        Integer minGrade = baseMapper.selectGradeMin(params.getUserId());
        if (minGrade == null) {
            return HttpResult.error("人员不存在");
        }
        Map<Integer, String> rule = getRule();
        List<JSONObject> vo3 = getVo3(minGrade, params, rule);
        return HttpResult.ok(vo3);
    }

    @Override
    public HttpResult userCountRankingVo(AppHomeParams params) {
        Integer minGrade = baseMapper.selectGradeMin(params.getUserId());
        if (minGrade == null) {
            return HttpResult.error("人员不存在");
        }
        Map<Integer, String> rule = getRule();
        List<JSONObject> vo4 = getVo4(minGrade, params, rule);
        return HttpResult.ok(vo4);
    }


    public List<JSONObject> getLevelAllUser(String userId, Integer grade, PartnerApp partnerApp, Map<Integer, String> rule){
        Integer sort = grade + 1;
        QueryWrapper<PartnerUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("p.referrer_id",userId);
        queryWrapper.eq("grade",sort);
        queryWrapper.eq("u.`status`",1);
        if (!Objects.isNull(partnerApp)){
            if (StringUtils.isNotEmpty(partnerApp.getStartTime()) && StringUtils.isNotEmpty(partnerApp.getEndTime())){
                queryWrapper.between("p.create_time", partnerApp.getStartTime() + " " + TimeConstants.START_TIME, partnerApp.getEndTime() + " " + TimeConstants.END_TIME);
            }
        }

        List<PartnerUser> partnerUsers = baseMapper.selectAllListVo(queryWrapper);
        // 添加空值检查
        if (CollectionUtil.isEmpty(partnerUsers)) {
            return  new ArrayList<>(0);
        }

        List<String> userIds = partnerUsers.stream().map(PartnerUser::getUserId).collect(Collectors.toList());

        // 使用参数绑定防止SQL注入，合并查询条件
        QueryWrapper<PartnerPremiumDetails> wrapper = new QueryWrapper<>();
        wrapper.in("user_id", userIds);
        wrapper.eq("source", sort);
        wrapper.groupBy("user_id");

        // 合并查询结果处理
        List<Map<String, Object>> resultMapList = detailsMapper.selectCombinedStatistics(wrapper);

        // 简化Map转换逻辑
        Map<String, BigDecimal> premiumMapDict = new HashMap<>();
        Map<String, BigDecimal> commissionMapDict = new HashMap<>();

        for (Map<String, Object> map : resultMapList) {
            String userIdTemp = String.valueOf(map.get("userId"));
            BigDecimal premium = new BigDecimal(String.valueOf(map.get("premium")));
            BigDecimal commission = new BigDecimal(String.valueOf(map.get("commission")));
            premiumMapDict.put(userIdTemp, premium);
            commissionMapDict.put(userIdTemp, commission);
        }
        List<JSONObject> jsonList = new ArrayList<>();
        for (PartnerUser partnerUser : partnerUsers) {
            JSONObject jsonObject = getJsonObject(rule, partnerUser);
            jsonObject.put("number", countByUserIdLevel(partnerUser.getUserId(),partnerUser.getGrade() + 1));
            String currentUserId = partnerUser.getUserId();
            jsonObject.put("premium", premiumMapDict.getOrDefault(currentUserId, BigDecimal.ZERO));
            jsonObject.put("commission", commissionMapDict.getOrDefault(currentUserId, BigDecimal.ZERO));
            jsonList.add(jsonObject);
        }
        List<JSONObject> sort1 = getSort(jsonList);
        return sort1;
    }

    public List<JSONObject> getLevelUserList(String userId,Integer grade,PartnerApp partnerApp, Map<Integer, String> rule){
        Integer sort = grade + 1;
        QueryWrapper<PartnerUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("p.referrer_id",userId);
        queryWrapper.eq("grade",sort);
        queryWrapper.eq("u.`status`",1);
        if (!Objects.isNull(partnerApp)){
            if (StringUtils.isNotEmpty(partnerApp.getStartTime()) && StringUtils.isNotEmpty(partnerApp.getEndTime())){
                queryWrapper.between("p.create_time", partnerApp.getStartTime() + " " + TimeConstants.START_TIME, partnerApp.getEndTime() + " " + TimeConstants.END_TIME);
            }
        }

        List<PartnerUser> list = baseMapper.selectListDb( queryWrapper);
        if (CollectionUtil.isEmpty(list)) {
            return  new ArrayList<>(0);
        }
        List<String> userIds = list.stream().map(PartnerUser::getUserId).collect(Collectors.toList());

        // 使用参数绑定防止SQL注入，合并查询条件
        QueryWrapper<PartnerPremiumDetails> wrapper = new QueryWrapper<>();
        wrapper.in("user_id", userIds);
        wrapper.eq("source", sort);
        wrapper.groupBy("user_id");

        // 合并查询结果处理
        List<Map<String, Object>> resultMapList = detailsMapper.selectCombinedStatistics(wrapper);

        // 简化Map转换逻辑
        Map<String, BigDecimal> premiumMapDict = new HashMap<>();
        Map<String, BigDecimal> commissionMapDict = new HashMap<>();

        for (Map<String, Object> map : resultMapList) {
            String userIdTemp = String.valueOf(map.get("userId"));
            BigDecimal premium = new BigDecimal(String.valueOf(map.get("premium")));
            BigDecimal commission = new BigDecimal(String.valueOf(map.get("commission")));
            premiumMapDict.put(userIdTemp, premium);
            commissionMapDict.put(userIdTemp, commission);
        }
        List<JSONObject> jsonList = new ArrayList<>();
        for (PartnerUser partnerUser : list) {
            JSONObject jsonObject = getJsonObject(rule, partnerUser);
            jsonObject.put("number", countByUserIdLevel(partnerUser.getUserId(),partnerUser.getGrade() + 1));
            String currentUserId = partnerUser.getUserId();
            jsonObject.put("premium", premiumMapDict.getOrDefault(currentUserId, BigDecimal.ZERO));
            jsonObject.put("commission", commissionMapDict.getOrDefault(currentUserId, BigDecimal.ZERO));
            jsonList.add(jsonObject);
        }
        List<JSONObject> sort1 = getSort(jsonList);
        return sort1;
    }

    public Page getLevelUser(String userId,Integer grade,PartnerApp partnerApp, Map<Integer, String> rule){
        Integer sort = grade + 1;
        QueryWrapper<PartnerUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("p.referrer_id",userId);
        queryWrapper.eq("grade",sort);
        queryWrapper.eq("u.`status`",1);
        if (!Objects.isNull(partnerApp)){
            if (StringUtils.isNotEmpty(partnerApp.getStartTime()) && StringUtils.isNotEmpty(partnerApp.getEndTime())){
                queryWrapper.between("p.create_time", partnerApp.getStartTime() + " " + TimeConstants.START_TIME, partnerApp.getEndTime() + " " + TimeConstants.END_TIME);
            }
        }

        Page page = baseMapper.selectListVo(partnerApp.getPage(), queryWrapper);
        List<PartnerUser> partnerUsers = page.getRecords();
        // 添加空值检查
        if (CollectionUtil.isEmpty(partnerUsers)) {
            return  page;
        }
        
        List<String> userIds = partnerUsers.stream().map(PartnerUser::getUserId).collect(Collectors.toList());
        
        // 使用参数绑定防止SQL注入，合并查询条件
        QueryWrapper<PartnerPremiumDetails> wrapper = new QueryWrapper<>();
        wrapper.in("user_id", userIds);
        wrapper.eq("source", sort);
        wrapper.groupBy("user_id");
        
        // 合并查询结果处理
        List<Map<String, Object>> resultMapList = detailsMapper.selectCombinedStatistics(wrapper);
        
        // 简化Map转换逻辑
        Map<String, BigDecimal> premiumMapDict = new HashMap<>();
        Map<String, BigDecimal> commissionMapDict = new HashMap<>();
        
        for (Map<String, Object> map : resultMapList) {
            String userIdTemp = String.valueOf(map.get("userId"));
            BigDecimal premium = new BigDecimal(String.valueOf(map.get("premium")));
            BigDecimal commission = new BigDecimal(String.valueOf(map.get("commission")));
            premiumMapDict.put(userIdTemp, premium);
            commissionMapDict.put(userIdTemp, commission);
        }
        List<JSONObject> jsonList = new ArrayList<>();
        for (PartnerUser partnerUser : partnerUsers) {
            JSONObject jsonObject = getJsonObject(rule, partnerUser);
            jsonObject.put("number", countByUserIdLevel(partnerUser.getUserId(),partnerUser.getGrade() + 1));
            String currentUserId = partnerUser.getUserId();
            jsonObject.put("premium", premiumMapDict.getOrDefault(currentUserId, BigDecimal.ZERO));
            jsonObject.put("commission", commissionMapDict.getOrDefault(currentUserId, BigDecimal.ZERO));
            jsonList.add(jsonObject);
        }
        List<JSONObject> sort1 = getSort(jsonList);
        return page.setRecords(sort1);
    }

    public BigDecimal getValue(String targetKey, List<Map<String, Object>> list){
        if (targetKey == null || list == null) {
            return BigDecimal.ZERO;
        }
        return list.stream()
                .filter(map -> StringUtils.equals(targetKey, String.valueOf(map.get("userId"))))
                .findFirst()
                .map(map -> new BigDecimal(String.valueOf(map.get("num"))))
                .orElse(BigDecimal.ZERO);
    }

    @Override
    public boolean selectByUserIdList(String id) {
        List<PartnerUser> partnerUsers = baseMapper.selectList(new LambdaQueryWrapper<>(PartnerUser.class).eq(PartnerUser::getUserId, id));
        for (PartnerUser partnerUser : partnerUsers) {
            if (partnerUser.getGrade() > 4){
                return false;
            }
        }


        return CollectionUtil.isNotEmpty(partnerUsers) ? true : false;
    }

    @Override
    public AppUserInfoVo getUserInfo(Integer type) {
        String userId = BaseController.getUserId();
        AppUserInfoVo appUserInfoVo = sysUserMapper.queryByUserId(userId);
        Integer min = baseMapper.selectGradeIntMin(userId);
        if (null != min){
            PartnerUser partnerUser = baseMapper.selectOne(new LambdaQueryWrapper<>(PartnerUser.class)
                    .eq(PartnerUser::getUserId, userId)
                    .eq(PartnerUser::getGrade, min));
            InsUploadFiles insUploadFiles = uploadFilesMapper.selectById(partnerUser.getPictureUrl());
            appUserInfoVo.setInsUploadFiles(insUploadFiles);
        }else {
            appUserInfoVo.setInsUploadFiles(new InsUploadFiles());
        }
        appUserInfoVo.setGrade(null == min ? 4 : min);
        return appUserInfoVo;
    }



    public List<JSONObject> getSort(List<JSONObject> list) {
        return list.stream()
                .sorted(Comparator.comparing(
                                jo -> parseSortField(JSONObject.parseObject(jo.toString())),
                                Comparator.nullsLast(Comparator.naturalOrder()))
                        .thenComparing(
                                jo -> parseCreateTime(JSONObject.parseObject(jo.toString())),
                                Comparator.nullsFirst(Comparator.naturalOrder())))
                .collect(Collectors.toList());
    }

    private static Integer parseSortField(JSONObject obj) {
        if (obj == null) {
            return 0;
        }
        Object value = obj.get("grade");
        if (value instanceof Number) {
            return ((Number) value).intValue();
        } else if (value instanceof String) {
            try {
                return Integer.parseInt(value.toString());
            } catch (NumberFormatException e) {
                return 0;
            }
        }
        return 0;
    }

    private static LocalDateTime parseCreateTime(JSONObject obj) {
        if (obj == null) {
            return LocalDateTime.MIN;
        }
        Object valueObj = obj.get("createTime");
        if (valueObj == null) {
            return LocalDateTime.MIN;
        }

        String value = valueObj.toString().trim();
        if (value.isEmpty()) {
            return LocalDateTime.MIN;
        }

        try {
            long epochSecond = Long.parseLong(value);
            return LocalDateTime.ofInstant(Instant.ofEpochSecond(epochSecond), ZoneId.systemDefault());
        } catch (NumberFormatException e) {
            return LocalDateTime.MIN;
        }
    }


    private JSONObject getJsonObject(Map<Integer, String> rule, PartnerUser partnerUser) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("id",partnerUser.getId());
        jsonObject.put("userName", partnerUser.getName());
        jsonObject.put("grade", partnerUser.getGrade());
        jsonObject.put("createTime", partnerUser.getCreateTime());
        jsonObject.put("gradeName", "他的" + rule.getOrDefault(Integer.valueOf(partnerUser.getGrade() + 1), ""));
        return jsonObject;
    }

    public Long countByUserIdLevel(String userId,Integer grade){
        if (Objects.isNull(userId)){
            return Long.parseLong("0");
        }
        return baseMapper.selectCount(new LambdaQueryWrapper<PartnerUser>().eq(PartnerUser::getReferrerId, userId).eq(PartnerUser::getGrade, grade));
    }



    public List<JSONObject> getVo4(Integer minGrade, AppHomeParams params, Map<Integer, String> rule) {
        Integer grade = queryLevel(minGrade);
        List<JSONObject> list = new ArrayList<>();
        List<String> currentUserIds = new ArrayList<>();
        currentUserIds.add(params.getUserId());

        while (grade < 7) {
            List<PartnerUser> currentUserList = new ArrayList<>();
            if (CollectionUtil.isNotEmpty(currentUserIds)) {
                currentUserList = baseMapper.selectJuniorListUser(grade, currentUserIds, params);
                currentUserIds = currentUserList.stream().map(PartnerUser::getUserId).collect(Collectors.toList());
            }
            getVo4Data(list, grade, currentUserList, params, rule);
            grade++;
        }
        return list;
    }

    public void getVo4Data(List<JSONObject> list, int grade, List<PartnerUser> currentUser, AppHomeParams params, Map<Integer, String> rule) {
        JSONObject object = new JSONObject();
        object.put("grade", grade);
        object.put("gradeName", rule.getOrDefault(grade, ""));
        List<JSONObject> arrayList = new ArrayList<>();

        for (PartnerUser user : currentUser) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("id", user.getId());
            jsonObject.put("userName", user.getName());
            jsonObject.put("number", baseMapper.userCountVo(user.getUserId(), params,(user.getGrade() + 1)));
            arrayList.add(jsonObject);
        }

        arrayList.sort((o1, o2) -> o2.getString("number").compareTo(o1.getString("number")));
        object.put("data", arrayList);
        list.add(object);
    }

    public List<JSONObject> getVo3(Integer minGrade, AppHomeParams params, Map<Integer, String> rule) {
        Integer grade = queryLevel(minGrade);
        List<JSONObject> list = new ArrayList<>();
        List<String> currentUserIds = new ArrayList<>();
        currentUserIds.add(params.getUserId());

        while (grade < 7) {
            if (CollectionUtil.isNotEmpty(currentUserIds)) {
                currentUserIds = baseMapper.selectJuniorList(grade, currentUserIds, params);
            }
            getVo3Data(list, grade, currentUserIds, params, rule);
            grade++;
        }
        return list;
    }

    public void getVo3Data(List<JSONObject> list, int grade, List<String> currentUserIds, AppHomeParams params, Map<Integer, String> rule) {
        JSONObject object = new JSONObject();
        object.put("grade", grade);
        object.put("gradeName", rule.getOrDefault(grade, ""));

        Integer newNum = baseMapper.userCountIdsVo(currentUserIds, params);
        Integer number = baseMapper.userCountIdsVo(currentUserIds, null);


        JSONObject jsonObject = new JSONObject();
        //新增数量
        jsonObject.put("newNum", newNum);
        //总数量
        jsonObject.put("number", number);
        //新增占比
        jsonObject.put("newProportion", calculatePrecisePercentage(getToInt(newNum),getToInt(number)));
        //历史占比
        jsonObject.put("oldProportion",calculatePrecisePercentage(BigDecimal.valueOf(number).subtract(BigDecimal.valueOf(newNum)),getToInt(number)));
        object.put("data", jsonObject);
        list.add(object);
    }


    public static BigDecimal getToInt(Integer intValue){
        return Optional.ofNullable(intValue)
                .map(BigDecimal::valueOf)
                .orElse(BigDecimal.ZERO);
    }

    public static String calculatePrecisePercentage(BigDecimal part, BigDecimal total) {
        if (total.compareTo(BigDecimal.ZERO) == 0) {
            return "0";
        }
        BigDecimal ratio = part.divide(total, 4, RoundingMode.HALF_UP) // 保留4位小数
                .multiply(BigDecimal.valueOf(100))
                .setScale(2, RoundingMode.DOWN); // 最终保留两位小数
        return ratio + "%";
    }


    public List<Map<String, Object>> getVo2(Integer minGrade, AppHomeParams params, Map<Integer, String> rule) {
        Integer grade = queryLevel(minGrade);
        List<Map<String, Object>> list = new ArrayList<>();
        List<String> currentUserIds = new ArrayList<>();
        currentUserIds.add(params.getUserId());
        while (grade < 7) {
            if (CollectionUtil.isNotEmpty(currentUserIds)) {
                currentUserIds = baseMapper.selectJuniorList(grade, currentUserIds, params);
            }
            processGradeVo2(list, grade, currentUserIds, params, rule);
            grade++;
        }
        return list;
    }

    public void processGradeVo2(List<Map<String, Object>> list, int grade, List<String> currentUserIds, AppHomeParams params, Map<Integer, String> rule) {
        Map<String, Object> voMap = new HashMap<>();
        voMap.put("grade", grade);
        voMap.put("gradeName", rule.getOrDefault(grade, ""));
        List<Map<String, String>> maps = new ArrayList<>(0);
        if (CollectionUtil.isNotEmpty(currentUserIds)){
            maps = baseMapper.userCountVo2(currentUserIds, params);
        }
        List<String> keys = new ArrayList<>();
        List<String> values = new ArrayList<>();
        for (Map<String, String> map : maps) {
            for (Map.Entry<String, String> entry : map.entrySet()) {
                if ("total".equals(entry.getKey())){
                    keys.add(String.valueOf(entry.getValue()));
                }else if ("createTime".equals(entry.getKey())){
                    values.add(String.valueOf(entry.getValue()));
                }
            }
        }
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("dataTime",values);
        jsonObject.put("data",keys);
        voMap.put("data", jsonObject);
        list.add(voMap);
    }

    public List<Map<String, Object>> getV1(Integer minGrade, AppHomeParams params, Map<Integer, String> rule) {
        Integer grade = queryLevel(minGrade);
        List<Map<String, Object>> list = new ArrayList<>();
        List<String> currentUserIds = new ArrayList<>();
        currentUserIds.add(params.getUserId());

        while (grade < 7) {
            if (CollectionUtil.isNotEmpty(currentUserIds)) {
                currentUserIds = baseMapper.selectJuniorList(grade, currentUserIds,params);
            }
            processGrade(list, grade, currentUserIds,rule,params);
            grade++;
        }
        return list;
    }

    public void processGrade(List<Map<String, Object>> list, int grade, List<String> currentUserIds, Map<Integer, String> rule,AppHomeParams params) {
        Map<String, Object> map = new HashMap<>();
        map.put("grade", grade);
        map.put("gradeName", rule.getOrDefault(grade, ""));
        map.put("count", currentUserIds.size());
        list.add(map);
    }



    @Override
    public HttpResult myCommissionRate(String userId) {

        List<PartnerUser> partnerUsers = baseMapper.selectList(new LambdaQueryWrapper<>(PartnerUser.class).eq(PartnerUser::getUserId, userId));
        if (CollectionUtil.isEmpty(partnerUsers)){
            return HttpResult.error("用户无权益信息");
        }
        BigDecimal totalAmountSafe = BigDecimal.ZERO;
//        for (PartnerUser partnerUser : partnerUsers) {
//            BigDecimal bigDecimal = CalculateCommissionUtils.calculateCommission(String.valueOf(partnerUser.getGrade()),partnerUser.getUserId(),"");
//            totalAmountSafe = totalAmountSafe.add(bigDecimal);
//        }
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("totalRate",totalAmountSafe);

        Map<Integer, String> rule = getRule();

        ArrayList<Object> list = new ArrayList<>();
        for (PartnerUser user : partnerUsers) {
            JSONObject object = new JSONObject();
            object.put("grade",user.getGrade());
            object.put("gradeName",rule.getOrDefault(user.getGrade(),""));
            object.put("commissionRate","");
            list.add(object);
        }
        jsonObject.put("data",list);
        return HttpResult.ok(jsonObject);
    }

    @Override
    public List<PartnerUser> selectByUserId(String userId) {
        return baseMapper.selectList(new LambdaQueryWrapper<>(PartnerUser.class).eq(PartnerUser::getUserId, userId));
    }

    @Override
    public PartnerUser selectByUserIdAndGrade(String referrerId, Integer grade) {
        return baseMapper.selectOne(new LambdaQueryWrapper<>(PartnerUser.class)
                .eq(PartnerUser::getUserId, referrerId).eq(PartnerUser::getGrade, grade));
    }

    @Override
    public PartnerPartnerAccount newGetFee(String userId) {
        PartnerPartnerAccount account = partnerPartnerAccountMapper.selectByUserId(userId);
        BigDecimal invalid = expiredCommissionMapper.selectCountInvalid(userId);
        if (null != invalid && invalid.compareTo(BigDecimal.ZERO) != 0){
            account.setCashFee(account.getCashFee().subtract(invalid));
        }
        return account;
    }

    private static List<JSONObject> getObjects(List<PartnerPremiumDetails> details) {
        List<JSONObject> list = new ArrayList<>();
        for (PartnerPremiumDetails detail : details) {
            if (detail == null) {
                continue;
            }
            JSONObject object = new JSONObject();
            int source = detail.getSource();
            String grade;
            switch (source) {
                case 1:
                    grade = "我的创始人佣金";
                    break;
                case 2:
                    grade = "我的管理人佣金";
                    break;
                case 3:
                    grade = "我的合伙人佣金";
                    break;
                case 4:
                    grade = "我的工作室佣金";
                    break;
                default:
                    grade = null;
                    break;
            }
            if (grade == null) {
                continue;
            }
            object.put("grade", grade);
            object.put("commission", String.format("%s*%s=%s",detail.getSumpremium(), detail.getProportional(), detail.getExtractFee()));
            list.add(object);
        }
        return list;
    }
}