湖北水库：工程项目树数量修改

shenyijian

2024-08-30 44d30cbd79df473dbdf6d28decde2bbc931c0821

 skjcmanager/skjcmanager-service/skjcmanager-sm/src/main/java/cn/gistack/sm/sg/service/impl/SgProjectInfoServiceImpl.java

@@ -10,21 +10,18 @@
import cn.gistack.sm.sg.service.SgProjectInfoService;
import cn.gistack.sm.sjztmd.entity.AttAdBase;
import cn.gistack.sm.sjztmd.service.IAttAdBaseService;
import cn.hutool.core.lang.copier.Copier;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jetbrains.annotations.NotNull;
import org.springblade.core.secure.utils.AuthUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StopWatch;

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.*;
import java.util.function.Function;
@@ -52,18 +49,100 @@
   private SgGxStepMapper sgGxStepMapper;

   @Override
   public IPage<SgProjectInfoDO> queryPageList(IPage<SgProjectInfoDO> page, ProjectSearchDTO searchDTO) {
      List<SgProjectInfoDO> sgProjectInfoDOS = baseMapper.queryPageList(page,searchDTO);
      List<SgProjectInfoDO> projectProgress = getProjectProgress(sgProjectInfoMapper.queryStepByProject(searchDTO));
      if (CollectionUtils.isNotEmpty(projectProgress)){
         Map<Long, String> progressMap = projectProgress.stream().filter(s->s.getProjectProgress()!=null).collect(Collectors.toMap(SgProjectInfoDO::getId, SgProjectInfoDO::getProjectProgress));
   public Object queryPageList(IPage<SgProjectInfoDO> page, ProjectSearchDTO searchDTO) {
      List<String> sgCodeS = getSgCodeByUser();
      searchDTO.setSgCodeS(sgCodeS);
      Boolean isPage = searchDTO.getIsPage();
      if (isPage==null) isPage = true;
      if (isPage ){
         List<SgProjectInfoDO> sgProjectInfoDOS = baseMapper.queryPageList(page,searchDTO);
         List<SgProjectInfoDO> projectProgress = getProjectProgress(sgProjectInfoMapper.queryStepByProject(searchDTO));
         if (CollectionUtils.isNotEmpty(projectProgress)){
            Map<Long, String> progressMap = projectProgress.stream().filter(s->s.getProjectProgress()!=null).collect(Collectors.toMap(SgProjectInfoDO::getId, SgProjectInfoDO::getProjectProgress));
            sgProjectInfoDOS.forEach(s->{
               s.setProjectProgress(progressMap.get(s.getId()));
            });
         }
         return page.setRecords(sgProjectInfoDOS);
      }else {
         List<SgAllDeptOrUser> allDepts = sgProjectInfoMapper.queryDept();
         Map<Long, String> deptMap = allDepts.stream().collect(Collectors.toMap(SgAllDeptOrUser::getId, SgAllDeptOrUser::getName));
         List<SgAllDeptOrUser> allUser = sgProjectInfoMapper.queryUser();
         Map<Long, String> userMap = allUser.stream().collect(Collectors.toMap(SgAllDeptOrUser::getId, SgAllDeptOrUser::getName));
         List<SgProjectInfoDO> sgProjectInfoDOS = baseMapper.queryPageList(null,searchDTO);
         List<SgProjectInfoDO> projectProgress = getProjectProgress(sgProjectInfoMapper.queryStepByProject(searchDTO));
         if (CollectionUtils.isNotEmpty(projectProgress)){
            Map<Long, String> progressMap = projectProgress.stream().filter(s->s.getProjectProgress()!=null).collect(Collectors.toMap(SgProjectInfoDO::getId, SgProjectInfoDO::getProjectProgress));
            sgProjectInfoDOS.forEach(s->{
               s.setProjectProgress(progressMap.get(s.getId()));
            });
         }
         sgProjectInfoDOS.forEach(s->{
            s.setProjectProgress(progressMap.get(s.getId()));
            //土建
            if (StringUtils.isNotBlank(s.getConstructionUnit())){
               s.setConstructionUnit(deptMap.get(Long.valueOf(s.getConstructionUnit())));
            }
            s.setConstructionPerson(getUserNames(userMap, s.getConstructionPerson()));

            //设备
            if (StringUtils.isNotBlank(s.getSelfUnit())){
               s.setSelfUnit(deptMap.get(Long.valueOf(s.getSelfUnit())));
            }
            s.setSelfPerson(getUserNames(userMap, s.getSelfPerson()));

            //设计
            if (StringUtils.isNotBlank(s.getDesignUnit())){
               s.setDesignUnit(deptMap.get(Long.valueOf(s.getDesignUnit())));
            }
            s.setDesignPerson(getUserNames(userMap, s.getDesignPerson()));

            //监理
            if (StringUtils.isNotBlank(s.getControlUnit())){
               s.setControlUnit(deptMap.get(Long.valueOf(s.getControlUnit())));
            }
            s.setControlPerson(getUserNames(userMap, s.getControlPerson()));

            //检测
            if (StringUtils.isNotBlank(s.getAcceptanceUnit())){
               s.setAcceptanceUnit(deptMap.get(Long.valueOf(s.getAcceptanceUnit())));
            }
            s.setAcceptancePerson(getUserNames(userMap, s.getAcceptancePerson()));
         });
         return sgProjectInfoDOS;
      }
      return page.setRecords(sgProjectInfoDOS);

   }

   /**
    * 获取用户姓名
    * @param userMap
    * @return
    */
   private  String getUserNames(Map<Long, String> userMap,String person ) {
      String userNames = "";
      if (StringUtils.isNotBlank(person)){
         // 使用Stream API来处理分割和映射
          userNames = Arrays.stream(person.split(",")) // 将字符串按逗号分割成数组，并转为Stream
            .map(Long::valueOf) // 将每个字符串元素转换为Long
            .map(userMap::get) // 使用userMap将Long映射为对应的用户名
            .collect(Collectors.joining(",")); // 使用逗号将用户名拼接成一个字符串
         return userNames;
      }
      return userNames;
   }

   /**
    * 获取当前用户的工程编码
    */
   public List<String> getSgCodeByUser(){
      Long userId = AuthUtil.getUserId();
      String sgCode =  sgProjectInfoMapper.getSgCodeByUser(userId.toString());
      if (StringUtils.isNotBlank(sgCode)){
         List<String> list = List.of(sgCode.split(","));
         return list;
      }
      return null;
   }
   /**
    * 获取项目及项目下设备及设备下工序进度
    * @param searchDTO
@@ -90,7 +169,7 @@
    * @return
    */
   @NotNull
   private List<SgProjectInfoDO> getProjectProgress(List<SgProjectInfoVO> list) {
   public List<SgProjectInfoDO> getProjectProgress(List<SgProjectInfoVO> list) {
      //项目分组
      Map<Long, List<SgProjectInfoVO>> projectMap = list.stream().collect(Collectors.groupingBy(SgProjectInfoVO::getId));
      List<SgProjectInfoDO> result = new ArrayList<>();
@@ -103,54 +182,72 @@
         }
         SgProjectInfoVO sgProjectInfoVO = value.get(0);
         SgProjectInfoDO sgProjectInfoDO = SgProjectInfoDO.builder().id(porId).lonLat(sgProjectInfoVO.getLonLat()).status(sgProjectInfoVO.getProjectStatus()).projectName(sgProjectInfoVO.getProjectName()).build();
         List<SgTypeVO> sgGxDOS = new ArrayList<>();
         //类型分组
         Map<String, List<SgProjectInfoVO>> GxMap = value.stream().filter(s->s.getDeviceType()!=null).collect(Collectors.groupingBy(SgProjectInfoVO::getDeviceType));
         for (Map.Entry<String, List<SgProjectInfoVO>> ty : GxMap.entrySet()) {
            String type = ty.getKey();
            List<SgProjectInfoVO> gxList = ty.getValue();
            if (CollectionUtils.isEmpty(gxList)){
         //父类型分组
         List<PtypeVO> pTypes = new ArrayList();
         Map<String, List<SgProjectInfoVO>> pTypeMap = value.stream().filter(s->s.getPtype()!=null).collect(Collectors.groupingBy(SgProjectInfoVO::getPtype));
         for (Map.Entry<String, List<SgProjectInfoVO>> pty : pTypeMap.entrySet()) {
            List<SgProjectInfoVO> ptyValue = pty.getValue();
            if (CollectionUtils.isEmpty(ptyValue)){
               continue;
            }
            SgTypeVO typeVO = SgTypeVO.builder().typeName(gxList.get(0).getTypeName()).build();
            List<SgDeviceDO> deviceDOS = new ArrayList<>();
            //设备分组
            Map<Long, List<SgProjectInfoVO>> dMap = gxList.stream().collect(Collectors.groupingBy(SgProjectInfoVO::getDId));
            for (Map.Entry<Long, List<SgProjectInfoVO>> device : dMap.entrySet()) {
               Long dId = device.getKey();
               List<SgProjectInfoVO> deList = device.getValue();
               SgDeviceDO sgDeviceDO = new SgDeviceDO();
               sgDeviceDO.setId(dId);
               sgDeviceDO.setDeviceName(deList.get(0).getDeviceName());
               List<SgGxStepDO> stepDOS = deList.stream().filter(s->s.getReportStatus()==null || s.getReportStatus()!=4).map(s -> SgGxStepDO.builder().id(s.getStepId()).gxStepNum(s.getGxStepNum()).gxStepName(s.getGxStepName()).deviceId(s.getDId()).approvalStatus(s.getReportStatus()).build()).collect(Collectors.toList());
               List<SgGxStepDO> stepOver = stepDOS.stream().filter(s -> s.getApprovalStatus() != null && s.getApprovalStatus() == 2).collect(Collectors.toList());
               BigDecimal stepSize = BigDecimal.valueOf(stepDOS.size());
               BigDecimal stepOverSize = BigDecimal.ZERO;
               if (!stepOver.isEmpty()){
                  stepOverSize = BigDecimal.valueOf(stepOver.size());
            PtypeVO ptypeVO = PtypeVO.builder().pTypeName(ptyValue.get(0).getPtypeName()).build();
            List<SgTypeVO> sgGxDOS = new ArrayList<>();
            //类型分组
            Map<String, List<SgProjectInfoVO>> GxMap = ptyValue.stream().filter(s->s.getDeviceType()!=null).collect(Collectors.groupingBy(SgProjectInfoVO::getDeviceType));
            for (Map.Entry<String, List<SgProjectInfoVO>> ty : GxMap.entrySet()) {
               String type = ty.getKey();
               List<SgProjectInfoVO> gxList = ty.getValue();
               if (CollectionUtils.isEmpty(gxList)){
                  continue;
               }
               BigDecimal divide = stepOverSize.divide(stepSize, 2, RoundingMode.HALF_UP);
               sgDeviceDO.setStatus(divide.compareTo(new BigDecimal(1)) == 0?2:deList.get(0).getDeviceStatus());
               sgDeviceDO.setProgress(divide.toString());
               sgDeviceDO.setDeviceProgress(getBigDecimalPercent(divide));
               sgDeviceDO.setStepDOList(stepDOS);
               deviceDOS.add(sgDeviceDO);
               allDevice.add(sgDeviceDO);
               SgTypeVO typeVO = SgTypeVO.builder().typeName(gxList.get(0).getTypeName()).build();
               List<SgDeviceDO> deviceDOS = new ArrayList<>();
               //设备分组
               Map<Long, List<SgProjectInfoVO>> dMap = gxList.stream().collect(Collectors.groupingBy(SgProjectInfoVO::getDId));
               for (Map.Entry<Long, List<SgProjectInfoVO>> device : dMap.entrySet()) {
                  Long dId = device.getKey();
                  List<SgProjectInfoVO> deList = device.getValue();
                  SgDeviceDO sgDeviceDO = new SgDeviceDO();
                  sgDeviceDO.setId(dId);
                  sgDeviceDO.setDeviceName(deList.get(0).getDeviceName());
                  List<SgGxStepDO> stepDOS = deList.stream().filter(s -> s.getReportStatus() == null || (s.getReportStatus() != 4 && !(s.getReportStatus() == 3 && s.getResubmit() != 0))).map(s -> SgGxStepDO.builder().id(s.getStepId()).gxStepNum(s.getGxStepNum()).gxStepName(s.getGxStepName()).deviceId(s.getDId()).approvalStatus(s.getReportStatus()).build()).collect(Collectors.toList());
                  List<SgGxStepDO> stepOver = stepDOS.stream().filter(s -> s.getApprovalStatus() != null && s.getApprovalStatus() == 2).collect(Collectors.toList());
                  BigDecimal stepSize = BigDecimal.valueOf(stepDOS.size());
                  BigDecimal stepOverSize = BigDecimal.ZERO;
                  if (!stepOver.isEmpty()){
                     stepOverSize = BigDecimal.valueOf(stepOver.size());
                  }
                  BigDecimal divide = stepOverSize.divide(stepSize, 2, RoundingMode.HALF_UP);
                  sgDeviceDO.setStatus(divide.compareTo(new BigDecimal(1)) == 0?2:deList.get(0).getDeviceStatus());
                  sgDeviceDO.setProgress(divide.toString());
                  sgDeviceDO.setDeviceProgress(getBigDecimalPercent(divide));
                  sgDeviceDO.setStepDOList(stepDOS);
                  deviceDOS.add(sgDeviceDO);
                  allDevice.add(sgDeviceDO);
               }
               BigDecimal deviceSize = BigDecimal.valueOf(deviceDOS.size());
               double sum = deviceDOS.stream().mapToDouble(s -> Double.parseDouble(s.getProgress())).sum();
               BigDecimal deviceOver = BigDecimal.valueOf(sum);
               BigDecimal divideDevice = deviceOver.divide(deviceSize, 2, RoundingMode.HALF_UP);
               typeVO.setDeviceDOS(deviceDOS);
               typeVO.setTypeProgress(getBigDecimalPercent(divideDevice));
               typeVO.setProgress(divideDevice.toString());
               sgGxDOS.add(typeVO);
            }
            BigDecimal deviceSize = BigDecimal.valueOf(deviceDOS.size());
            double sum = deviceDOS.stream().mapToDouble(s -> Double.parseDouble(s.getProgress())).sum();
            BigDecimal deviceOver = BigDecimal.valueOf(sum);
            BigDecimal divideDevice = deviceOver.divide(deviceSize, 2, RoundingMode.HALF_UP);
            typeVO.setDeviceDOS(deviceDOS);
            typeVO.setTypeProgress(getBigDecimalPercent(divideDevice));
            sgGxDOS.add(typeVO);
            BigDecimal sgGxSize = BigDecimal.valueOf(sgGxDOS.size());
            double sum = sgGxDOS.stream().mapToDouble(s -> Double.parseDouble(s.getProgress())).sum();
            BigDecimal sgGxOver = BigDecimal.valueOf(sum);
            BigDecimal divideSgGx = sgGxOver.divide(sgGxSize, 2, RoundingMode.HALF_UP);
            ptypeVO.setPTypeProgress(getBigDecimalPercent(divideSgGx));
            ptypeVO.setSgTypeVOS(sgGxDOS);
            pTypes.add(ptypeVO);
         }
         BigDecimal allDeviceSize = BigDecimal.valueOf(allDevice.size());
         if (!allDeviceSize.equals(BigDecimal.ZERO)){
            double sum = allDevice.stream().mapToDouble(s -> Double.parseDouble(s.getProgress())).sum();
            BigDecimal allDeviceOver = BigDecimal.valueOf(sum);
            BigDecimal allDivideDevice = allDeviceOver.divide(allDeviceSize, 2, RoundingMode.HALF_UP);
            sgProjectInfoDO.setSgGxDOS(sgGxDOS);
            sgProjectInfoDO.setPtypeVOS(pTypes);
            sgProjectInfoDO.setProjectProgress( getBigDecimalPercent(allDivideDevice));
            sgProjectInfoDO.setProjectProgressNum(allDivideDevice);
         }
@@ -163,7 +260,7 @@
   public List<SgProjectInfoVO> progressList(ProjectSearchDTO searchDTO) {
      List<SgProjectInfoVO> list = new ArrayList<>();
      List<SgProjectInfoDO> projectProgress = new ArrayList<>();
      if(!searchDTO.getAdCode().isEmpty()){
      if(StringUtils.isNotBlank(searchDTO.getAdCode())){
         projectProgress = getProjectProgress(sgProjectInfoMapper.queryStepByProject1(searchDTO));
      }else {
          projectProgress = getProjectProgress(sgProjectInfoMapper.queryStepByProject(searchDTO));
@@ -217,6 +314,8 @@

   @Override
   public List<SgProjectInfoDO> listAll(ProjectSearchDTO searchDTO) {
      List<String> sgCodeS = getSgCodeByUser();
      searchDTO.setSgCodeS(sgCodeS);
      return sgProjectInfoMapper.queryPageList(null,searchDTO);
   }

@@ -246,21 +345,121 @@
   public List<SgStatisProVO> getsgStatisticsList(String code) {
      AttAdBase ywxtAdDetail = iAttAdBaseService.getYwxtAdDetail(code);
      List<SgStatisProVO> sgStatisProVOS;


      //片区
      if (ywxtAdDetail == null) {
         sgStatisProVOS = sgProjectInfoMapper.getsgStatisticsZero(code);
         String getname = sgProjectInfoMapper.getname(code);
         getDeviceTypes(sgStatisProVOS);
//         String getname = sgProjectInfoMapper.getname(code);
         String getname = code;
         updateProjectProgress(sgStatisProVOS, code, getname, "2");
      } else if (ywxtAdDetail.getAdGrad().equals("1")) {//默认
         sgStatisProVOS = sgProjectInfoMapper.getsgStatisticsOne(code);
         sgStatisProVOS = getSgStatisProVOS(sgStatisProVOS);
         getDeviceTypes(sgStatisProVOS);
         updateProjectProgress(sgStatisProVOS, ywxtAdDetail.getPAdCode(), ywxtAdDetail.getPAdName(), "0");
      } else {//区县
         sgStatisProVOS = sgProjectInfoMapper.getsgStatisticsList(code);
         getDeviceTypes(sgStatisProVOS);
         updateProjectProgress(sgStatisProVOS, ywxtAdDetail.getAdCode(), ywxtAdDetail.getAdName(), "3");
      }
      return sgStatisProVOS;
   }

   /**
    * 标段排序
    * @param sgStatisProVOS
    * @return
    */
   private  List<SgStatisProVO> getSgStatisProVOS(List<SgStatisProVO> sgStatisProVOS) {
      sgStatisProVOS = sgStatisProVOS.stream()
         .sorted(Comparator.comparing(s -> {
            String scode = s.getCode();
            if (scode.equals("第一标段")) {
               return 1;
            } else if (scode.equals("第二标段")) {
               return 2;
            } else if (scode.equals("第三标段")) {
               return 3;
            } else if (scode.equals("第四标段")) {
               return 4;
            } else if (scode.equals("第五标段")) {
               return 5;
            } else {
               return Integer.MAX_VALUE;
            }
         }))
         .collect(Collectors.toList());
      return sgStatisProVOS;
   }

   /**
    * 统计设备类型开工率
    * @param sgStatisProVOS
    */
   private void getDeviceTypes(List<SgStatisProVO> sgStatisProVOS) {
      if (CollectionUtils.isNotEmpty(sgStatisProVOS)){
         for (SgStatisProVO vo : sgStatisProVOS) {
            String proIds = vo.getProIds();
            if (StringUtils.isNotBlank(proIds)){
            List<SgStatisDeviceVO> deviceVOS =   sgProjectInfoMapper.getDeviceTypes("("+proIds+")");
            if(CollectionUtils.isNotEmpty(deviceVOS)){
               Map<String, SgStatisDeviceVO> map = deviceVOS.stream().collect(Collectors.toMap(SgStatisDeviceVO::getPType, Function.identity()));
               //表面变形
               SgStatisDeviceVO sg108 = map.get("sg108");
               if (Objects.nonNull(sg108)){
                  Integer deviceCount = sg108.getDeviceCount();
                  Integer deviceStart = sg108.getDeviceStart();
                  vo.setSurfaceNum(deviceCount);
                  if (deviceCount != 0){
                     BigDecimal divide = BigDecimal.valueOf(deviceStart).divide(BigDecimal.valueOf(deviceCount), 2, BigDecimal.ROUND_UP);
                     vo.setSeepageProgress(getBigDecimalPercent(divide));
                  }else {
                     vo.setSeepageProgress("0%");
                  }
               }
               //视频
               SgStatisDeviceVO sg104 = map.get("sg104");
               if (Objects.nonNull(sg104)){
                  Integer deviceCount = sg104.getDeviceCount();
                  Integer deviceStart = sg104.getDeviceStart();
                  vo.setVideoNum(deviceCount);
                  if (deviceCount != 0){
                     BigDecimal divide = BigDecimal.valueOf(deviceStart).divide(BigDecimal.valueOf(deviceCount), 2, BigDecimal.ROUND_UP);
                     vo.setVideoProgress(getBigDecimalPercent(divide));
                  }else {
                     vo.setVideoProgress("0%");
                  }
               }
               //渗压
               SgStatisDeviceVO sg101 = map.get("sg101");
               if (Objects.nonNull(sg101)){
                  Integer deviceCount = sg101.getDeviceCount();
                  Integer deviceStart = sg101.getDeviceStart();
                  vo.setTransNum(deviceCount);
                  if (deviceCount != 0){
                     BigDecimal divide = BigDecimal.valueOf(deviceStart).divide(BigDecimal.valueOf(deviceCount), 2, BigDecimal.ROUND_UP);
                     vo.setTransProgress(getBigDecimalPercent(divide));
                  }else {
                     vo.setTransProgress("0%");
                  }
               }
               //渗流
               SgStatisDeviceVO sg102 = map.get("sg102");
               if (Objects.nonNull(sg102)){
                  Integer deviceCount = sg102.getDeviceCount();
                  Integer deviceStart = sg102.getDeviceStart();
                  vo.setSeepageNum(deviceCount);
                  if (deviceCount != 0){
                     BigDecimal divide = BigDecimal.valueOf(deviceStart).divide(BigDecimal.valueOf(deviceCount), 2, BigDecimal.ROUND_UP);
                     vo.setSeepageProgress(getBigDecimalPercent(divide));
                  }else {
                     vo.setSeepageProgress("0%");
                  }
               }
               }
            }
         }
      }
   }

   private void updateProjectProgress(List<SgStatisProVO> sgStatisProVOS, String pcode, String pname, String adGrad) {
@@ -313,11 +512,11 @@
         List<SgProjectInfoDO> projectProgress = getProjectProgress(list);
         projectProgress.forEach(p -> {

            List<SgTypeVO> sgGxDOS = p.getSgGxDOS();
            sgGxDOS.forEach(sgTypeVO -> {
               String typeProgress = sgTypeVO.getTypeProgress().replace("%", "");
            List<PtypeVO> ptypeVOS = p.getPtypeVOS();
            ptypeVOS.forEach(sgTypeVO -> {
               String typeProgress = sgTypeVO.getPTypeProgress().replace("%", "");
               BigDecimal percentageBigDecimal = new BigDecimal(typeProgress).divide(new BigDecimal("100"), 2, RoundingMode.HALF_UP);
               bigDecimals.merge(sgTypeVO.getTypeName(), percentageBigDecimal, BigDecimal::add);
               bigDecimals.merge(sgTypeVO.getPTypeName(), percentageBigDecimal, BigDecimal::add);
            });

         });
@@ -383,8 +582,15 @@
      QueryWrapper<SgProgressReportDO> queryWrapper = new QueryWrapper<>();
      queryWrapper.eq("gx_step_id", stepIdForNull)
         .eq("profram_id", programId);
      SgProgressReportDO sgProgressReportDO = sgProgressReportMapper.selectOne(queryWrapper);
      SgProgressReportDO sgProgressReportDO = null;

      List<SgProgressReportDO> sgProgressReportDOS = sgProgressReportMapper.selectList(queryWrapper);
      if (CollectionUtils.isNotEmpty(sgProgressReportDOS)) {
         List<SgProgressReportDO> collect = sgProgressReportDOS.stream().filter(s -> s.getStatus() == null || (s.getStatus() != 4 && !(s.getStatus() == 3 && s.getResubmit() != 0))).collect(Collectors.toList());
        if (!collect.isEmpty()){
           sgProgressReportDO = collect.get(0);
        }
      }
      PreAcceVO preAcceVO = new PreAcceVO();
      if (sgProgressReportDO!= null) {
         preAcceVO.setId(sgProgressReportDO.getId().toString());
@@ -405,4 +611,69 @@

   }


   @Override
   public List<SgProjectTreeVO> projectTree(ProjectSearchDTO dto) {
      List<SgProjectTreeVO> list =    sgProjectInfoMapper.projectTree(dto);
      if (CollectionUtils.isNotEmpty(list)){
      // 按省、市、县分组
      Map<String, Map<String, Map<String, List<SgProjectTreeVO>>>> groupedProjects = list.stream()
         .collect(Collectors.groupingBy(SgProjectTreeVO::getProvinceNm,
            Collectors.groupingBy(SgProjectTreeVO::getCityNm,
               Collectors.groupingBy(SgProjectTreeVO::getCountyNm))));

      // 构建树结构
      List<SgProjectTreeVO> result = new ArrayList<>();
      for (Map.Entry<String, Map<String, Map<String, List<SgProjectTreeVO>>>> provinceEntry : groupedProjects.entrySet()) {
         String province = provinceEntry.getKey();
         Map<String, Map<String, List<SgProjectTreeVO>>> cityMap = provinceEntry.getValue();

         SgProjectTreeVO provinceNode = new SgProjectTreeVO();
         provinceNode.setProvinceNm(province);
         provinceNode.setId(UUID.randomUUID().toString().replace("-",""));
         provinceNode.setRegionName(province);
         provinceNode.setChildList(new ArrayList<>());
         long provinceNum = 0;
         for (Map.Entry<String, Map<String, List<SgProjectTreeVO>>> cityEntry : cityMap.entrySet()) {
            String city = cityEntry.getKey();
            Map<String, List<SgProjectTreeVO>> countyMap = cityEntry.getValue();

            SgProjectTreeVO cityNode = new SgProjectTreeVO();
            List<String> cityIds = new ArrayList<>();
            cityNode.setCityNm(city);
            cityNode.setId(UUID.randomUUID().toString().replace("-",""));
            cityNode.setRegionName(city);
            cityNode.setChildList(new ArrayList<>());

            for (Map.Entry<String, List<SgProjectTreeVO>> countyEntry : countyMap.entrySet()) {
               String county = countyEntry.getKey();
               List<SgProjectTreeVO> countyProjects = countyEntry.getValue();
               for (SgProjectTreeVO countyProject : countyProjects) {
                  countyProject.setRegionName(countyProject.getResNm());
               }
               SgProjectTreeVO countyNode = new SgProjectTreeVO();
               countyNode.setCountyNm(county);
               countyNode.setRegionName(county);
               countyNode.setId(UUID.randomUUID().toString().replace("-",""));
               countyNode.setChildList(new ArrayList<>(countyProjects));
               countyNode.setChildNum((long) countyProjects.size());
               countyNode.setProjectIds(countyProjects.stream().map(SgProjectTreeVO::getId).collect(Collectors.toList()));
               cityIds.addAll(countyNode.getProjectIds());
               cityNode.getChildList().add(countyNode);
            }

            cityNode.setChildNum((long) cityIds.size());
            cityNode.setProjectIds(cityIds);
            provinceNode.getChildList().add(cityNode);
            provinceNum+= (long) cityIds.size();
         }

         provinceNode.setChildNum(provinceNum);
         result.add(provinceNode);
      }
      return result;
      }
      return new ArrayList<>();
   }

}