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.LocalDateTime;
import java.time.ZoneId;
import java.util.*;
import cn.hutool.core.bean.BeanUtil;
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.controller.SysUserController;
import com.ydtech.modules.admin.dao.SysPartnerConfigMapper;
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.model.vo.SysUser2Vo;
import com.ydtech.modules.base.controller.BaseController;
import com.ydtech.modules.esm.dao.EsmUserImageMapper;
import com.ydtech.modules.esm.model.EsmUserImage;
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.CalculateCommissionUtils;
import com.ydtech.modules.partner.dao.PartnerLiftingRecordMapper;
import com.ydtech.modules.partner.dao.PartnerPartnerAccountMapper;
import com.ydtech.modules.partner.dao.PartnerPremiumDetailsMapper;
import com.ydtech.modules.partner.dao.PartnerUserMapper;
import com.ydtech.modules.partner.model.*;
import com.ydtech.modules.partner.model.param.AppHomeParams;
import com.ydtech.modules.partner.model.param.PartnerRuleEntity;
import com.ydtech.modules.partner.model.param.QueryVo;
import com.ydtech.modules.partner.model.param.UserGradeParam;
import com.ydtech.modules.partner.model.vo.*;
import com.ydtech.modules.partner.service.PartnerLiftingRecordService;
import com.ydtech.modules.partner.service.PartnerRuleService;
import com.ydtech.modules.partner.service.PartnerUserService;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static net.sf.jsqlparser.parser.feature.Feature.values;

