From af389156a78401b1e51807efe90b7310fc4c20f6 Mon Sep 17 00:00:00 2001
From: Fixiaobai <fixiaobai@163.com>
Date: 星期五, 10 十一月 2023 19:50:28 +0800
Subject: [PATCH] Changes11
---
mes-basic/src/main/java/com/chinaztt/mes/basic/service/impl/BasicParamTemplateServiceImpl.java | 194 ++++++++++++++++++++++++++++++++++++++++++++++--
1 files changed, 185 insertions(+), 9 deletions(-)
diff --git a/mes-basic/src/main/java/com/chinaztt/mes/basic/service/impl/BasicParamTemplateServiceImpl.java b/mes-basic/src/main/java/com/chinaztt/mes/basic/service/impl/BasicParamTemplateServiceImpl.java
index 8fb7751..ef6f5c6 100644
--- a/mes-basic/src/main/java/com/chinaztt/mes/basic/service/impl/BasicParamTemplateServiceImpl.java
+++ b/mes-basic/src/main/java/com/chinaztt/mes/basic/service/impl/BasicParamTemplateServiceImpl.java
@@ -36,6 +36,8 @@
import com.chinaztt.mes.basic.service.BasicParamTemplateService;
import com.chinaztt.mes.basic.util.DictUtils;
import com.chinaztt.mes.common.numgen.NumberGenerator;
+import com.chinaztt.mes.common.util.JsonUtil;
+import com.chinaztt.ztt.admin.api.entity.SysDictItem;
import com.chinaztt.ztt.common.oss.service.OssTemplate;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@@ -46,8 +48,8 @@
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
+import java.util.stream.Collectors;
/**
* 宸ュ簭妯℃澘
@@ -69,8 +71,23 @@
private DictUtils dictUtils;
@Override
- public IPage<List<Param>> getParamById(Page page, QueryWrapper<ParamDTO> gen) {
- return paramMapper.getParamById(page, gen);
+ public List<Map<String, Object>> getParamById(Page page, long technologyOperationTemplateId) {
+ QueryWrapper<ParamJoinTemplate>gen=new QueryWrapper<>();
+ gen.lambda().eq(ParamJoinTemplate::getParentId,0)
+ .eq(ParamJoinTemplate::getTechnologyOperationTemplateId,technologyOperationTemplateId);
+ List<ParamJoinTemplate> paramJoinTemplates = paramJoinTemplateMapper.selectList(gen);
+ if(paramJoinTemplates.size()<1){
+ return new ArrayList<>();
+ }
+ List<SysDictItem> dict = dictUtils.getDict("technology_param");
+ List<Long>longList=new ArrayList<>();
+ paramJoinTemplates.forEach(p->{
+ longList.add(p.getTechnologyOperationParamId());
+ });
+ //QueryWrapper<Param>queryWrapper=new QueryWrapper<>();
+ //queryWrapper.lambda().in(Param::getId,longList);
+ //List<Param> params = paramMapper.selectList(queryWrapper);
+ return getTree(longList,dict,technologyOperationTemplateId);
}
@@ -82,7 +99,8 @@
@Override
- public List<ParamDTO> relateTypeTemplate(List<ParamJoinTemplate> operationParamJoinTemplate) {
+ @Transactional(rollbackFor = Exception.class)
+ public List<Map<String, Object>> relateTypeTemplate(List<ParamJoinTemplate> operationParamJoinTemplate) {
List<ParamJoinTemplate> newOperationParamJoinTemplateList = new ArrayList<>();
List<ParamDTO> paramList = new ArrayList<>();
if (CollectionUtil.isNotEmpty(operationParamJoinTemplate)) {
@@ -98,17 +116,175 @@
newOperationParamJoinTemplateList.add(newParamJoinTemplate);
}
for (ParamJoinTemplate newOperationParam : newOperationParamJoinTemplateList) {
+ long firstId=newOperationParam.getTechnologyOperationParamId();
+ long templateId=newOperationParam.getTechnologyOperationTemplateId();
paramJoinTemplateMapper.insert(newOperationParam);
+ //浜岀骇鍙傛暟
+ QueryWrapper<Param>queryWrapperSecond = new QueryWrapper<Param>();
+ queryWrapperSecond.lambda().eq(Param::getParentId,newOperationParam.getTechnologyOperationParamId());
+ List<Param> paramList1 = paramMapper.selectList(queryWrapperSecond);
+ if(paramList1.size()>0){
+ for (int i = 0; i < paramList1.size(); i++) {
+ Param secondParam = paramList1.get(i);
+ ParamJoinTemplate templateSecond=new ParamJoinTemplate();
+ templateSecond.setSort(i+1L);
+ templateSecond.setTechnologyOperationParamId(secondParam.getId());
+ templateSecond.setTechnologyOperationTemplateId(templateId);
+ templateSecond.setParentId(firstId);
+ paramJoinTemplateMapper.insert(templateSecond);
+ //涓夌骇鍙傛暟
+ QueryWrapper<Param>queryWrapperThird = new QueryWrapper<Param>();
+ queryWrapperThird.lambda().eq(Param::getParentId,secondParam.getId());
+ List<Param> selectList = paramMapper.selectList(queryWrapperThird);
+ if(selectList.size()>0){
+ for (int j = 0; j < selectList.size(); j++) {
+ Param thirdParam = selectList.get(j);
+ ParamJoinTemplate templateThird=new ParamJoinTemplate();
+ templateThird.setSort(j+1L);
+ templateThird.setTechnologyOperationParamId(thirdParam.getId());
+ templateThird.setTechnologyOperationTemplateId(templateId);
+ templateThird.setParentId(secondParam.getId());
+ paramJoinTemplateMapper.insert(templateThird);
+ }
+ }
+ }
+ }
}
- paramList = paramMapper.getTemplateParam(operationParamJoinTemplate.get(0).getTechnologyOperationTemplateId());
+ //paramList = paramMapper.getTemplateParam(operationParamJoinTemplate.get(0).getTechnologyOperationTemplateId());
}
- return paramList;
+ List<SysDictItem> dict = dictUtils.getDict("technology_param");
+ QueryWrapper<ParamJoinTemplate>templateQueryWrapper=new QueryWrapper<>();
+ templateQueryWrapper.lambda().eq(ParamJoinTemplate::getParentId,0).select(ParamJoinTemplate::getTechnologyOperationParamId);
+ List<Long>longList=new ArrayList<>();
+ paramJoinTemplateMapper.selectList(templateQueryWrapper).forEach(p->{
+ longList.add(p.getTechnologyOperationParamId());
+ });
+ return getTree(longList,dict,operationParamJoinTemplate.get(0).getTechnologyOperationTemplateId());
}
+
+ public List<Map<String,Object>> getTree(List records,List<SysDictItem> dict,long templateId){
+ QueryWrapper<ParamJoinTemplate>templateQueryWrapper=new QueryWrapper<>();
+ templateQueryWrapper.lambda().eq(ParamJoinTemplate::getTechnologyOperationTemplateId,templateId);
+ List<ParamJoinTemplate> paramJoinTemplates = paramJoinTemplateMapper.selectList(templateQueryWrapper);
+ List<Map<String,Object>> all = new ArrayList<>();
+ records.forEach(l->{
+ //涓�绾у弬鏁�
+ Param paramFirst = paramMapper.selectById(Long.parseLong(String.valueOf(l)));
+
+ Map pojo = JsonUtil.jsonToPojo(JsonUtil.jsonToString(paramFirst), Map.class);
+ Optional.ofNullable(pojo.get("type")).ifPresent(o->{
+ pojo.put("type",dict.stream().filter(d-> Objects.equals(String.valueOf(d.getValue()),pojo.get("type"))).collect(Collectors.toList()).get(0).getLabel());
+ });
+ String id = String.valueOf(pojo.get("id"));
+ List<ParamJoinTemplate> collect = paramJoinTemplates.stream().filter(p -> Objects.equals(id, String.valueOf(p.getTechnologyOperationParamId()))).collect(Collectors.toList());
+ if(collect.size()>0) {
+ pojo.put("paramValue", collect.get(0).getDefaultValue());
+ }else {
+ pojo.put("paramValue", "");
+ }
+ QueryWrapper<Param>queryWrapper=new QueryWrapper<>();
+ queryWrapper.lambda().eq(Param::getParentId,pojo.get("id"));
+ List<Param> secondList = paramMapper.selectList(queryWrapper);
+ QueryWrapper<ParamJoinTemplate>queryWrapperTem=new QueryWrapper<>();
+ queryWrapperTem.lambda().eq(ParamJoinTemplate::getParentId,Long.valueOf(String.valueOf(l)));
+ List<ParamJoinTemplate> paramJoinTemplates1 = paramJoinTemplateMapper.selectList(queryWrapperTem);
+ //鍘婚櫎涓嶇浉鍏崇殑鏁版嵁
+ secondList.removeIf(s -> paramJoinTemplates1.stream().noneMatch(p->Objects.equals(s.getId(),p.getTechnologyOperationParamId())));
+ //娌℃湁children鐩存帴娣诲姞
+ if(secondList.isEmpty()){
+ Map<String,Object> oneMap = new HashMap<>();
+ oneMap.put("code",pojo.get("code"));
+ oneMap.put("paramItem",pojo.get("parameterItem"));
+ oneMap.put("paramItemTwo","");
+ oneMap.put("paramItemThree","");
+ oneMap.put("oneId", com.chinaztt.mes.common.util.StringUtils.defaultString( String.valueOf(pojo.get("id")),""));
+ oneMap.put("paramType", com.chinaztt.mes.common.util.StringUtils.defaultString((String) pojo.get("type"),""));
+ oneMap.put("paramFormat", com.chinaztt.mes.common.util.StringUtils.defaultString((String) pojo.get("parameterFormat"),""));
+ oneMap.put("unit", com.chinaztt.mes.common.util.StringUtils.defaultString((String) pojo.get("unit"),""));
+ oneMap.put("parentId",pojo.get("parentId"));
+ List<ParamJoinTemplate> collectSecond = paramJoinTemplates.stream().filter(p -> Objects.equals(String.valueOf(pojo.get("id")),String.valueOf( p.getTechnologyOperationParamId()))).collect(Collectors.toList());
+ if(collectSecond.size()>0){
+ oneMap.put("paramValue",collectSecond.get(0).getDefaultValue());
+ }else {
+ oneMap.put("paramValue","");
+ }
+ all.add(oneMap);
+ }
+ secondList.forEach(s->{
+ Map second = JsonUtil.jsonToPojo(JsonUtil.jsonToString(s), Map.class);
+ List<ParamJoinTemplate> collectSecond = paramJoinTemplates.stream().filter(p -> Objects.equals(s.getId(), p.getTechnologyOperationParamId())).collect(Collectors.toList());
+ if(collectSecond.size()>0){
+ second.put("paramValue",collectSecond.get(0).getDefaultValue());
+ s.setParamValue(String.valueOf(second.get("paramValue")));
+ }else {
+ second.put("paramValue","");
+ s.setParamValue(String.valueOf(second.get("paramValue")));
+ }
+ Optional.ofNullable(second.get("type")).ifPresent(o->{
+ List<SysDictItem> collect1 = dict.stream().filter(d -> Objects.equals(String.valueOf(d.getValue()), second.get("type"))).collect(Collectors.toList());
+ if(collect1.size()>0){
+ s.setType(String.valueOf(collect1.get(0).getLabel()));
+ }
+ //second.put("type",dict.stream().filter(d-> Objects.equals(String.valueOf(d.getValue()),second.get("type"))).collect(Collectors.toList()).get(0).getLabel());
+ //s.setType(String.valueOf(second.get("type")));
+ });
+ QueryWrapper<Param>queryWrapperSecond=new QueryWrapper<>();
+ queryWrapperSecond.lambda().eq(Param::getParentId,second.get("id"));
+ List<Param> third = paramMapper.selectList(queryWrapperSecond);
+ QueryWrapper<ParamJoinTemplate>queryWrapperThird=new QueryWrapper<>();
+ queryWrapperThird.lambda().eq(ParamJoinTemplate::getParentId,Long.valueOf(String.valueOf(s.getId())));
+ List<ParamJoinTemplate> paramJoinTemplates2 = paramJoinTemplateMapper.selectList(queryWrapperThird);
+ third.removeIf(t -> paramJoinTemplates2.stream().noneMatch(p->Objects.equals(p.getTechnologyOperationParamId(),t.getId())));
+ if(third.isEmpty()){
+ Param p = new Param();
+ p.setType(s.getType());
+ p.setParamValue(s.getParamValue());
+ //p.setParameterFormat(null);
+ //p.setParamValue(s.getParamValue());
+ p.setUnit(s.getUnit());
+ p.setParentId(s.getParentId());
+ third.add(p);
+ }
+ third.forEach(t->{
+ Optional.ofNullable(t.getType()).ifPresent(o->{
+ List<SysDictItem> collect1 = dict.stream().filter(d -> Objects.equals(String.valueOf(d.getValue()), t.getType())).collect(Collectors.toList());
+ if(collect1.size()>0){
+ t.setType(collect1.get(0).getLabel());
+ }
+ });
+ Map<String,Object> allMap = new HashMap<>();
+ List<ParamJoinTemplate> collectThird = paramJoinTemplates.stream().filter(p -> Objects.equals(t.getId(), p.getTechnologyOperationParamId())).collect(Collectors.toList());
+ if(collectThird.size()>0){
+ allMap.put("paramValue",collectThird.get(0).getDefaultValue());
+ }else {
+ allMap.put("paramValue","");
+ }
+ allMap.put("code",pojo.get("code"));
+ allMap.put("paramItem", com.chinaztt.mes.common.util.StringUtils.defaultString((String) pojo.get("parameterItem"),""));
+ allMap.put("oneId", com.chinaztt.mes.common.util.StringUtils.defaultString( String.valueOf(pojo.get("id")),""));
+ allMap.put("twoId", com.chinaztt.mes.common.util.StringUtils.defaultString( String.valueOf(second.get("id")) ,""));
+ allMap.put("threeId", com.chinaztt.mes.common.util.StringUtils.defaultString(String.valueOf(t.getId()),""));
+ allMap.put("paramItemTwo", com.chinaztt.mes.common.util.StringUtils.defaultString((String) second.get("parameterItem"),""));
+ allMap.put("paramItemThree", com.chinaztt.mes.common.util.StringUtils.defaultString(t.getParameterItem(),""));
+ allMap.put("paramType", com.chinaztt.mes.common.util.StringUtils.defaultString(t.getType(),""));
+ //allMap.put("paramFormat", com.chinaztt.mes.common.util.StringUtils.defaultString(t.getParameterFormat(),""));
+ allMap.put("unit", com.chinaztt.mes.common.util.StringUtils.defaultString(t.getUnit(),""));
+ allMap.put("parentId",t.getParentId());
+ allMap.put("paramValue",t.getParamValue());
+ all.add(allMap);
+ });
+ });
+ });
+ return all;
+ }
+
@Override
public boolean deleteParamTemplate(ParamJoinTemplate operationParamJoinTemplate) {
- paramJoinTemplateMapper.delete(Wrappers.<ParamJoinTemplate>lambdaQuery().eq(ParamJoinTemplate::getTechnologyOperationParamId, operationParamJoinTemplate.getTechnologyOperationParamId()).eq(ParamJoinTemplate::getTechnologyOperationTemplateId, operationParamJoinTemplate.getTechnologyOperationTemplateId()));
- return false;
+ System.out.println("------------------------->"+operationParamJoinTemplate);
+ return paramJoinTemplateMapper
+ .deleteByCondition( operationParamJoinTemplate.getTechnologyOperationParamId(),
+ operationParamJoinTemplate.getTechnologyOperationTemplateId())>0;
}
@Override
--
Gitblit v1.9.3