同步功能-项目新增节点同步到合同段时 直接新增

同步功能-新增同步任务时 判断同步源为公共模板就只能选择新增表单和表单排序

blade-service/blade-manager/src/main/java/org/springblade/manager/service/impl/WbsSynchronousServiceImpl.java

@@ -301,7 +301,6 @@ public class WbsSynchronousServiceImpl {
                 List<WbsTreePrivate> editPrivateNodes = new ArrayList<>();
                 for (WbsTreePrivate templateNode : templateNodes) {
                     //数据修复-----------------------------------------------------------------------------------------------------------------------------------开始
-
                     if (!isPublic) {
                         boolean isUpdate = false;
                         if (templateNode.getExcelId() != null) {
@@ -369,8 +368,8 @@ public class WbsSynchronousServiceImpl {
                             wbsTreePrivateMapper.update(templateNode, Wrappers.<WbsTreePrivate>lambdaUpdate()
                                     .eq(WbsTreePrivate::getPKeyId, templateNode.getPKeyId()));
                         }
-                        //数据修复-----------------------------------------------------------------------------------------------------------------------------------完成
                     }
+                    //数据修复-----------------------------------------------------------------------------------------------------------------------------------完成
                     //更新只跟新表单
                     for (WbsTreePrivate editPrivateNode : wbsTreePrivates) {
                         // 判断模板表与项目表 html是否一致
@@ -378,7 +377,7 @@ public class WbsSynchronousServiceImpl {
                             if (templateNode.getType() == 1) {
                                 editPrivateNode.setNodeName(templateNode.getNodeName());
                                 editData.add(editPrivateNode);
-                            }else {
+                            } else {
                                 //清表
                                 if (collect.contains(2)) {
                                     //绑定清表
@@ -575,181 +574,193 @@ public class WbsSynchronousServiceImpl {
                 List<WbsTreeContract> startContacts = wbsTreeContractMapper.selectList(Wrappers.<WbsTreeContract>lambdaQuery()
                         .eq(WbsTreeContract::getContractId, contractInfo.getId())
                         .eq(WbsTreeContract::getIsTypePrivatePid, primaryKeyId));
-                //如果没有查询到，表示该合同下不存在该节点
+                //如果没有查询到，表示该合同下不存在该节点 就直接新增
                 if (CollectionUtil.isEmpty(startContacts)) {
                     //不能抛异常  不然就会中止程序  开发阶段先抛异常，后续统一处理
-                    throw new ServiceException("当前节点不存在");
-                }
-
-                for (WbsTreeContract wbsTreeContract : startContacts) {
-
-
-                    //获取合同 当前节点的所有子节点数据
-                    LambdaQueryWrapper<WbsTreeContract> wrapperContract = Wrappers.lambdaQuery();
-                    wrapperContract
+                    List<WbsTreeContract> addContractNode = null;
+                    addContractNode = BeanUtil.copyProperties(wbsTreePrivates, WbsTreeContract.class);
+                    //获取选中节点的父级节点与合同段对应的关系
+                    WbsTreePrivate parentNode = wbsTreePrivateMapper.selectById(wbsTreePrivate.getPId());
+                    List<WbsTreeContract> list = wbsTreeContractMapper.selectList(Wrappers.<WbsTreeContract>lambdaQuery()
                             .eq(WbsTreeContract::getContractId, contractInfo.getId())
-                            .eq(WbsTreeContract::getIsDeleted, 0);
-                    //判断如果为顶级顶级节点
-                    if (wbsTreeContract.getTreePId() != 0) {
-                        wrapperContract.apply("FIND_IN_SET({0},ancestors_p_id)", wbsTreeContract.getPKeyId());
+                            .eq(WbsTreeContract::getIsTypePrivatePid, parentNode.getPKeyId()));
+                    for (WbsTreeContract wbsTreeContract : list) {
+                        List<WbsTreeContract> wbsTreeContracts = new ArrayList<>();
+                        wbsTreeContracts.add(wbsTreeContract);
+                        insertContractForm(wbsTreeSynchronousRecord, contractInfo, wbsTreeContracts, addContractNode);
                     }
+                } else {
+                    for (WbsTreeContract wbsTreeContract : startContacts) {
+                        //获取合同 当前节点的所有子节点数据
+                        LambdaQueryWrapper<WbsTreeContract> wrapperContract = Wrappers.lambdaQuery();
+                        wrapperContract
+                                .eq(WbsTreeContract::getContractId, contractInfo.getId())
+                                .eq(WbsTreeContract::getIsDeleted, 0);
+                        //判断如果为顶级顶级节点
+                        if (wbsTreeContract.getTreePId() != 0) {
+                            wrapperContract.apply("FIND_IN_SET({0},ancestors_p_id)", wbsTreeContract.getPKeyId());
+                        }
 
-                    //当前合同的子节点数据
-                    List<WbsTreeContract> wbsTreeContracts = wbsTreeContractMapper.selectList(wrapperContract);
-                    wbsTreeContracts.add(wbsTreeContract);
+                        //当前合同的子节点数据
+                        List<WbsTreeContract> wbsTreeContracts = wbsTreeContractMapper.selectList(wrapperContract);
+                        wbsTreeContracts.add(wbsTreeContract);
 
-                    HashMap<Long, Integer> informationQueryMap = new HashMap<>();
-                    //查询质检合同节点填表信息
-                    String sql = "SELECT  b.wbs_id, b.STATUS  FROM" +
-                            "( SELECT p_key_id FROM m_wbs_tree_contract WHERE is_deleted = 0 AND contract_id = " + contractInfo.getId() + " AND FIND_IN_SET( " + wbsTreeContract.getPKeyId() + ", ancestors_p_id ) ) a" +
-                            " INNER JOIN (  SELECT  c.wbs_id, c.STATUS FROM u_information_query c" +
-                            " JOIN ( SELECT wbs_id, MAX( update_time ) AS max_update_time FROM u_information_query WHERE contract_id = " + contractInfo.getId() + " GROUP BY wbs_id ) subquery ON c.wbs_id = subquery.wbs_id " +
-                            " AND c.update_time = subquery.max_update_time WHERE  c.contract_id = " + contractInfo.getId() + " and c.is_deleted = 0 ) b ON a.p_key_id = b.wbs_id";
+                        HashMap<Long, Integer> informationQueryMap = new HashMap<>();
+                        //查询质检合同节点填表信息
+                        String sql = "SELECT  b.wbs_id, b.STATUS  FROM" +
+                                "( SELECT p_key_id FROM m_wbs_tree_contract WHERE is_deleted = 0 AND contract_id = " + contractInfo.getId() + " AND FIND_IN_SET( " + wbsTreeContract.getPKeyId() + ", ancestors_p_id ) ) a" +
+                                " INNER JOIN (  SELECT  c.wbs_id, c.STATUS FROM u_information_query c" +
+                                " JOIN ( SELECT wbs_id, MAX( update_time ) AS max_update_time FROM u_information_query WHERE contract_id = " + contractInfo.getId() + " GROUP BY wbs_id ) subquery ON c.wbs_id = subquery.wbs_id " +
+                                " AND c.update_time = subquery.max_update_time WHERE  c.contract_id = " + contractInfo.getId() + " and c.is_deleted = 0 ) b ON a.p_key_id = b.wbs_id";
 
-                    List<InformationQuery> informationQueries = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(InformationQuery.class));
-                    //质检节点填报信息
+                        List<InformationQuery> informationQueries = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(InformationQuery.class));
+                        //质检节点填报信息
 
-                    for (InformationQuery informationQuery : informationQueries) {
-                        informationQueryMap.put(informationQuery.getWbsId(), informationQuery.getStatus());
-                    }
+                        for (InformationQuery informationQuery : informationQueries) {
+                            informationQueryMap.put(informationQuery.getWbsId(), informationQuery.getStatus());
+                        }
 
 
-                    //合同段节点对应的项目id
-                    List<Long> typePrivateIds = wbsTreeContracts.stream().map(WbsTreeContract::getIsTypePrivatePid).collect(Collectors.toList());
+                        //合同段节点对应的项目id
+                        List<Long> typePrivateIds = wbsTreeContracts.stream().map(WbsTreeContract::getIsTypePrivatePid).collect(Collectors.toList());
 
-                    //需要新增的表单
-                    List<WbsTreePrivate> addPrivateNodes = wbsTreePrivates.stream().filter(f -> !typePrivateIds.contains(f.getPKeyId())).collect(Collectors.toList());
+                        //需要新增的表单
+                        List<WbsTreePrivate> addPrivateNodes = wbsTreePrivates.stream().filter(f -> !typePrivateIds.contains(f.getPKeyId())).collect(Collectors.toList());
 
-                    //如果没有选中 则默认同步所有
-                    if (CollectionUtil.isNotEmpty(formList)) {
-                        //二次筛选  只保留任务选中的表单   但可能新增的数据包含新节点
-                        addPrivateNodes = addPrivateNodes.stream().filter(f -> f.getType() == 1 || formList.contains(f.getPKeyId())).collect(Collectors.toList());
-                    }
+                        //如果没有选中 则默认同步所有
+                        if (CollectionUtil.isNotEmpty(formList)) {
+                            //二次筛选  只保留任务选中的表单   但可能新增的数据包含新节点
+                            addPrivateNodes = addPrivateNodes.stream().filter(f -> f.getType() == 1 || formList.contains(f.getPKeyId())).collect(Collectors.toList());
+                        }
 
-                    //筛选出需要更新的节点  同时做数据隔离
-                    List<WbsTreeContract> editContractNodes = new ArrayList<>();
-                    for (WbsTreePrivate templateNode : wbsTreePrivates) {
-                        //更新只跟新表单
-                        if (templateNode.getType() == 2) {
+                        //筛选出需要更新的节点  同时做数据隔离
+                        List<WbsTreeContract> editContractNodes = new ArrayList<>();
+                        for (WbsTreePrivate templateNode : wbsTreePrivates) {
+                            //更新只跟新表单
                             for (WbsTreeContract editContractNode : wbsTreeContracts) {
+
                                 // 判断模板表与项目表 html是否一致
                                 if (ObjectUtils.equals(templateNode.getPKeyId(), editContractNode.getIsTypePrivatePid())) {
-
-                                    //同步范围 当前节点是否允许修改
-                                    Boolean isSync = false;
-                                    if (CollectionUtil.isNotEmpty(contractRanges)) {
-                                        switch (Integer.valueOf(wbsTreePrivate.getWbsType())) {
-                                            //质检
-                                            case 1:
-                                                Integer submit = informationQueryMap.get(editContractNode.getPKeyId());
-
-                                                if (submit == null && contractRanges.contains(WbsSyncTypeEnum.NOT_FILLED_IN.code)) {
-                                                    //未审批 101
-                                                    isSync = true;
-                                                } else if (submit == 0 && contractRanges.contains(WbsSyncTypeEnum.ALREADY_FILLED_IN_NOT_REPORTED.code)) {
-                                                    //已填报-未上报 102
-                                                    isSync = true;
-                                                } else if (submit == 1 && contractRanges.contains(WbsSyncTypeEnum.PENDING_APPROVAL.code)) {
-                                                    //待审批 104
-                                                    isSync = true;
-                                                } else if (submit == 2 && contractRanges.contains(WbsSyncTypeEnum.APPROVED.code)) {
-                                                    //已审批 105
-                                                    isSync = true;
-                                                }
-                                                break;
-                                            //试验
-                                            case 2:
-                                                break;
-                                            //计量
-                                            case 3:
-                                                break;
-                                            //日志
-                                            case 4:
-                                                break;
-                                            //征地拆迁
-                                            case 5:
-                                                break;
-                                            default:
-                                                break;
-                                        }
+                                    if (templateNode.getType() == 1) {
+                                        editContractNode.setNodeName(templateNode.getNodeName());
+                                        editData.add(editContractNode);
                                     } else {
-                                        isSync = true;
-                                    }
+                                        //同步范围 当前节点是否允许修改
+                                        Boolean isSync = false;
+                                        if (CollectionUtil.isNotEmpty(contractRanges)) {
+                                            switch (Integer.valueOf(wbsTreePrivate.getWbsType())) {
+                                                //质检
+                                                case 1:
+                                                    Integer submit = informationQueryMap.get(editContractNode.getPKeyId());
+
+                                                    if (submit == null && contractRanges.contains(WbsSyncTypeEnum.NOT_FILLED_IN.code)) {
+                                                        //未审批 101
+                                                        isSync = true;
+                                                    } else if (submit == 0 && contractRanges.contains(WbsSyncTypeEnum.ALREADY_FILLED_IN_NOT_REPORTED.code)) {
+                                                        //已填报-未上报 102
+                                                        isSync = true;
+                                                    } else if (submit == 1 && contractRanges.contains(WbsSyncTypeEnum.PENDING_APPROVAL.code)) {
+                                                        //待审批 104
+                                                        isSync = true;
+                                                    } else if (submit == 2 && contractRanges.contains(WbsSyncTypeEnum.APPROVED.code)) {
+                                                        //已审批 105
+                                                        isSync = true;
+                                                    }
+                                                    break;
+                                                //试验
+                                                case 2:
+                                                    break;
+                                                //计量
+                                                case 3:
+                                                    break;
+                                                //日志
+                                                case 4:
+                                                    break;
+                                                //征地拆迁
+                                                case 5:
+                                                    break;
+                                                default:
+                                                    break;
+                                            }
+                                        } else {
+                                            isSync = true;
+                                        }
 
 
-                                    //清表 公式 元素
-                                    if (collect.contains(2) || collect.contains(3) || collect.contains(5)) {
-                                        editContractNode.setExcelId(templateNode.getExcelId());
-                                        editContractNode.setInitTableName(templateNode.getInitTableName());
-                                        editContractNode.setHtmlUrl(templateNode.getHtmlUrl());
-                                        if (templateNode.getExcelId() != null) {
-                                            editContractNode.setIsLinkTable(2);
+                                        //清表 公式 元素
+                                        if (collect.contains(2) || collect.contains(3) || collect.contains(5)) {
+                                            editContractNode.setExcelId(templateNode.getExcelId());
+                                            editContractNode.setInitTableName(templateNode.getInitTableName());
+                                            editContractNode.setHtmlUrl(templateNode.getHtmlUrl());
+                                            if (templateNode.getExcelId() != null) {
+                                                editContractNode.setIsLinkTable(2);
+                                            }
                                         }
-                                    }
-                                    //排序
-                                    if (collect.contains(7)) {
-                                        editContractNode.setSort(templateNode.getSort());
-                                    }
+                                        //排序
+                                        if (collect.contains(7)) {
+                                            editContractNode.setSort(templateNode.getSort());
+                                        }
+
+                                        //手动选中的表单 进行筛选
+                                        if (CollectionUtil.isNotEmpty(formList)) {
+                                            if (formList.contains(templateNode.getPKeyId())) {
+                                                if (collect.contains(2) || collect.contains(3) || collect.contains(4) || collect.contains(5) || collect.contains(6) || collect.contains(7)) {
+                                                    if (isSync) {
+                                                        editContractNodes.add(editContractNode);
+                                                    }
 
-                                    //手动选中的表单 进行筛选
-                                    if (CollectionUtil.isNotEmpty(formList)) {
-                                        if (formList.contains(templateNode.getPKeyId())) {
+                                                }
+                                            }
+                                        } else {
                                             if (collect.contains(2) || collect.contains(3) || collect.contains(4) || collect.contains(5) || collect.contains(6) || collect.contains(7)) {
                                                 if (isSync) {
                                                     editContractNodes.add(editContractNode);
                                                 }
-
-                                            }
-                                        }
-                                    } else {
-                                        if (collect.contains(2) || collect.contains(3) || collect.contains(4) || collect.contains(5) || collect.contains(6) || collect.contains(7)) {
-                                            if (isSync) {
-                                                editContractNodes.add(editContractNode);
                                             }
                                         }
+                                        //找到了某个选中节点下与项目节点想同的节点了  提前结束循环，节省资源
+                                        break;
                                     }
-                                    //找到了某个选中节点下与项目节点想同的节点了  提前结束循环，节省资源
-                                    break;
                                 }
                             }
                         }
-                    }
-                    //修改数据二次筛选  只保留任务选中的表单   但可能新增的数据包含新节点
-                    if (CollectionUtil.isNotEmpty(formList)) {
-                        editContractNodes = editContractNodes.stream().filter(f -> formList.contains(f.getPKeyId())).collect(Collectors.toList());
-                    }
+                        //修改数据二次筛选  只保留任务选中的表单   但可能新增的数据包含新节点
+                        if (CollectionUtil.isNotEmpty(formList)) {
+                            editContractNodes = editContractNodes.stream().filter(f -> formList.contains(f.getPKeyId())).collect(Collectors.toList());
+                        }
 
-                    //合同段新增节点
-                    List<WbsTreeContract> addContractNode = null;
-                    if (addPrivateNodes != null) {
-                        addContractNode = BeanUtil.copyProperties(addPrivateNodes, WbsTreeContract.class);
-                    }
+                        //合同段新增节点
+                        List<WbsTreeContract> addContractNode = null;
+                        if (addPrivateNodes != null) {
+                            addContractNode = BeanUtil.copyProperties(addPrivateNodes, WbsTreeContract.class);
+                        }
 
-                    //转类型排序
-                    List<Integer> integers = new ArrayList<>(collect);
-                    Collections.sort(integers);
-                    for (Integer i : integers) {
-                        switch (i) {
-                            //添加表单
-                            case 1:
-                                insertContractForm(wbsTreeSynchronousRecord, contractInfo, wbsTreeContracts, addContractNode);
-                                //如果同时选择新增表单和其他的同步类型  在操作其他类型的时候需要添加新的表单
-                                if (CollectionUtil.isNotEmpty(addContractNode)) {
-                                    editContractNodes.addAll(addContractNode.stream().filter(f -> f.getType() == 2).collect(Collectors.toList()));
-                                }
-                                break;
-                            //清表配置
-                            case 2:
-                                //元素配置
-                            case 3:
-                                //公式配置
-                            case 5:
-                                //排序
-                            case 7:
-                                editData.addAll(editContractNodes);
-                                break;
-                            default:
-                                break;
+                        //转类型排序
+                        List<Integer> integers = new ArrayList<>(collect);
+                        Collections.sort(integers);
+                        for (Integer i : integers) {
+                            switch (i) {
+                                //添加表单
+                                case 1:
+                                    insertContractForm(wbsTreeSynchronousRecord, contractInfo, wbsTreeContracts, addContractNode);
+                                    //如果同时选择新增表单和其他的同步类型  在操作其他类型的时候需要添加新的表单
+//                                    if (CollectionUtil.isNotEmpty(addContractNode)) {
+//                                        editContractNodes.addAll(addContractNode.stream().filter(f -> f.getType() == 2).collect(Collectors.toList()));
+//                                    }
+                                    break;
+                                //清表配置
+                                case 2:
+                                    //元素配置
+                                case 3:
+                                    //公式配置
+                                case 5:
+                                    //排序
+                                case 7:
+                                    editData.addAll(editContractNodes);
+                                    break;
+                                default:
+                                    break;
+                            }
                         }
                     }
                 }

blade-service/blade-manager/src/main/java/org/springblade/manager/service/impl/WbsTreeSynchronousRecordServiceImpl.java

@@ -80,23 +80,29 @@ public class WbsTreeSynchronousRecordServiceImpl extends ServiceImpl<WbsTreeSync
 
 
         //记录选中节点下的表单数
-        int count = 0;
         String[] newNodeIds = mWbsTreeSynchronousRecord.getNodeId().split(",");
         for (String newNodeId : newNodeIds) {
             Long nodeIdLong = Long.valueOf(newNodeId);
             if (privateIds.contains(nodeIdLong)) {
                 throw new ServiceException("当前选中节点正在同步，请勿重复同步");
             }
-            //计算当前选中节点的所有子节点表单数量
-            List<WbsTreePrivate> wbsTreePrivates = wbsTreePrivateMapper.selectList(new QueryWrapper<WbsTreePrivate>().lambda()
-                    .select(WbsTreePrivate::getPKeyId)
-                    .eq(WbsTreePrivate::getIsDeleted, 0)
-                    .eq(WbsTreePrivate::getType, 2)
-                    .apply("find_in_set({0},ancestors_p_id)", newNodeId)
-            );
-            count += wbsTreePrivates.size();
         }
 
+        //模板项目信息
+        ProjectInfo tempProject = projectInfoMapper.selectOne(Wrappers.<ProjectInfo>lambdaQuery()
+                .eq(ProjectInfo::getId, mWbsTreeSynchronousRecord.getTemplateId()));
+        //当前项目绑定的是公有模板还是私有项目
+        if(mWbsTreeSynchronousRecord.getRange() == 1 && tempProject == null && (
+                mWbsTreeSynchronousRecord.getType().contains("2")||
+                mWbsTreeSynchronousRecord.getType().contains("3")||
+                mWbsTreeSynchronousRecord.getType().contains("4")||
+                mWbsTreeSynchronousRecord.getType().contains("5")||
+                mWbsTreeSynchronousRecord.getType().contains("6"))){
+            throw new ServiceException("模板为公共模板，无法选择");
+        }
+
+
+
         //获取项目名称
         ProjectInfo projectInfo = projectInfoMapper.selectById(mWbsTreeSynchronousRecord.getProjectId());
         if (projectInfo == null) {