@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;

    @Override
    public int insert(PartnerUser partnerUser) {
        return baseMapper.insert(partnerUser);
    }

    @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.selectGradeIntMin(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);
    }


    public void querySubordinates(List<PartnerUser> list,  PartnerUser partnerUser){
        while (partnerUser != null && StringUtils.isNotBlank(partnerUser.getUserId())) {
            PartnerUser one = baseMapper.selectOne(new LambdaQueryWrapper<>(PartnerUser.class).eq(PartnerUser::getReferrerId, partnerUser.getUserId()));
            list.add(one);
            querySubordinates( list,one);
        }
    }


    @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("1",userGradeParam.getGrade())){
            return HttpResult.error("当前用户无法升级");
        }
        QueryWrapper<PartnerLiftingRecord> wrapper = new QueryWrapper<>();
        wrapper.eq("user_id",userGradeParam.getId());
        wrapper.eq("audit_status",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);
        //   条件
        PartnerRuleEntity ruleEntity = ruleService.selectByGrade(userGradeParam.getGrade());
        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());
        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.setCycle(getMessage(ruleEntity));
        record.setUpgradeStrategy(ruleService.verifyUpgradeConditionsMessage(userGradeParam.getId(),userGradeParam.getGrade()));
        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);
        for (TeamOverviewVo overviewVo : teamOverviewVos) {
            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;
            }
        }
        homeVo.setTeamOverview(teamOverviewVos);
        return HttpResult.ok(homeVo);
    }


    @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) {
                            PartnerUser partnerUser = new PartnerUser();
                            partnerUser.setName(sysUser.getName());
                            partnerUser.setMobile(sysUser.getMobile());
                            partnerUser.setUserId(sysUser.getId());
                            partnerUser.setDeptId(sysUser.getDeptId());
                            partnerUser.setDeptName(sysUser.getDeptName());
                            partnerUser.setGrade(Integer.valueOf(s));
                            partnerUser.setReferrerId(partnerUsers.getUserId());
                            baseMapper.insert(partnerUser);
//                        if (StringUtils.equals("4",s)){
//                            sysUser.setGrade(4);
//                            SysUser2Vo sysUser2Vo = getUser2Vo(sysUser,partnerUser.getUserId());
//                            SpringUtil.getBean(SysUserController.class).newSaveUserInfoByPartner(sysUser2Vo);
//                        }
                        }
                    }
                }
            }
        }catch (Exception e){
            log.error("添加失败",e);
            return HttpResult.error();
        }
        return HttpResult.ok("添加成功");
    }

    private static SysUser2Vo getUser2Vo(SysUser sysUser,String id) {
        SysUser2Vo sysUser2Vo = new SysUser2Vo();
        SysUser user = new SysUser();
        user.setName(sysUser.getName());
        user.setMobile(sysUser.getMobile());
        user.setIdentity(sysUser.getIdentity());
        user.setPassword(sysUser.getPassword());
        user.setRoleId("21");
        user.setReferrerId(id);
        user.setDeptSource("2");
        user.setGrade(4);
        sysUser2Vo.setSysUser( user);
        return sysUser2Vo;
    }

    public static boolean containsOnlyId(List<String> list, String targetId) {
        return list != null
                && !list.isEmpty()
                && list.stream().allMatch(targetId::equals);
    }


    @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) {
       /* PartnerUser 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));
        vo.put("vo3", getVo3(minGrade, params, rule));
        vo.put("vo4", getVo4(minGrade, params, rule));*/
        return HttpResult.ok();
    }


    /**
     *


     List<Student> sortedList = list.stream()
     .sorted(
     Comparator.comparing(Student::getSort)                     // 按 sort 升序
     .thenComparing(
     Student::getCreateTime,
     Comparator.nullsFirst(Comparator.reverseOrder())     // 创建时间降序，空值优先
     )
     )
     .collect(Collectors.toList());


     *
     *
     */

    @Override
    public HttpResult selectByIdList(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 = new ArrayList<>();
        getLevelData(partnerUser.getUserId(),partnerUser.getGrade(),list, getRule());
        map.put("list",list);
        map.put("referrer",referrerInfo);
        return HttpResult.ok(map);
    }

    public void getLevelData(String userId,Integer grade, List<JSONObject> list,Map<Integer, String> rule){
        LambdaQueryWrapper<PartnerUser> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PartnerUser::getReferrerId,userId);
        queryWrapper.eq(PartnerUser::getGrade,grade + 1);
        List<PartnerUser> partnerUsers = baseMapper.selectList(queryWrapper);
        for (PartnerUser partnerUser : partnerUsers) {
            JSONObject jsonObject = getJsonObject(rule, partnerUser);
            jsonObject.put("number", baseMapper.userCountVo(partnerUser.getUserId(), null,partnerUser.getGrade()));
            list.add(jsonObject);
        }
    }



    @Override
    public HttpResult selectByGradeList(Map<String,String> paeramsMap, String userId) {
        if (StringUtils.isEmpty(userId) || StringUtils.isEmpty(paeramsMap.get("grade"))) {
            return HttpResult.error("用户ID和等级不能为空");
        }
        AppHomeParams params = new AppHomeParams();
        params.setUserId(userId);
        List<TeamOverviewVo> teamOverviewVos = baseMapper.selectTeamOverview(params);
        List<Object> list = new ArrayList<>();
        Map<Integer, String> rule = getRule();

        for (TeamOverviewVo overviewVo : teamOverviewVos) {
            HashMap<String, Object> map = new HashMap<>();
            map.put("grade",overviewVo.getGrade());
            map.put("gradeName",overviewVo.getGradeName());
            PartnerUser partnerUser = baseMapper.selectOne(new LambdaQueryWrapper<>(PartnerUser.class)
                    .eq(PartnerUser::getUserId, userId)
                    .eq(PartnerUser::getGrade, overviewVo.getGrade()));
            List<JSONObject> object = new ArrayList<>();
            if (ObjectUtils.isNotEmpty(partnerUser)) {
                List<JSONObject> jsonList = new ArrayList<>();
                object = buildUserHierarchyResult(partnerUser.getUserId(),partnerUser.getGrade(),paeramsMap,rule,jsonList);
            }
            HashMap<String, Object> hashMap = new HashMap<>();
            hashMap.put("commission",sumField(object,"commission"));
            hashMap.put("numberOrders",object.size());
            hashMap.put("totalPremium",sumField(object,"premium"));
            map.put("data",object);
            map.put("total",hashMap);
            list.add(map);
        }
        return HttpResult.ok(list);
    }


    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(Map<String, String> map) {
        if (StringUtils.isBlank(map.get("grade"))){
            return HttpResult.error("用户不能为空");
        }
        List<JSONObject> datalist = baseMapper.queryDataList(map);
        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",datalist);
        hashMap.put("total",totalMap);
        return hashMap;
    }

    @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);
    }


    private List<JSONObject> buildUserHierarchyResult(String userId,Integer grade, Map<String,String> paeramsMap
            ,Map<Integer, String> rule,List<JSONObject> jsonList) {
        getLevelUser(userId,grade,jsonList, rule,paeramsMap);
        return  getSort(jsonList);
    }


    public void getLevelUser(String userId,Integer grade, List<JSONObject> list,Map<Integer, String> rule,Map<String,String> paeramsMap){
        Integer sort = grade + 1;
        LambdaQueryWrapper<PartnerUser> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PartnerUser::getReferrerId,userId);
        queryWrapper.eq(PartnerUser::getGrade,sort);
        if (CollectionUtil.isNotEmpty(paeramsMap)){
            if (paeramsMap.containsKey("startTime") && StringUtils.isNotEmpty(paeramsMap.get("startTime"))){
                queryWrapper.ge(PartnerUser::getCreateTime, paeramsMap.get("startTime") + " " + TimeConstants.START_TIME);
            }
            if (paeramsMap.containsKey("endTime") && StringUtils.isNotEmpty(paeramsMap.get("endTime"))){
                queryWrapper.le(PartnerUser::getCreateTime, paeramsMap.get("endTime") + " " + TimeConstants.END_TIME);
            }
            if (StringUtils.isNotEmpty(paeramsMap.get("startTime")) && StringUtils.isNotEmpty(paeramsMap.get("endTime"))){
                queryWrapper.between(PartnerUser::getCreateTime, paeramsMap.get("startTime") + " " + TimeConstants.START_TIME, paeramsMap.get("endTime") + " " + TimeConstants.END_TIME);
            }
        }

        List<PartnerUser> partnerUsers = baseMapper.selectList(queryWrapper);
        
        // 添加空值检查
        if (CollectionUtil.isEmpty(partnerUsers)) {
            return;
        }
        
        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);
        }
        for (PartnerUser partnerUser : partnerUsers) {
            JSONObject jsonObject = getJsonObject(rule, partnerUser);
            jsonObject.put("number", countByUserIdLevel(partnerUser.getUserId()));
            String currentUserId = partnerUser.getUserId();
            jsonObject.put("premium", premiumMapDict.getOrDefault(currentUserId, BigDecimal.ZERO));
            jsonObject.put("commission", commissionMapDict.getOrDefault(currentUserId, BigDecimal.ZERO));
            list.add(jsonObject);
        }
    }

    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);
        appUserInfoVo.setGrade(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);
        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){
        if (Objects.isNull(userId)){
            return Long.parseLong("0");
        }
        return baseMapper.selectCount(new LambdaQueryWrapper<PartnerUser>().eq(PartnerUser::getReferrerId, userId));
    }



    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);
        }


//        Map<String, Integer> mergedMap = arrayList.stream()
//                .flatMap(map -> map.entrySet().stream())
//                .collect(Collectors.toMap(
//                        Map.Entry::getKey,
//                        Map.Entry::getValue,
//                        Integer::sum
//                ));
//        for (Map.Entry<String, Integer> entry : mergedMap.entrySet()) {
//            Integer value = entry.getValue();
//        }
        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",CalculateCommissionUtils.calculateCommission(String.valueOf(user.getGrade()),user.getUserId(),""));
            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) {
        return partnerPartnerAccountMapper.selectByUserId(userId);
    }

    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;
    }
}