Просмотр исходного кода

Merge remote-tracking branch 'origin/master' into master

yangyj 1 год назад
Родитель
Сommit
29bab25aa1

+ 1 - 1
blade-service/blade-business/src/main/java/org/springblade/business/controller/ArchiveFileController.java

@@ -505,7 +505,7 @@ public class ArchiveFileController extends BladeController {
                 json.put("operationObjIds", Func.toStrList(ids));
                 json.put("operationObjName", title);
 
-                this.operationLogClient.saveUserOperationLog(27, "其文件", "工程文件", json);
+                this.operationLogClient.saveUserOperationLog(27, "其文件", "工程文件", json);
 
                 //保存回收站记录
                 this.recycleBinClient.saveDelBusinessData(Func.toStrList(ids), title, 1, position, fileList.get(0).getProjectId(), fileList.get(0).getContractId());

+ 18 - 0
blade-service/blade-business/src/main/java/org/springblade/business/mapper/OperationLogMapper.xml

@@ -56,6 +56,24 @@
         select *
         from u_operation_log uol where is_deleted = 0
         and (SELECT contract_id from m_wbs_tree_contract WHERE p_key_id = SUBSTRING_INDEX(uol.business_id,",",1)) = #{vo.contractId}
+        <if test="vo.operationModule != null and vo.operationModule != '' ">
+             and operation_module = #{vo.operationModule}
+        </if>
+        <if test="vo.operationType != null and vo.operationType != '' ">
+            and operation_type = #{vo.operationType}
+        </if>
+        <if test="vo.operationMedium != null and vo.operationMedium != '' ">
+            and operation_medium = #{vo.operationMedium}
+        </if>
+        <if test="vo.createUser != null and vo.createUser != '' ">
+            and create_user = #{vo.createUser}
+        </if>
+        <if test="vo.queryValue != null and vo.queryValue != '' ">
+            and operation_content like CONCAT(CONCAT('%', #{vo.queryValue}), '%')
+        </if>
+        <if test="vo.startTime != null and vo.startTime != '' ">
+            and create_time &gt;= #{vo.startTime} and create_time &lt;= #{vo.endTime}
+        </if>
         order by uol.create_time desc
     </select>
 

+ 11 - 1
blade-service/blade-meter/src/main/java/org/springblade/meter/controller/MeterTreeController.java

@@ -1,6 +1,7 @@
 package org.springblade.meter.controller;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.toolkit.StringUtils;
@@ -609,6 +610,15 @@ public class MeterTreeController extends BladeController {
     @ApiOperationSupport(order = 24)
     @ApiOperation(value = "合同段树节点修改", notes = "传入MeterTreeContractDTO")
     public R<Object> contractUpdate(@RequestBody MeterTreeContractDTO dto) {
+        //先校验节点编号是否唯一
+        if (StringUtils.isNotBlank(dto.getNodeCode())){
+            long count = meterTreeContractService.count(new LambdaUpdateWrapper<MeterTreeContract>()
+                    .eq(MeterTreeContract::getNodeCode, dto.getNodeCode())
+                    .ne(MeterTreeContract::getId, dto.getId()));
+            if (count > 0){
+                throw new ServiceException("修改失败,当前工程编号已经存在");
+            }
+        }
         if (ObjectUtil.isNotEmpty(dto.getDecompositionList()) && dto.getDecompositionList().size() > 0) {
             /*最底层节点修改*/
             dto.setUpdateStatus(1); //编辑
@@ -833,7 +843,7 @@ public class MeterTreeController extends BladeController {
     @ApiOperationSupport(order = 33)
     @ApiOperation(value = "合同段计量单元导入", notes = "传入当前选择的节点id,excel文件file")
     public R<Object> contractTreeNodeImport(@RequestParam String id, MultipartFile file) {
-        if (ObjectUtil.isNotEmpty(id) && meterTreeContractService.contractTreeNodeImport(id, file)) {
+        if (ObjectUtil.isNotEmpty(id) && meterTreeContractService.contractTreeNodeImport2(id, file)) {
             return R.success("操作成功");
         }
         return R.fail("操作失败");

+ 2 - 0
blade-service/blade-meter/src/main/java/org/springblade/meter/mapper/MeterTreeContractMapper.java

@@ -19,4 +19,6 @@ public interface MeterTreeContractMapper extends BaseMapper<MeterTreeContract> {
     void batchUpdateById(@Param("list") List<MeterTreeContract> list);
 
     List<InventoryFormMeter> getNodeAllForm(@Param("ids") Set<Long> ids);
+
+    List<String> getAllEqualsNumber(@Param("contractId") Long contractId,@Param("numbers") List<String> collect);
 }

+ 7 - 0
blade-service/blade-meter/src/main/java/org/springblade/meter/mapper/MeterTreeContractMapper.xml

@@ -25,4 +25,11 @@
             #{id}
         </foreach>
     </select>
+    <select id="getAllEqualsNumber" resultType="java.lang.String">
+        select node_code from s_meter_tree_contract where contract_id = #{contractId} and is_deleted = 0
+        and node_code in
+        <foreach collection="numbers" item="number" open="(" close=")" separator=",">
+            #{number}
+        </foreach>
+    </select>
 </mapper>

+ 3 - 0
blade-service/blade-meter/src/main/java/org/springblade/meter/service/MeterTreeContractService.java

@@ -27,4 +27,7 @@ public interface MeterTreeContractService extends BaseService<MeterTreeContract>
 
     boolean contractTreeNodeImport(String id, MultipartFile file);
 
+    //按照层级导入
+    boolean contractTreeNodeImport2(String id, MultipartFile file);
+
 }

+ 513 - 0
blade-service/blade-meter/src/main/java/org/springblade/meter/service/impl/MeterTreeContractServiceImpl.java

@@ -1,5 +1,6 @@
 package org.springblade.meter.service.impl;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import lombok.AllArgsConstructor;
 import org.apache.commons.lang.StringUtils;
@@ -960,6 +961,518 @@ public class MeterTreeContractServiceImpl extends BaseServiceImpl<MeterTreeContr
         return var;
     }
 
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public boolean contractTreeNodeImport2(String id, MultipartFile file) {
+        MeterTreeContract meterTreeContract = baseMapper.selectById(id);
+        if (meterTreeContract.getAncestor().split(",").length > 5) {
+            throw new ServiceException("只能从前五层节点开始导入,操作失败");
+        }
+        List<MeterTreeContract> rootNodesImport = new ArrayList<>();
+        if (meterTreeContract.getParentId().equals(0L) && meterTreeContract.getAncestor().equals("0")) {
+            /*根节点导入,获取下一层级节点*/
+            rootNodesImport = baseMapper.selectList(Wrappers.<MeterTreeContract>lambdaQuery().eq(MeterTreeContract::getParentId, id).isNotNull(MeterTreeContract::getNodeCode));
+        } else {
+            /*非根节点导入,获取当前节点*/
+            if (ObjectUtil.isEmpty(meterTreeContract.getNodeCode())) {
+                throw new ServiceException("当前选择导入的工程编号为空,操作失败");
+            }
+            rootNodesImport.add(meterTreeContract);
+        }
+
+        /*解析excel*/
+        List<Map<String, String>> parseExcelFileToList = this.parseExcelFile(file);
+
+        /*节点新增*/
+        List<MeterTreeContract> resultNodeListAdd = new LinkedList<>();
+        /*节点金额修改Ids*/
+        Set<Long> updateNodeSet = new HashSet<>();
+        /*清单中间新增*/
+        List<InventoryFormMeter> resultFormListAdd = new LinkedList<>();
+        /*清单中间数量修改*/
+        List<InventoryFormMeter> resultFormListUpdate = new LinkedList<>();
+
+        /*导入节点的子级信息*/
+        //查询当前节点,有节点编号的所有子节点
+        List<MeterTreeContract> rootNodeChild = baseMapper.selectList(Wrappers.<MeterTreeContract>lambdaQuery().like(MeterTreeContract::getAncestor, id).isNotNull(MeterTreeContract::getNodeCode));
+        //通过节点编号分组
+        Map<String, MeterTreeContract> rootNodeChildMap = new HashMap<>();
+        try {
+            rootNodeChildMap = rootNodeChild.stream().collect(Collectors.toMap(MeterTreeContract::getNodeCode, Function.identity()));
+        }catch (IllegalStateException e){
+            throw new ServiceException("树节点的工程编号存在重复,请检查后再重新导入");
+        }
+        //获取所有子节点id
+        List<Long> rootNodeChildIds = rootNodeChild.stream().map(MeterTreeContract::getId).collect(Collectors.toList());
+        Map<Long, List<InventoryFormMeter>> inventoryFormMeterMapsGroupByContractMeterId = new HashMap<>();
+        Map<String, InventoryFormMeter> inventoryFormMeterMapsByFormIdAndMeterId = new HashMap<>();
+        Map<String, ChangeTokenInventory> changeTokenInventoryMapsByFormIdAndMeterId = new HashMap<>();
+        Map<String, InventoryFormApply> inventoryFormApplyMapsByFormIdAndMeterId = new HashMap<>();
+        if (rootNodeChildIds.size() > 0) {
+            /*子级的中间表关联的清单信息*/
+            List<InventoryFormMeter> query = jdbcTemplate.query("SELECT * FROM s_inventory_form_meter WHERE is_deleted = 0" +
+                            " AND contract_id = " + meterTreeContract.getContractId() +
+                            " AND contract_meter_id IN(" + StringUtils.join(rootNodeChildIds, ",") + ")",
+                    new BeanPropertyRowMapper<>(InventoryFormMeter.class));
+            inventoryFormMeterMapsGroupByContractMeterId = query.stream().collect(Collectors.groupingBy(InventoryFormMeter::getContractMeterId));
+            inventoryFormMeterMapsByFormIdAndMeterId =
+                    query.stream()
+                            .collect(Collectors.toMap(
+                                    meter -> meter.getContractFormId() + ":" + meter.getContractMeterId(),
+                                    Function.identity()
+                            ));
+
+            /*变更令引用*/
+            List<ChangeTokenInventory> query1 = jdbcTemplate.query("SELECT contract_meter_id,contract_form_id FROM s_change_token_inventory WHERE is_deleted = 0" +
+                            " AND contract_id = " + meterTreeContract.getContractId() +
+                            " AND contract_meter_id IN(" + StringUtils.join(rootNodeChildIds, ",") + ")",
+                    new BeanPropertyRowMapper<>(ChangeTokenInventory.class));
+            changeTokenInventoryMapsByFormIdAndMeterId =
+                    query1.stream()
+                            .collect(Collectors.toMap(
+                                    change -> change.getContractFormId() + ":" + change.getContractMeterId(),
+                                    Function.identity()
+                            ));
+
+            /*中间计量引用*/
+            List<InventoryFormApply> query2 = jdbcTemplate.query("SELECT contract_meter_id,contract_form_id FROM s_inventory_form_apply WHERE is_deleted = 0" +
+                            " AND contract_id = " + meterTreeContract.getContractId() +
+                            " AND contract_meter_id IN(" + StringUtils.join(rootNodeChildIds, ",") + ")",
+                    new BeanPropertyRowMapper<>(InventoryFormApply.class));
+            inventoryFormApplyMapsByFormIdAndMeterId =
+                    query2.stream()
+                            .collect(Collectors.toMap(
+                                    inventoryFormApply -> inventoryFormApply.getContractFormId() + ":" + inventoryFormApply.getContractMeterId(),
+                                    Function.identity()
+                            ));
+        }
+
+        /*桩号类型*/
+        Map<String, String> meterStakeTypeMaps = jdbcTemplate.query("SELECT dict_key,dict_value FROM blade_dict WHERE is_deleted = 0 AND code = 'meter_stake_type'", new BeanPropertyRowMapper<>(Dict.class)).stream().collect(Collectors.toMap(Dict::getDictValue, Dict::getDictKey));
+
+        /*清单信息*/
+        List<ContractInventoryForm> query = jdbcTemplate.query("SELECT id,change_price,form_number FROM s_contract_inventory_form WHERE is_deleted = 0 AND contract_id = " + meterTreeContract.getContractId(), new BeanPropertyRowMapper<>(ContractInventoryForm.class));
+        Map<String, ContractInventoryForm> contractInventoryFormMapsByFormNumber = query.stream().collect(Collectors.toMap(ContractInventoryForm::getFormNumber, Function.identity()));
+        Map<Long, ContractInventoryForm> contractInventoryFormMapsById = query.stream().collect(Collectors.toMap(ContractInventoryForm::getId, Function.identity()));
+
+        Map<String, List<Map<String, String>>> rootCodeMaps = parseExcelFileToList.stream()
+                .collect(Collectors.groupingBy(
+                        map -> map.get("工程编号"),
+                        LinkedHashMap::new,
+                        Collectors.toList()));
+        //导入时选择的节点,如果选择的是首节点时就存在多个二级节点
+        for (MeterTreeContract treeContract : rootNodesImport) {
+
+            /*工程编号匹配*/
+            List<Map<String, String>> projectCodeGroup = rootCodeMaps.getOrDefault(treeContract.getNodeCode(), null);
+
+            if (ObjectUtil.isNotEmpty(projectCodeGroup)) {
+                //查询出当前节点下的所有子节点,并按照节点编号分组
+                List<MeterTreeContract> allNode = this.list(new LambdaQueryWrapper<MeterTreeContract>()
+                        .like(MeterTreeContract::getAncestor, treeContract.getId())
+                        .isNotNull(MeterTreeContract::getNodeCode));
+                Map<String, MeterTreeContract> map7 = allNode.stream().collect(Collectors.toMap(MeterTreeContract::getNodeCode, l -> l));
+                //先过滤导入节点中的清单
+                List<Map<String, String>> map6 = projectCodeGroup.stream().filter(l -> StringUtils.isBlank(l.get("清单编号"))).collect(Collectors.toList());
+                List<Integer> firstNode = new ArrayList<>();
+                for (Map<String, String> map : map6) {
+                    MeterTreeContract node = map7.get(map.get("节点编号"));
+                    //判断是否已经存在于合同段
+                    if (node == null){
+                        map.put("id",SnowFlakeUtil.getId()+"");
+                        map.put("status",0+"");
+                    }else {
+                        map.put("id",node.getId()+"");
+                        map.put("parentId",node.getParentId()+"");
+                        map.put("ancestors",node.getAncestor());
+                        map.put("status",1+"");
+                    }
+                    //保存每个首节点位置
+                    if (map.get("节点编号").split("-").length == 2){
+                        firstNode.add(map6.indexOf(map));
+                    }
+                }
+                int size = firstNode.size();
+                if (size == 0){
+                    throw new ServiceException("未找到首节点,请检查后重新导入");
+                }
+                //根据首节点分成多个数组
+                List<List<Map<String, String>>> lists = new ArrayList<>();
+                //只有一个节点,直接单独处理
+                if (size == 1){
+                    lists.add(map6);
+                }else {
+                    //规则是首节点下跟着子节点
+                    for (int i = 0; i < size-1; i++) {
+                        lists.add(map6.subList(firstNode.get(i),firstNode.get(i+1)));
+                    }
+                    lists.add(map6.subList(firstNode.get(size-1),map6.size()));
+                }
+                Map<String,Map<String, String>> lastMap = new HashMap<>();
+                Map<String,Map<String, String>> thisMap = new HashMap<>();
+                //循环保存
+                for (List<Map<String, String>> list : lists) {
+                    Map<String, String> form = list.get(0);
+                    String number = form.get("节点编号");
+                    if (form.get("status").equals("0")) {
+                        form.put("parentId",treeContract.getId()+"");
+                        form.put("ancestors",treeContract.getAncestor()+","+treeContract.getId());
+                    }
+                    lastMap.put(number,form);
+                    //循环判断层级
+                    for (Map<String, String> fo : list) {
+                        String num = fo.get("节点编号");
+                        int i = num.split("-").length - 2;
+                        fo.put("nodeTier",i+"");
+                        //设置父编号
+                        if (i != 0) {
+                            fo.put("parentNumber", num.substring(0, num.lastIndexOf("-")));
+                        }
+                    }
+                    Map<String, List<Map<String, String>>> listMap = list.parallelStream().collect(Collectors.groupingBy(l->l.get("nodeTier")));
+                    //根据层级循环,为每一层设置数据
+                    for (int i = 1; i < listMap.size(); i++) {
+                        List<Map<String, String>> forms = listMap.get(i+"");
+                        //如果当前层级不存在数据直接跳出
+                        if (forms == null || forms.size() == 0){
+                            break;
+                        }
+                        for (Map<String, String> f : forms) {
+                            Map<String, String> fo = lastMap.get(f.get("parentNumber"));
+                            if (fo == null){
+                                throw new ServiceException("节点:"+f.get("工程名称")+",未找到上级节点");
+                            }
+                            if (f.get("status").equals("0")) {
+                                //设置父id和祖级id
+                                f.put("parentId",fo.get("id")+"");
+                                f.put("ancestors",fo.get("ancestors")+","+fo.get("id"));
+                            }
+                            thisMap.put(f.get("节点编号"),f);
+                        }
+                        lastMap = thisMap;
+                        thisMap = new HashMap<>();
+                    }
+                    lastMap.clear();
+                }
+                //判断是否有节点没有找到上级节点
+                StringBuilder sb = new StringBuilder();
+                for (Map<String, String> excel : map6) {
+                    if (StringUtils.isBlank(excel.get("parentId"))){
+                        sb.append(excel.get("工程名称")+",");
+                    }
+                }
+                if (sb.length() > 0){
+                    throw new ServiceException("以下工程名称:"+sb.deleteCharAt(sb.length()-1)+"。未找到上级节点,请修改excel后重新导入");
+                }
+
+                List<Map<String, String>> map5 = projectCodeGroup.stream().filter(l -> StringUtils.isNotBlank(l.get("清单编号"))).collect(Collectors.toList());
+                map5.stream().forEach(l->l.put("id",SnowFlakeUtil.getId()+""));
+                map6.addAll(map5);
+                projectCodeGroup = map6;
+
+                //按照节点编号分组
+                Map<String, List<Map<String, String>>> nodeCodeGroup = projectCodeGroup.stream()
+                        .collect(Collectors.groupingBy(
+                                map -> map.get("节点编号"),
+                                LinkedHashMap::new,
+                                Collectors.toList()));
+                nodeCodeGroup.values().forEach(list -> list.forEach(map -> map.entrySet().removeIf(entry -> entry.getKey().isEmpty())));
+
+                int sort = 1;
+
+                /*节点编号匹配*/
+                for (Map.Entry<String, List<Map<String, String>>> listEntry : nodeCodeGroup.entrySet()) {
+
+                    String nodeCode = listEntry.getKey();
+
+                    List<Map<String, String>> rows = listEntry.getValue().stream()
+                            .sorted(Comparator.comparing(map -> {
+                                String formCode = map.get("清单编号");
+                                return formCode == null ? "" : formCode;
+                            })).collect(Collectors.toList());
+                    List<Map<String, String>> nullFormCodeCount = rows.stream()
+                            .filter(map -> ObjectUtil.isEmpty(map.get("清单编号"))).collect(Collectors.toList());
+                    if (nullFormCodeCount.size() == 0) {
+                        throw new RuntimeException("节点编号【" + nodeCode + "】没有清单编号为空的数据,请确认至少有一条");
+                    }
+                    if (nullFormCodeCount.size() > 1) {
+                        throw new RuntimeException("节点编号【" + nodeCode + "】存在多条清单编号为空的数据,请确认是否只有一条");
+                    }
+
+                    MeterTreeContract orDefault = rootNodeChildMap.getOrDefault(nodeCode, null);
+
+                    /*不存在节点编号,新增节点、清单*/
+                    if (orDefault == null) {
+
+                        MeterTreeContract obj = new MeterTreeContract();
+                        BigDecimal money = BigDecimal.ZERO;
+                        BigDecimal moneyChange = BigDecimal.ZERO;
+                        String meterId = nullFormCodeCount.get(0).get("id");
+
+                        for (Map<String, String> map : rows) {
+                            String currCode = map.get("节点编号");
+                            if (currCode.equals(nodeCode)) {
+                                String nodeId = map.get("id");
+                                String formCode = map.get("清单编号");
+                                String nodeName = map.get("工程名称");
+                                String buildPictureTotal = map.get("施工图数量");
+                                String stakeType = map.get("桩号类型");
+                                String startStake = map.get("起始桩号");
+                                String endStake = map.get("结束桩号");
+                                String contractPicture = map.get("合同图号");
+                                String remarks = map.get("备注");
+
+                                //节点
+                                if (ObjectUtil.isEmpty(formCode)) {
+                                    obj.setId(Long.valueOf(nodeId));
+                                    obj.setParentId(Long.valueOf(map.get("parentId")));
+                                    obj.setAncestor(map.get("ancestors"));
+                                    obj.setNodeName(nodeName);
+                                    obj.setNodeCode(currCode);
+                                    obj.setUpdateStatus(0);
+                                    obj.setSort(sort);
+
+                                    /*获取父节点下一级类型,如果父节点是最大类型6,那么默认最大6*/
+                                    if (ObjectUtil.isNotEmpty(treeContract.getNodeType())) {
+                                        obj.setNodeType(treeContract.getNodeType().equals(6) ? 6 : treeContract.getNodeType() + 1);
+                                    }
+
+                                    if (ObjectUtil.isNotEmpty(stakeType)) {
+                                        String upperCase = stakeType.toUpperCase();
+                                        String key = meterStakeTypeMaps.getOrDefault(upperCase, null);
+                                        if (key != null) {
+                                            obj.setStakeType(Integer.parseInt(key));
+                                        }
+                                    }
+                                    obj.setStartStake(startStake);
+                                    obj.setEndStake(endStake);
+                                    obj.setContractPicture(contractPicture);
+                                    obj.setRemarks(remarks);
+
+                                    obj.setTemplateId(treeContract.getTemplateId());
+                                    obj.setProjectId(treeContract.getProjectId());
+                                    obj.setContractId(treeContract.getContractId());
+
+                                    obj.setDataSourceType(4); //导入
+
+                                } else {
+                                    //清单
+                                    ContractInventoryForm contractInventoryForm = contractInventoryFormMapsByFormNumber.getOrDefault(formCode, null);
+                                    if (contractInventoryForm != null) {
+                                        InventoryFormMeter objForm = new InventoryFormMeter();
+                                        objForm.setId(SnowFlakeUtil.getId());
+                                        objForm.setProjectId(treeContract.getProjectId());
+                                        objForm.setContractId(treeContract.getContractId());
+
+                                        if (ObjectUtil.isNotEmpty(SecureUtil.getUser())) {
+                                            objForm.setCreateUser(SecureUtil.getUserId());
+                                            objForm.setUpdateUser(SecureUtil.getUserId());
+                                            if (SecureUtil.getDeptId().contains(",")) {
+                                                objForm.setCreateDept(Long.parseLong(SecureUtil.getDeptId().split(",")[0]));
+                                            } else {
+                                                objForm.setCreateDept(Long.parseLong(SecureUtil.getDeptId()));
+                                            }
+                                        }
+
+                                        objForm.setContractMeterId(Long.valueOf(meterId));
+                                        objForm.setContractFormId(contractInventoryForm.getId());
+
+                                        objForm.setBuildPictureTotal(this.parseString(buildPictureTotal));
+                                        objForm.setChangeBuildPictureTotal(objForm.getBuildPictureTotal());
+                                        objForm.setBuildPictureMoney(objForm.getBuildPictureTotal().multiply(contractInventoryForm.getChangePrice())); //数量*变更后单价
+                                        objForm.setChangeBuildPictureMoney(objForm.getBuildPictureMoney());
+
+                                        /*计量单元节点金额相关累加*/
+                                        money = money.add(objForm.getBuildPictureMoney());
+                                        moneyChange = moneyChange.add(objForm.getChangeBuildPictureMoney());
+
+                                        resultFormListAdd.add(objForm);
+                                    }
+                                }
+                            }
+                        }
+
+                        obj.setBuildPictureMoney(money);
+                        obj.setChangeMoney(moneyChange);
+                        resultNodeListAdd.add(obj);
+                        sort++;
+
+                    } else {
+                        /*存在节点编号,只同步累加或者新增清单*/
+                        /*获取该节点的原始的清单中间信息*/
+                        List<InventoryFormMeter> inventoryFormMeters = inventoryFormMeterMapsGroupByContractMeterId.get(orDefault.getId());
+                        //修改1增加导入不挂载表单校验
+                        Map<String, ContractInventoryForm> ysContractInventoryFormMapsByFormNumber = new HashMap<>();
+                        if (inventoryFormMeters != null && inventoryFormMeters.size() > 0) {
+                            for (InventoryFormMeter objForm : inventoryFormMeters) {
+                                /*获取原始清单详细详细*/
+                                ContractInventoryForm contractInventoryForm = contractInventoryFormMapsById.getOrDefault(objForm.getContractFormId(), null);
+                                if (contractInventoryForm != null) {
+                                    ysContractInventoryFormMapsByFormNumber.put(contractInventoryForm.getFormNumber(), contractInventoryForm);
+                                }
+                            }
+                        }
+
+                            for (Map<String, String> map : rows) {
+                                String formCode = map.get("清单编号");
+                                if (formCode.isEmpty()) {
+                                    continue;
+                                }
+                                String buildPictureTotal = map.get("施工图数量");
+
+                                /*获取原始清单详细详细*/
+                                ContractInventoryForm contractInventoryForm = ysContractInventoryFormMapsByFormNumber.getOrDefault(formCode, null);
+                                if (contractInventoryForm != null) {
+                                    //相同清单编号,则同步累加
+                                    if (contractInventoryForm.getFormNumber().equals(formCode)) {
+                                        /*获取到对应的中间关联清单信息*/
+                                        String key = contractInventoryForm.getId() + ":" + orDefault.getId();
+                                        InventoryFormMeter formUpdate = inventoryFormMeterMapsByFormIdAndMeterId.getOrDefault(key, null);
+                                        if (formUpdate != null) {
+
+                                            /*判断是否被引用、变更*/
+                                            ChangeTokenInventory orDefault1 = changeTokenInventoryMapsByFormIdAndMeterId.getOrDefault(key, null);
+                                            InventoryFormApply orDefault2 = inventoryFormApplyMapsByFormIdAndMeterId.getOrDefault(key, null);
+                                            if (orDefault1 != null || orDefault2 != null) {
+                                                continue;
+                                            }
+
+                                            //累加
+                                            BigDecimal bigDecimal = this.parseString(buildPictureTotal);
+                                            formUpdate.setBuildPictureTotal(formUpdate.getBuildPictureTotal().add(bigDecimal));
+
+                                            formUpdate.setChangeBuildPictureTotal(formUpdate.getBuildPictureTotal());
+
+                                            formUpdate.setBuildPictureMoney(formUpdate.getBuildPictureTotal().multiply(contractInventoryForm.getChangePrice())); //数量*变更后单价
+
+                                            formUpdate.setChangeBuildPictureMoney(formUpdate.getBuildPictureMoney());
+
+                                            /*更改数量*/
+                                            resultFormListUpdate.add(formUpdate);
+
+                                            /*更新节点金额*/
+                                            updateNodeSet.add(orDefault.getId());
+
+                                        }
+                                    }
+
+                                } else {
+
+                                    //没有获取到,那么证明是不相同清单编号,则获取对应的清单数据,进行新增清单
+                                    ContractInventoryForm contractInventoryFormAdd = contractInventoryFormMapsByFormNumber.getOrDefault(formCode, null);
+                                    if (contractInventoryFormAdd != null) {
+                                        InventoryFormMeter formAdd = new InventoryFormMeter();
+                                        formAdd.setId(SnowFlakeUtil.getId());
+                                        formAdd.setProjectId(orDefault.getProjectId());
+                                        formAdd.setContractId(orDefault.getContractId());
+
+                                        if (ObjectUtil.isNotEmpty(SecureUtil.getUser())) {
+                                            formAdd.setCreateUser(SecureUtil.getUserId());
+                                            formAdd.setUpdateUser(SecureUtil.getUserId());
+                                            if (SecureUtil.getDeptId().contains(",")) {
+                                                formAdd.setCreateDept(Long.parseLong(SecureUtil.getDeptId().split(",")[0]));
+                                            } else {
+                                                formAdd.setCreateDept(Long.parseLong(SecureUtil.getDeptId()));
+                                            }
+                                        }
+
+                                        formAdd.setContractMeterId(orDefault.getId());
+                                        formAdd.setContractFormId(contractInventoryFormAdd.getId());
+
+                                        formAdd.setBuildPictureTotal(this.parseString(buildPictureTotal));
+                                        formAdd.setChangeBuildPictureTotal(formAdd.getBuildPictureTotal());
+                                        formAdd.setBuildPictureMoney(formAdd.getBuildPictureTotal().multiply(contractInventoryFormAdd.getChangePrice())); //数量*变更后单价
+                                        formAdd.setChangeBuildPictureMoney(formAdd.getBuildPictureMoney());
+
+                                        /*新增清单*/
+                                        resultFormListAdd.add(formAdd);
+
+                                        /*更新节点金额*/
+                                        updateNodeSet.add(orDefault.getId());
+
+                                    }
+                                }
+                            }
+                    }
+                }
+            }
+        }
+
+        boolean var = false;
+
+        /*节点*/
+        if (resultNodeListAdd.size() > 0) {
+            //判断要新增的数据中,清单编号是否已经存在
+            List<String> collect = resultNodeListAdd.stream().map(l -> l.getNodeCode()).collect(Collectors.toList());
+            if (collect.size() > 0){
+                List<String> numbers = baseMapper.getAllEqualsNumber(meterTreeContract.getContractId(),collect);
+                if (numbers.size() > 0){
+                    throw new ServiceException("以下节点编号已经存在:["+StringUtils.join(numbers,",")+"],请修改excel后重新导入");
+                }
+            }
+            this.saveBatch(resultNodeListAdd, 1000);
+            var = true;
+        }
+
+        /*清单中间新增*/
+        if (resultFormListAdd.size() > 0) {
+            inventoryFormMeterMapper.batchInsert(resultFormListAdd);
+            var = true;
+        }
+
+        /*清单中间数量修改*/
+        if (resultFormListUpdate.size() > 0) {
+            for (InventoryFormMeter inventoryFormMeter : resultFormListUpdate) {
+                String sql = "UPDATE s_inventory_form_meter " +
+                        "SET build_picture_total = ? ," +
+                        "change_build_picture_total = ? ," +
+                        "build_picture_money = ? ," +
+                        "change_build_picture_money = ? WHERE id = ?";
+                jdbcTemplate.update(sql,
+                        inventoryFormMeter.getBuildPictureTotal(),
+                        inventoryFormMeter.getChangeBuildPictureTotal(),
+                        inventoryFormMeter.getBuildPictureMoney(),
+                        inventoryFormMeter.getChangeBuildPictureMoney(),
+                        inventoryFormMeter.getId());
+            }
+            var = true;
+        }
+
+        /*节点金额修改*/
+        if (updateNodeSet.size() > 0) {
+            for (Long treeContractId : updateNodeSet) {
+                /*重新计算节点下的清单数量金额等*/
+                List<ContractFromVO> decompositionList = contractInventoryFormMapper.getNodeResolveForm(meterTreeContract.getContractId(), treeContractId);
+                if (ObjectUtil.isNotEmpty(decompositionList) && decompositionList.size() > 0) {
+                    BigDecimal moneyAll = BigDecimal.ZERO;
+                    BigDecimal moneyChangeAll = BigDecimal.ZERO;
+
+                    for (ContractFromVO contractFromVO : decompositionList) {
+                        BigDecimal buildPictureTotal = contractFromVO.getBuildPictureTotal(); //变更前数量
+                        BigDecimal changeBuildPictureTotal = contractFromVO.getChangeBuildPictureTotal(); //变更后数量
+                        BigDecimal currentPrice = contractFromVO.getCurrentPrice(); //单价
+
+                        BigDecimal buildPictureMoney = buildPictureTotal.multiply(currentPrice); //变更前金额
+                        BigDecimal changeBuildPictureMoney = changeBuildPictureTotal.multiply(currentPrice); //变更后金额
+
+                        moneyAll = moneyAll.add(buildPictureMoney);
+                        moneyChangeAll = moneyChangeAll.add(changeBuildPictureMoney);
+                    }
+
+                    String sql = "UPDATE s_meter_tree_contract " +
+                            "SET build_picture_money = ?, " +
+                            "change_money = ? WHERE id = ?";
+                    jdbcTemplate.update(sql,
+                            moneyAll,
+                            moneyChangeAll,
+                            treeContractId);
+                }
+                var = true;
+            }
+        }
+        return true;
+    }
+
     /**
      * 获取对应的父级的ancestor字段
      *