From 694374bb1c6c08e3e79a65f575922e61c5c971fc Mon Sep 17 00:00:00 2001
From: xiejun <xj@2023>
Date: 星期四, 15 六月 2023 10:29:57 +0800
Subject: [PATCH] 历史导入功能添加
---
Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java | 1540 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 1,528 insertions(+), 12 deletions(-)
diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java
index 14905bf..d89aac3 100644
--- a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java
@@ -2,12 +2,16 @@
import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.common.utils.StringUtils;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.vci.ubcs.code.bo.AttributeValue;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.bo.CodeTemplateAttrSqlBO;
import com.vci.ubcs.code.dto.CodeOrderDTO;
+import com.vci.ubcs.code.entity.CodeAllCode;
+import com.vci.ubcs.code.entity.CodeClassify;
import com.vci.ubcs.code.enumpack.CodeDefaultLC;
import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
+import com.vci.ubcs.code.lifecycle.CodeAllCodeLC;
import com.vci.ubcs.code.mapper.CommonsMapper;
import com.vci.ubcs.code.service.*;
import com.vci.ubcs.code.util.ClientBusinessObject;
@@ -16,6 +20,8 @@
import com.vci.ubcs.code.vo.webserviceModel.attrmap.DataObjectVO;
import com.vci.ubcs.code.vo.webserviceModel.attrmap.RowDatas;
import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultDataObjectDetailDO;
+import com.vci.ubcs.omd.feign.IBtmTypeClient;
+import com.vci.ubcs.omd.vo.BtmTypeVO;
import com.vci.ubcs.starter.bo.WriteExcelData;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.poi.bo.ReadExcelOption;
@@ -26,6 +32,8 @@
import com.vci.ubcs.starter.revision.model.BaseModel;
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
import com.vci.ubcs.starter.util.LocalFileUtil;
+import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
+import com.vci.ubcs.starter.web.constant.QueryOptionConstant;
import com.vci.ubcs.starter.web.enumpck.BooleanEnum;
import com.vci.ubcs.starter.web.enumpck.VciFieldTypeEnum;
import com.vci.ubcs.starter.web.pagemodel.DataGrid;
@@ -36,6 +44,7 @@
import com.vci.ubcs.starter.web.util.*;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.map.HashedMap;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
@@ -43,17 +52,17 @@
import org.apache.poi.ss.usermodel.RichTextString;
import org.apache.poi.ss.usermodel.Workbook;
import org.springblade.core.redis.cache.BladeRedis;
+import org.springblade.core.tool.api.R;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
-import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
-
import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.stream.Collectors;
@@ -66,6 +75,21 @@
@Service
@Slf4j
public class MdmIOServiceImpl implements MdmIOService {
+
+
+ /**
+ * 瀛楁
+ */
+ public static final String ROW_INDEX = "LAY_TABLE_INDEX";
+
+ /**
+ * 閿欒淇℃伅鐨勫瓧娈�
+ */
+ public static final String ERROR_MSG = "errorMsg";
+
+ @Value("${batchadd.exportattr.type:鍩烘湰淇℃伅}")
+ public String BATCHADD_EXCEPORT_ATTR_TYPE;
+
@Value("${batchadd.redis.time:6000000}")
public int BATCHADD_REDIS_TIME;
/**
@@ -74,11 +98,17 @@
@Resource
private ICodeClassifyService classifyService;
+
/**
* 閫氱敤鏌ヨ
*/
@Resource
private CommonsMapper commonsMapper;
+ /****
+ * 鐮佸�兼湇鍔�
+ */
+ @Resource
+ ICodeAllCodeService codeAllCodeService;
/**
* 妯℃澘鐨勬湇鍔�
@@ -111,6 +141,178 @@
*/
@Autowired
private FormulaServiceImpl formulaService;
+ /**
+ * 瑙勫垯鐨勬湇鍔�
+ */
+ @Autowired
+ private ICodeRuleService ruleService;
+ /**
+ * 涓氬姟绫诲瀷鐨勬湇鍔�
+ */
+ @Autowired
+ private IBtmTypeClient btmTypeClient;
+ /**
+ * 鎵归噺鐢宠锛氶�夊彇閫変腑鍒嗙被涓嬬殑鎵�鏈夋ā鏉垮叧閿睘鎬э紝鐩镐技灞炴�э紝蹇呭～灞炴�э紝鍐欏叆execl涓�
+ *
+ * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+ * @return excel鐨勬枃浠跺湴鍧�
+ */
+ @Override
+ public String downloadTopImportExcel(String codeClassifyOid){
+ List<CodeClassifyTemplateVO> templateVOList=new ArrayList<>();
+ VciBaseUtil.alertNotNull("瀵煎嚭妯℃澘","瀵煎嚭鐨勯厤缃�",codeClassifyOid,"涓婚搴撳垎绫荤殑涓婚敭");
+ CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);
+ templateVOList= templateService.childTemplates(codeClassifyOid);
+ List<CodeClassifyVO> codeClassifyVOS=classifyService.getIdPathToNamePathByParentId(codeClassifyOid,true);
+ WriteExcelOption eo = new WriteExcelOption();
+ LinkedHashMap<String,CodeClassifyTemplateAttrVO> allFieldToOutNameMap=new LinkedHashMap<>();
+ templateVOList.stream().forEach(templateVO -> {
+ //缁勫悎鏍煎紡鐨勪笉瀵煎叆锛�
+ // 鏋氫妇鐨勬彁渚涘簭鍒楃殑閫夋嫨
+ //鏃堕棿鍏ㄩ儴缁熶竴涓簓yyy-MM-dd HH:mm:ss
+ //鍙傜収鐨勮嚜琛岃緭鍏ュ悕绉�
+ //鍒嗙被娉ㄥ叆鐨勪笉鐢紝閮芥槸瀵煎叆鍚庤嚜鍔ㄥ鐞嗙殑
+ //缂栫爜锛岀姸鎬佺瓑瀛楁涓嶅鍏�
+ List<CodeClassifyTemplateAttrVO> templateAttrVOS = templateVO.getAttributes().stream().filter(s ->
+ !DEFAULT_ATTR_LIST.contains(s.getId())
+ && StringUtils.isBlank(s.getComponentRule())
+ && StringUtils.isBlank(s.getClassifyInvokeAttr())
+ && (VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
+ ).collect(Collectors.toList());
+ if(CollectionUtils.isEmpty(templateAttrVOS)){
+ throw new VciBaseException("妯℃澘娌℃湁閰嶇疆浠讳綍銆愯〃鍗曟樉绀恒�戜负銆愭槸銆戠殑灞炴��");
+ }
+ templateAttrVOS.stream().forEach(codetemplateAttr ->{
+ String field=codetemplateAttr.getId();
+ String name=codetemplateAttr.getName();
+ CodeClassifyTemplateAttrVO codeBaseAttributeDTO=new CodeClassifyTemplateAttrVO();
+ boolean res=codetemplateAttr.getAttributeGroup().equals(BATCHADD_EXCEPORT_ATTR_TYPE)//鍩烘湰灞炴�у瓧娈垫樉绀�
+ ||(StringUtils.isNotBlank(codetemplateAttr.getKeyAttrFlag())&&Boolean.parseBoolean(codetemplateAttr.getKeyAttrFlag()))//鍏抽敭灞炴�х殑瀛樺叆
+ ||(StringUtils.isNotBlank(codetemplateAttr.getSameRepeatAttrFlag())&&Boolean.parseBoolean(codetemplateAttr.getSameRepeatAttrFlag())) //鐩镐技灞炴�х殑瀛樺叆
+ ||(StringUtils.isNotBlank(codetemplateAttr.getRequireFlag())&&Boolean.parseBoolean(codetemplateAttr.getRequireFlag()));
+ if(allFieldToOutNameMap.containsKey(name)){//濡傛灉瀛樺湪鐨勮瘽鍒欓渶瑕佹牴鎹叿浣撶殑鍘昏祴鍊�
+ codeBaseAttributeDTO= allFieldToOutNameMap.get(name);
+ if(StringUtils.isNotBlank(codetemplateAttr.getKeyAttrFlag())&&Boolean.parseBoolean(codetemplateAttr.getKeyAttrFlag())){
+ codeBaseAttributeDTO.setKeyAttrFlag(codetemplateAttr.getKeyAttrFlag());//灞炴�у叧閿睘鎬�
+ }
+ if(StringUtils.isNotBlank(codetemplateAttr.getRequireFlag())&&Boolean.parseBoolean(codetemplateAttr.getRequireFlag())){
+ codeBaseAttributeDTO.setRequireFlag(codetemplateAttr.getRequireFlag());//灞炴�у繀濉」
+ }
+ if(StringUtils.isNotBlank(codetemplateAttr.getSameRepeatAttrFlag())&&Boolean.parseBoolean(codetemplateAttr.getSameRepeatAttrFlag())){
+ codeBaseAttributeDTO.setSameRepeatAttrFlag(codetemplateAttr.getSameRepeatAttrFlag());//灞炴�х浉浼煎睘鎬�
+ }
+ }else if(res){
+ allFieldToOutNameMap.put(name,codetemplateAttr);
+ }
+ });
+ });
+ //鏁寸悊濂芥墍鏈夋ā鏉块渶瑕佸啓鍏xecl鐨勫睘鎬т俊鎭�
+ Workbook workbook = new HSSFWorkbook();
+ LinkedList<WriteExcelData> excelDataList = new LinkedList<>();
+ if(!CollectionUtils.isEmpty(allFieldToOutNameMap)){
+ excelDataList.add(new WriteExcelData(0,0,"鍒嗙被璺緞"));
+ final int[] index = {0};
+ allFieldToOutNameMap.values().stream().forEach(attrVO -> {
+ Object text = attrVO.getName();
+ text = exportKeyAndRequired(workbook,attrVO,text);
+ int colIndex = 1 + index[0]++;
+ WriteExcelData excelData = new WriteExcelData(0, colIndex, text);
+ if(StringUtils.isNotBlank(attrVO.getCodeDateFormat())
+ || VciFieldTypeEnum.VTDateTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())
+ || VciFieldTypeEnum.VTDate.name().equalsIgnoreCase(attrVO.getAttributeDataType())
+ ||VciFieldTypeEnum.VTTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
+ excelData.setDateFormat(VciDateUtil.DateTimeFormat);
+ }
+ if(text instanceof RichTextString){
+ excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+ }
+ excelDataList.add(excelData);
+ if(StringUtils.isNotBlank(attrVO.getEnumString()) || StringUtils.isNotBlank(attrVO.getEnumId())){
+ //娣诲姞鏁版嵁鏈夋晥鎬�
+ List<String> enumValueList = new ArrayList<>();
+ enumValueList.add("");
+ List<KeyValue> valueList = engineService.listComboboxItems(attrVO);
+ if(!CollectionUtils.isEmpty(valueList)){
+ valueList.stream().forEach(kv->{
+ enumValueList.add(kv.getValue());
+ });
+ }
+ //榛樿鍔�1涓囨潯
+ WriteExcelData ed = new WriteExcelData(1,colIndex,"");
+ ed.setRowTo(100);
+ ed.setColTo(colIndex);
+ ed.setValidation(true);
+ ed.setValidationDataList(enumValueList);
+ ed.setValidationErrorMsg("璇峰湪搴忓垪涓�夋嫨姝ｇ‘鐨勫��");
+ excelDataList.add(ed);
+ }
+ if(VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
+ List<String> booleanList = new ArrayList<>();
+ booleanList.add("鏄�");
+ booleanList.add("鍚�");
+ //榛樿鍔�1涓囨潯
+ WriteExcelData ed = new WriteExcelData(1,colIndex,"");
+ ed.setRowTo(100);
+ ed.setColTo(colIndex);
+ ed.setValidation(true);
+ ed.setValidationDataList(booleanList);
+ ed.setValidationErrorMsg("璇峰湪搴忓垪涓�夋嫨姝ｇ‘鐨勫��");
+ excelDataList.add(ed);
+ }
+ });
+ eo.addSheetDataList(codeClassifyVO.getName()+"瀵煎叆妯℃澘",excelDataList);
+ }
+ LinkedList<WriteExcelData> classPathList = new LinkedList<>();
+ classPathList.add(new WriteExcelData(0,0,"鍒嗙被灞傜骇"));
+
+ WriteExcelData idPathWriteExcelTitle=new WriteExcelData(0,1,"鍒嗙被ID璺緞");
+ idPathWriteExcelTitle.setWidth(20);
+ idPathWriteExcelTitle.setCenter(false);
+ classPathList.add(idPathWriteExcelTitle);
+ WriteExcelData namePathWriteExcelTitle=new WriteExcelData(0,2,"鍒嗙被鍚嶇О璺緞");
+ namePathWriteExcelTitle.setWidth(20);
+ namePathWriteExcelTitle.setCenter(false);
+ classPathList.add(namePathWriteExcelTitle);
+
+
+ final int[] rowIndex = {1};
+ codeClassifyVOS.stream().forEach(codeClassifyVO1 -> {
+ classPathList.add(new WriteExcelData(rowIndex[0],0,codeClassifyVO1.getDataLevel()));
+
+ String idPath=codeClassifyVO1.getIdPath().startsWith("#")?codeClassifyVO1.getIdPath().substring(1):codeClassifyVO1.getIdPath();
+ WriteExcelData idPathWriteExcelData=new WriteExcelData(rowIndex[0],1,idPath);
+ idPathWriteExcelData.setWidth(30);
+ idPathWriteExcelData.setCenter(false);
+ classPathList.add(idPathWriteExcelData);
+
+ String namePath=codeClassifyVO1.getNamePath().startsWith("#")?codeClassifyVO1.getNamePath().substring(1):codeClassifyVO1.getNamePath();
+ WriteExcelData namePathWriteExcelData= new WriteExcelData(rowIndex[0],2,namePath);
+ namePathWriteExcelData.setWidth(40);
+ namePathWriteExcelData.setCenter(false);
+ classPathList.add(namePathWriteExcelData);
+ rowIndex[0]++;
+ });
+
+ WriteExcelData excelData=new WriteExcelData();
+ excelData.setMerged(true);
+ excelData.setRow(1);
+ excelData.setRowTo(2);
+ excelData.setCol(4);
+ excelData.setColTo(9);
+ excelData.setCenter(false);
+ excelData.setReadOnly(true);
+ excelData.setObj("瀵煎叆鏁版嵁鏃讹紝鍒嗙被璺緞蹇呴』濉啓鍙跺瓙鑺傜偣璺緞\n(閫夋嫨鍙跺瓙鑺傜偣瀵煎叆鍒欎笉闇�瑕佸～鍐欏垎绫昏矾寰�)");
+ excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
+ classPathList.add(excelData);
+
+ eo.addSheetDataList(codeClassifyVO.getName()+"鍒嗙被瀵圭収琛�",classPathList);
+
+ String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + codeClassifyVO.getName() + "_瀵煎叆妯℃澘.xls";
+ // eo.addSheetDataList(templateVOList.size()+"妯℃澘淇℃伅銆愯鍕垮垹闄ゆ垨绉诲姩銆�",tempEDList);
+ ExcelUtil.writeDataToFile(excelName,eo);
+ return excelName;
+ }
+
/**
* 鐢熸垚瀵煎叆鐨勬枃浠�
*
@@ -307,6 +509,627 @@
return codeImProtRusultVO;
}
+
+ /***
+ * 浠庨《灞傛壒閲忕敵璇峰鍏ユ柟娉�
+ * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+ * @param classifyAttr 鍒嗙被璺緞浣跨敤鐨勫睘鎬�
+ * @param file excel鏂囦欢鐨勪俊鎭�
+ * @return
+ */
+ @Override
+ public CodeImProtRusultVO batchTopImportCode(String codeClassifyOid, String classifyAttr, File file) {
+ VciBaseUtil.alertNotNull(codeClassifyOid,"鍒嗙被鐨勪富閿�");
+ ReadExcelOption reo = new ReadExcelOption();
+ reo.setReadAllSheet(true);
+ List<SheetDataSet> sheetDataSetList = ExcelUtil.readDataObjectFromExcel(file,null,reo);
+ if(CollectionUtils.isEmpty(sheetDataSetList) || CollectionUtils.isEmpty(sheetDataSetList.get(0).getRowData())
+ ||sheetDataSetList.get(0).getRowData().size()<1){
+ throw new VciBaseException("娌℃湁璇诲彇鍒颁换浣曠殑鏁版嵁");
+ }
+ if(sheetDataSetList.size()>LIMIT+1){
+ throw new VciBaseException("涓轰簡淇濊瘉绯荤粺鐨勭ǔ瀹氭�э紝璇蜂竴娆′笉瑕佸鍏ヨ秴杩�1涓囨潯鐨勬暟鎹�");
+ }
+ //鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
+ SheetDataSet dataSet = sheetDataSetList.get(0);
+ CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
+ //鑾峰彇褰撳墠妯℃澘
+ CodeClassifyTemplateVO selectCodeClassifyTemplateVO =engineService.getUsedTemplateByClassifyOid(codeClassifyOid);
+ Map<String,List<ColumnVO>> templateColumnVOMap=new HashMap<>();
+ createTemplate(selectCodeClassifyTemplateVO,templateColumnVOMap);
+
+ List<CodeClassifyVO> childClassifyVOs = classifyService.listChildrenClassify(codeClassifyOid, true, classifyAttr, true);
+ Map<String/**璺緞**/, CodeClassifyVO> pathMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getPath().startsWith("#") ? s.getPath().substring(1) : s.getPath(), t -> t));
+ pathMap.put("#current#", classifyFullInfo.getCurrentClassifyVO());
+ List<String> titleRowData = dataSet.getColName();
+ Map<String, String> errorMap = new ConcurrentHashMap<>();
+ //棣栧厛灏嗘暟鎹互妯℃澘鐨勫舰寮忓垎寮�
+ LinkedHashMap<String,List<CodeImprotDataVO>> codeclassifyDataMap=new LinkedHashMap<>();
+ List<CodeImprotDataVO> codeClassifyDatas=new ArrayList<>();
+ createExeclClassData(dataSet,pathMap,errorMap,codeClassifyDatas);
+
+ //鏍规嵁妯℃澘灏嗘暟鎹暣鍚堝湪涓�璧凤紝鍘绘牎楠�
+ Map<String/**妯℃澘oid**/, List<CodeImprotDataVO>/**鏁版嵁瀵硅薄**/> templateDatasMap =codeClassifyDatas.stream().collect(Collectors.toMap(CodeImprotDataVO::getTemplateOid,s->{
+ List<CodeImprotDataVO> l=new ArrayList<>();
+ l.add(s);
+ return l;
+ },(List<CodeImprotDataVO> s1,List<CodeImprotDataVO> s2)->{
+ s1.addAll(s2);
+ return s1;
+ }));
+ String uuid=VciBaseUtil.getPk();
+ List<CodeImportTemplateVO> codeImportTemplateVOS=new ArrayList<>();
+ Map<String,CodeImportTemplateVO> codeRuleMap=new HashMap<>();
+
+ //鐩镐技鏁版嵁
+ // Map<String,String>wpResembleMap=new HashMap<>();
+ // List<CodeImprotDataVO> wpCodeImprotDataVOList=new ArrayList<>();
+ //鎸夌収妯℃澘鍘绘暣鐞嗘暟鎹�
+ templateDatasMap.keySet().stream().forEach(templateVOOid->{
+ List<CodeImprotDataVO> codeImprotDataVOS= templateDatasMap.get(templateVOOid);
+ CodeClassifyTemplateVO templateVO= templateService.getObjectHasAttrByOid(templateVOOid);
+
+ //闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+ List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
+ !DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+ ).collect(Collectors.toList());
+
+ Map<String/**妯℃澘灞炴�у瓧娈祇id**/, String /**妯℃澘灞炴�у閮ㄥ悕绉�**/> fieldNameMap =attrVOS.stream().collect(Collectors.toMap(CodeClassifyTemplateAttrVO::getId,s->s.getName()));
+
+ List<ClientBusinessObject> allCboList=new ArrayList<>();
+ codeImprotDataVOS.stream().forEach(codeImprotDataVO -> {
+ List<ColumnVO>columnVOList =new ArrayList();
+ String templateOid=selectCodeClassifyTemplateVO.getOid();
+ if(templateColumnVOMap.containsKey(templateOid)){
+ columnVOList= columnVOList=templateColumnVOMap.get(templateOid);
+ }else{
+ createTemplate(templateVO,templateColumnVOMap);
+ columnVOList= columnVOList=templateColumnVOMap.get(templateOid);
+ }
+ String codeRuleOid=codeImprotDataVO.getCodeRuleOid();
+ if(!codeRuleMap.containsKey(codeRuleOid)){
+ CodeImportTemplateVO codeImportTemplateVO=new CodeImportTemplateVO();
+ codeImportTemplateVO.setRoot(false);
+ codeImportTemplateVO.setCodeClassifyOid(codeImprotDataVO.getCodeClassifyOid());
+ codeImportTemplateVO.setCodeRuleOid(codeImprotDataVO.getCodeRuleOid());
+ codeImportTemplateVO.setCodeTemplateOid (codeImprotDataVO.getTemplateOid());
+ codeImportTemplateVO.setCodeClassifyVO( codeImprotDataVO.getCodeClassifyVO());
+ codeImportTemplateVO.setCodeClassifyTemplateVO( codeImprotDataVO.getCodeClassifyTemplateVO());
+ codeImportTemplateVO.setCodeRuleVO(codeImprotDataVO.getCodeRuleVO());
+ List<String> colNames=codeImprotDataVO.getColNames();
+ codeImportTemplateVO.setCloNamesList(columnVOList);
+ codeImportTemplateVOS.add(codeImportTemplateVO);
+ codeRuleMap.put(codeRuleOid,codeImportTemplateVO);
+ }
+ List<ClientBusinessObject> cboList=new ArrayList<>();
+ excelToCbo(classifyFullInfo,codeImprotDataVO,cboList,true);
+ allCboList.addAll(cboList);
+ //寰�閫夋嫨鐨勮妭鐐归噷闈㈠姞鏁版嵁
+ // CodeImprotDataVO wpcodeImprotDataVO=new CodeImprotDataVO();
+ // BeanUtilForVCI.copyPropertiesIgnoreCase(codeImprotDataVO,wpcodeImprotDataVO);
+ /* wpcodeImprotDataVO.setCodeClassifyOid(codeClassifyOid);
+ wpcodeImprotDataVO.setCodeClassifyVO(classifyFullInfo.getCurrentClassifyVO());
+ wpcodeImprotDataVO.setCodeClassifyTemplateVO(selectCodeClassifyTemplateVO);
+ wpcodeImprotDataVO.setCodeRuleOid(classifyFullInfo.getCurrentClassifyVO().getCoderuleoid());*/
+ // wpCodeImprotDataVOList.add(wpcodeImprotDataVO);//寰�鐗╁搧瀵硅薄閲屾坊鍔�
+
+ });
+
+
+ //閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+ //濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌excel涓�
+ //2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
+ batchCheckRequiredAttrOnOrder(templateVO,allCboList,errorMap);
+ //3.鍒ゆ柇鍏抽敭灞炴��
+ CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, allCboList);
+ Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
+ Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
+ if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
+ selfRepeatRowIndexList.stream().forEach(rowIndex->{
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍦ㄥ綋鍓嶅鐞嗙殑鏁版嵁鏂囦欢涓叧閿睘鎬ч噸澶�" );
+ });
+ }
+ if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
+ keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
+ });
+ }
+ //鍒嗙被娉ㄥ叆
+ // batchSwitchClassifyAttrOnOrder(attrVOS,allCboList,classifyFullInfo,false);
+ //boolean
+ reSwitchBooleanAttrOnOrder(attrVOS,allCboList);
+ //4.鏍￠獙瑙勫垯
+ batchCheckVerifyOnOrder(attrVOS, allCboList,errorMap);
+ //鏄惁闇�瑕佹牎楠屾灇涓�/鍙傜収
+ //5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
+ batchSwitchEnumAttrOnOrder(attrVOS, allCboList, errorMap);
+ //7.澶勭悊鍙傜収鐨勬儏鍐�
+ batchSwitchReferAttrOnOrder(attrVOS,allCboList,errorMap);
+
+ //6.鏃堕棿鏍煎紡鐨勯獙璇�
+ //6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+ batchSwitchDateAttrOnOrder(attrVOS,allCboList,errorMap);
+ //璁剧疆榛樿鍊�
+ batchSwitchAttrDefault(attrVOS, allCboList);
+ //鏈�鍚庡紕缁勫悎瑙勫垯
+ batchSwitchComponentAttrOnOrder(attrVOS,allCboList);
+
+
+ Map<String, ClientBusinessObject> rowIndexCboMap = allCboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
+
+
+ List<ClientBusinessObject> needSaveCboList = allCboList.stream().filter(cbo -> {
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ return !errorMap.containsKey(rowIndex);
+ }).collect(Collectors.toList());
+ //鐩镐技鏍￠獙
+ Map<String,String>resembleMap=new HashMap<>();
+ List<DataResembleVO> dataResembleVOS=new ArrayList<>();
+ String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmtypeid();
+ bathcResembleQuery(codeClassifyOid,templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
+ if(resembleMap.size()>0) {
+ if(!CollectionUtils.isEmpty(dataResembleVOS)) {
+ bladeRedis.set(uuid + "-resemble-data", dataResembleVOS);
+ bladeRedis.expire(uuid + "-resemble-data",BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿
+ // createRedisDatas(uuid + "-resemble", codeImprotDataVOS, resembleMap, false);
+ // wpResembleMap.putAll(resembleMap);
+ }
+ }
+ //鎺掗櫎閿欒鐨勶紝鍓╀笅姝ｇ‘鐨�
+ Map<String,String> newErrorMap=new HashMap<>();
+ newErrorMap.putAll(resembleMap);
+ newErrorMap.putAll(errorMap);
+ needSaveCboList = allCboList.stream().filter(cbo -> {
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ return !newErrorMap.containsKey(rowIndex);
+ }).collect(Collectors.toList());
+ if(newErrorMap.size()>0) {
+ createRedisDatas(uuid + "-resemble",codeImprotDataVOS, newErrorMap,false);
+ }
+ createRedisDatas(uuid + "-ok",codeImprotDataVOS, newErrorMap,true);
+
+ });
+ //寰�鐗╁搧鑺傜偣涓婂姞妯℃澘
+
+
+
+ List<String> needRowIndexList=new ArrayList<>();
+ CodeImProtRusultVO codeImProtRusultVO = new CodeImProtRusultVO();
+ if(errorMap.size()>0) {
+ String filePath = returnErrorToExcel(dataSet.getRowData(), errorMap, needRowIndexList, dataSet.getColName());
+ if (StringUtils.isNotBlank(filePath)) {
+ codeImProtRusultVO.setFilePath(filePath);
+ }
+ }
+ if(StringUtils.isNotBlank(uuid)){
+ //灏嗘墍鏈夌殑鍒嗙被瀛樺叆缂撳瓨涔嬩腑
+ codeImProtRusultVO.setRedisUuid(uuid);
+ /** List<ColumnVO>columnVOList=new ArrayList<>();
+ CodeImportTemplateVO wpCodeImportTemplateVO=new CodeImportTemplateVO();
+ wpCodeImportTemplateVO.setRoot(true);
+ wpCodeImportTemplateVO.setCodeClassifyTemplateVO(selectCodeClassifyTemplateVO);
+ wpCodeImportTemplateVO.setCodeClassifyVO(classifyFullInfo.getCurrentClassifyVO());
+ String templateOid=selectCodeClassifyTemplateVO.getOid();
+ if(templateColumnVOMap.containsKey(templateOid)){
+ columnVOList= columnVOList=templateColumnVOMap.get(templateOid);
+ }else{
+ createTemplate(selectCodeClassifyTemplateVO,templateColumnVOMap);
+ columnVOList= columnVOList=templateColumnVOMap.get(templateOid);
+ }
+ wpCodeImportTemplateVO.setCloNamesList(columnVOList);
+ codeImportTemplateVOS.add(wpCodeImportTemplateVO);
+
+ if(wpResembleMap.size()>0){
+ // redisService.setCacheList(uuid + "-resemble-data", wpDataResembleVOList);
+ createRedisDatas(uuid + "-resemble",selectCodeClassifyTemplateVO, wpCodeImprotDataVOList, wpResembleMap, false,codeClassifyOid);
+ }
+ //鎺掗櫎閿欒鐨勶紝鍓╀笅姝ｇ‘鐨�
+ Map<String,String> newErrorMap=new HashMap<>();
+ newErrorMap.putAll(wpResembleMap);
+ newErrorMap.putAll(errorMap);
+ List<CodeImprotDataVO> needSaveCboList = wpCodeImprotDataVOList.stream().filter(cbo -> {
+ String rowIndex = cbo.getRowIndex();
+ return !newErrorMap.containsKey(rowIndex);
+ }).collect(Collectors.toList());
+ createRedisDatas(uuid + "-ok",selectCodeClassifyTemplateVO,wpCodeImprotDataVOList, newErrorMap,true,codeClassifyOid);****/
+ if(codeImportTemplateVOS.size()>0){
+ bladeRedis.set(uuid + "-class",codeImportTemplateVOS);
+ bladeRedis.expire(uuid + "-class",BATCHADD_REDIS_TIME);
+ }
+ }
+ return codeImProtRusultVO;
+ }
+
+ /**
+ * 瀵煎叆鍘嗗彶鏁版嵁
+ *
+ * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+ * @param classifyAttr 鍒嗙被璺緞浣跨敤鐨勫睘鎬�
+ * @param file excel鏂囦欢鐨勪俊鎭�
+ * @return 鏈夐敊璇俊鎭殑excel
+ */
+ @Override
+ public CodeImProtRusultVO batchImportHistoryData(String codeClassifyOid, String classifyAttr,File file) {
+ VciBaseUtil.alertNotNull(codeClassifyOid,"鍒嗙被鐨勪富閿�");
+ ReadExcelOption reo = new ReadExcelOption();
+ reo.setReadAllSheet(true);
+ List<SheetDataSet> sheetDataSetList = ExcelUtil.readDataObjectFromExcel(file,null,reo);
+ if (sheetDataSetList.size() > LIMIT + 1) {
+ throw new VciBaseException("涓轰簡淇濊瘉绯荤粺鐨勭ǔ瀹氭�э紝璇蜂竴娆′笉瑕佸鍏ヨ秴杩�1涓囨潯鐨勬暟鎹�");
+ }
+ Map<String,List<WriteExcelData>> shetNameMap=new HashMap<>();
+ //鐩镐技椤圭洰鏌ラ噸
+ String uuid=VciBaseUtil.getPk();
+ boolean isCreateUUid=false;
+ boolean isExport=false;
+ for(int i=0;i<sheetDataSetList.size()-1;i++) {
+ if (CollectionUtils.isEmpty(sheetDataSetList) || CollectionUtils.isEmpty(sheetDataSetList.get(i).getRowData())
+ || sheetDataSetList.get(i).getRowData().size() < 1) {
+ continue;
+ }
+ //鍘嗗彶瀵煎叆鐨勬椂鍊欎笉澶勭悊缂栫爜
+ //----閫昏緫鍐呭----
+ //1. 鍒嗙被鐨勮矾寰勫彲浠ュ湪椤甸潰涓婇�夋嫨鏄垎绫荤紪鍙疯繕鏄垎绫荤殑鍚嶇О
+ //2. 鍒嗙被鐨勮矾寰勶紝蹇呴』鏄綋鍓嶅鍏ラ�夋嫨鐨勫垎绫荤殑鑺傜偣锛屼互鍙婂叾涓嬬骇鑺傜偣
+ //3. 閫氳繃鏁版嵁瑕佸鍏ョ殑鍒嗙被鍘绘煡鎵惧搴旂殑缂栫爜瑙勫垯
+ //4. 鏁版嵁瀛樺偍鍜屾壒閲忕敵璇蜂竴鏍凤紝
+ //5. 闇�瑕佸崟鐙鐞嗕紒涓氱紪鐮佺殑鍐呭锛�
+ // 5.1 浼佷笟缂栫爜鍦ㄥ綋鍓峞xcel閲屼笉鑳介噸澶�
+ // 5.2 浼佷笟缂栫爜鍦ㄧ郴缁熶腑涓嶈兘閲嶅锛堝彲浠ユ槸宸茬粡鍥炴敹鐨勶級
+ // 5.3 浼佷笟缂栫爜鐨勯暱搴︼紝鍜岀紪鐮佽鍒欑殑闀垮害瑕佸搴斾笂
+ // 5.4 鑾峰彇娴佹按鐮佹鐨勫�硷紝鍘婚櫎濉厖鐨勫瓧绗︼紝鐪嬫祦姘村彿鏄灏戯紝鐒跺悗灏嗘祦姘村彿鍜岀幇鍦ㄧ殑鏈�澶ф祦姘村彿鍒ゆ柇锛屽皬浜庡氨鐩存帴褰曞叆锛屽ぇ浜庡垯淇敼鏈�澶ф祦姘村彿
+ // 5.5 瀛樺偍浼佷笟缂栫爜鍒癮llcode涓�
+
+ //鏌ヨ鍒嗙被鍜屾ā鏉�
+ CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
+
+ //鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
+ SheetDataSet dataSet = sheetDataSetList.get(i);
+ List<SheetRowData> rowDataList = dataSet.getRowData();
+
+ //鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
+ CodeClassifyTemplateVO templateVO = new CodeClassifyTemplateVO();
+ /** if (!templateService.checkChildHasSameTemplate(classifyFullInfo.getCurrentClassifyVO().getOid())) {
+ throw new VciBaseException("褰撳墠鐨勫垎绫讳互鍙婁笅绾у垎绫荤殑妯℃澘涓嶇浉鍚�");
+ }***/
+ //閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+ //鎵炬墍鏈夌殑鍒嗙被璺緞,闇�瑕佹牎楠岃矾寰勬槸鍚︽纭紝鏄惁閮藉湪褰撳墠鐨勫垎绫荤殑涓嬬骇
+ List<CodeClassifyVO> childClassifyVOs = classifyService.listChildrenClassify(codeClassifyOid, true, classifyAttr, true);
+ Map<String/**璺緞**/, CodeClassifyVO> pathMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getPath().startsWith("#") ? s.getPath().substring(1) : s.getPath(), t -> t));
+ List<String> titleRowData = dataSet.getColName();
+ Map<String, String> errorMap = new ConcurrentHashMap<>();
+ pathMap.put("#current#",classifyFullInfo.getCurrentClassifyVO());
+
+ try {
+ List<CodeClassifyTemplateVO> templateVOList= checkSamesTemplate(titleRowData,sheetDataSetList,i,pathMap,errorMap);
+ templateVO= templateVOList.get(0);
+ }catch (Throwable e){
+ throw new VciBaseException(e.getMessage());
+ }
+
+ List<SheetRowData> needowDataList = rowDataList.stream().filter(cbo -> {
+ String rowIndex = cbo.getRowIndex();
+ return !errorMap.containsKey(rowIndex);
+ }).collect(Collectors.toList());
+
+ //checkTemplateSync(sheetDataSetList, templateVO,i);
+ //杩欓噷涓嶉櫎鍘婚粯璁ょ殑灞炴��
+ List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes();
+ Map<Integer/**鍒楀彿**/, String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
+
+ Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId()));
+ String idFieldName = attrVOS.stream().filter(s -> VciQueryWrapperForDO.ID_FIELD.equalsIgnoreCase(s.getId())).findFirst().orElseGet(() -> new CodeClassifyTemplateAttrVO()).getName();
+ getFieldIndexMap(titleRowData, attrNameIdMap, fieldIndexMap);
+ //鍏堜笉鐢ㄧ灞炴�ф槸鍚﹂兘瀛樺湪锛屽厛杞崲涓�涓嬫暟鎹�
+ List<ClientBusinessObject> cboList = new ArrayList<>();
+ String fullPath = getFullPath(classifyFullInfo);
+ //鎴戜滑闇�瑕佽幏鍙栧埌鎵�鏈夌殑涓嬬骇鍒嗙被鐨刼id鐨勮矾寰勶紝鍥犱负鍚庨潰闇�瑕�
+ Map<String/**涓婚敭**/, String/**璺緞**/> childOidPathMap = getChildClassifyPathMap(classifyFullInfo, fullPath);
+ excelToCbo(classifyFullInfo, fieldIndexMap, needowDataList, templateVO, cboList, fullPath, false);
+
+
+ Map<String/**涓婚敭**/, CodeClassifyVO> classifyVOMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
+ classifyVOMap.put(classifyFullInfo.getCurrentClassifyVO().getOid(), classifyFullInfo.getCurrentClassifyVO());
+ pathMap.put("#current#", classifyFullInfo.getCurrentClassifyVO());
+
+ //鍒ゆ柇缂栧彿鍦╡xcel閲屾湰韬氨閲嶅鐨�
+ Map<String, Long> idCountMap = cboList.stream().collect(Collectors.groupingBy(ClientBusinessObject::getId, Collectors.counting()));
+ List<String> repeatIdList = new ArrayList<>();
+ idCountMap.forEach((id, count) -> {
+ if (count > 1) {
+ repeatIdList.add(id);
+ }
+ });
+ if (!CollectionUtils.isEmpty(repeatIdList)) {
+ cboList.stream().filter(s -> repeatIdList.contains(s.getId())).map(s -> s.getAttributeValue(IMPORT_ROW_INDEX)).forEach(rowIndex -> {
+ errorMap.put(rowIndex, "缂栧彿鍦ㄥ綋鍓峞xcel涓噸澶�;");
+ });
+ }
+ //鎴戜滑闇�瑕佸垽鏂繖浜涘垎绫荤殑妯℃澘鏄笉鏄竴鏍风殑锛屽彧闇�瑕佹牎楠岋紝涓嶇敤鑾峰彇
+ //妫�鏌ュ垎绫荤殑璺緞
+ checkClassifyPathInHistory(cboList, errorMap, pathMap, childOidPathMap);
+
+ //妫�鏌ヨ鍒�
+ Map<String/**鍒嗙被涓婚敭**/, String/**瑙勫垯涓婚敭**/> ruleOidMap = new ConcurrentHashMap<String, String>();
+ List<String> unExistRuleClassifyOidList = new CopyOnWriteArrayList<>();
+ checkRuleOidInHistory(classifyVOMap, ruleOidMap, unExistRuleClassifyOidList);
+ //濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌excel涓�
+
+ //鎴戜滑鏍规嵁鍑洪敊鐨勫垎绫荤殑涓婚敭锛屽幓鎵捐鍙�
+ if (!CollectionUtils.isEmpty(unExistRuleClassifyOidList)) {
+ cboList.stream().forEach(cbo -> {
+ if (unExistRuleClassifyOidList.contains(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD))) {
+ String row_index = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ errorMap.put(row_index, errorMap.getOrDefault(row_index, "") + ";鏍规嵁鍒嗙被璺緞瀵瑰簲鐨勫垎绫伙紝娌℃湁璁剧疆缂栫爜瑙勫垯");
+ }
+ });
+ }
+
+ //鍒ゆ柇蹇呰緭椤�
+ batchCheckRequiredAttrOnOrder(templateVO, cboList, errorMap);
+
+ //鏈夐檺鏍￠獙缂栫爜鏄惁瀛樺湪
+ batchCheckIdExistOnOrder(templateVO, cboList, errorMap);
+
+ //boolean
+ reSwitchBooleanAttrOnOrder(attrVOS, cboList);
+
+ // 鏋氫妇鐨勫唴瀹归渶瑕佹牴鎹悕绉拌浆鎹负鏋氫妇鐨勫��
+ batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
+
+ batchSwitchReferAttrOnOrder(attrVOS, cboList, errorMap);
+ //6.澶勭悊鍒嗙被娉ㄥ叆
+ batchSwitchClassifyAttrOnOrder(attrVOS, cboList, classifyFullInfo,true);
+
+ //璁剧疆榛樿鍊�
+ batchSwitchAttrDefault(attrVOS, cboList);
+ //7.澶勭悊缁勫悎瑙勫垯
+ batchSwitchComponentAttrOnOrder(attrVOS, cboList);
+ //3.鍒ゆ柇鍏抽敭灞炴��
+ CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList);
+ Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
+ Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
+ if (!CollectionUtils.isEmpty(selfRepeatRowIndexList)) {
+ selfRepeatRowIndexList.stream().forEach(rowIndex -> {
+ errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";鍦ㄥ綋鍓峞xcel鏂囦欢涓叧閿睘鎬ч噸澶�");
+ });
+ }
+ if (!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)) {
+ keyAttrRepeatRowIndexList.stream().forEach(rowIndex -> {
+ errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅");
+ });
+ }
+ //4.鏍￠獙瑙勫垯
+ batchCheckVerifyOnOrder(attrVOS, cboList, errorMap);
+
+ //6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+ batchSwitchDateAttrOnOrder(attrVOS, cboList, errorMap);
+ if (CollectionUtils.isEmpty(ruleOidMap.values())) {
+ throw new VciBaseException("瀵煎叆鐨勬暟鎹墍閫夋嫨鐨勫垎绫婚兘娌℃湁璁剧疆缂栫爜瑙勫垯");
+ }
+ Map<String, CodeRuleVO> ruleVOMap = ruleService.listCodeRuleByIds(ruleOidMap.values(), true).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
+ //鏍￠獙缂栫爜瑙勫垯鍜岀爜娈垫槸鍚︽纭�
+ Map<String, List<String>> ruleRowIndexMap = new ConcurrentHashMap<>();
+ checkSecLengthInHistory(cboList, classifyVOMap, ruleVOMap, ruleOidMap, errorMap, ruleRowIndexMap);
+ ruleRowIndexMap.keySet().parallelStream().forEach(ruleOid -> {
+ List<String> rowIndexList = ruleRowIndexMap.get(ruleOid);
+ List<ClientBusinessObject> thisCbos = cboList.stream().filter(cbo -> rowIndexList.contains(cbo.getAttributeValue(IMPORT_ROW_INDEX)) && !errorMap.containsKey(cbo.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
+//鎴戜滑闇�瑕佸厛鏌ヨ涓�涓嬶紝鍐呭鏄惁宸茬粡瀛樺湪
+ if(!CollectionUtils.isEmpty(thisCbos)){
+ List<String> existIds = new ArrayList<>();
+ VciBaseUtil.switchCollectionForOracleIn(thisCbos).stream().forEach(cbos -> {
+ List<CodeAllCode> codeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCodeRuleOid, ruleOid)
+ .notIn(CodeAllCode::getId,cbos.stream().map(s -> s.getId()).collect(Collectors.toSet()).toArray(new String[0]))
+ .notIn(CodeAllCode::getLcStatus,CodeAllCodeLC.TASK_BACK.getValue() + "','" + CodeAllCodeLC.OBSOLETED.getValue())
+ );
+ existIds.addAll(Optional.ofNullable(codeAllCodeList).orElseGet(() -> new ArrayList<>()).stream().map(s -> {
+ String id = s.getId();
+ if (StringUtils.isBlank(id)) {
+ id = s.getId();
+ }
+ return id;
+ }).collect(Collectors.toList()));
+ });
+ List<String> existIdCbos = thisCbos.stream().filter(s -> {
+ String id = s.getId();
+ if (StringUtils.isBlank(id)) {
+ id = s.getAttributeValue("id");
+ }
+ return existIds.contains(id);
+ }).map(s -> s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toList());
+ if (!CollectionUtils.isEmpty(existIdCbos)) {
+ thisCbos = thisCbos.stream().filter(s -> {
+ String id = s.getId();
+ if (StringUtils.isBlank(id)) {
+ id = s.getAttributeValue("id");
+ }
+ return !existIdCbos.contains(id);
+ }).collect(Collectors.toList());
+ existIdCbos.stream().forEach(rowIndex -> {
+ errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";銆�" + idFieldName + "銆戝湪绯荤粺涓凡缁忚鍗犵敤");
+ });
+ }
+ }
+ });
+
+ Map<String, ClientBusinessObject> rowIndexCboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
+ if (errorMap.size() > 0) {
+ isExport=true;
+ createRedisDatas(uuid + "-error", templateVO, rowIndexCboMap, dataSet, fieldIndexMap, errorMap, false);
+ }
+ createWriteExcelData(rowDataList, errorMap, new ArrayList<>(), titleRowData, shetNameMap, templateVO);
+ List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ return !errorMap.containsKey(rowIndex);
+ }).collect(Collectors.toList());
+ //鐩镐技鏍￠獙
+ Map<String, String> resembleMap = new HashMap<>();
+ List<DataResembleVO> dataResembleVOS = new ArrayList<>();
+ String btmtypeid = classifyFullInfo.getTopClassifyVO().getBtmtypeid();
+ bathcResembleQuery(templateVO.getCodeclassifyoid(), templateVO, needSaveCboList, resembleMap, btmtypeid, dataResembleVOS);
+ if (resembleMap.size() > 0) {
+ if (!CollectionUtils.isEmpty(dataResembleVOS)) {
+ bladeRedis.set(uuid + "-resemble-data", dataResembleVOS);
+ createRedisDatas(uuid + "-resemble", templateVO, rowIndexCboMap, dataSet, fieldIndexMap, resembleMap, false);
+ }
+ }
+ //鐢熸垚class缂撳瓨
+ Map<String, String> rowIndexClsOidMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t.getAttributeValue(CODE_CLASSIFY_OID_FIELD)));
+ createRedisByCodeClassify(uuid + "-class",templateVO,dataSet,fieldIndexMap,true);
+ //鑾峰彇缂栫爜锛屾煡璇㈠湪绯荤粺涓槸鍚﹁鍏朵粬鐨勫紩鐢ㄤ簡
+ //鎺掗櫎閿欒鐨勶紝鍓╀笅姝ｇ‘鐨�
+ Map<String, String> newErrorMap = new HashMap<>();
+ newErrorMap.putAll(resembleMap);
+ newErrorMap.putAll(errorMap);
+ //瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
+ needSaveCboList = cboList.stream().filter(cbo -> {
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ return !newErrorMap.containsKey(rowIndex);
+ }).collect(Collectors.toList());
+ if((errorMap.size()>0&&needSaveCboList.size()>0)||resembleMap.size()>0){
+ isCreateUUid=true;
+ }
+
+ List<String> needRowIndexList = needSaveCboList.stream().filter(s -> errorMap.containsKey(s.getAttributeValue(IMPORT_ROW_INDEX))).map(s -> s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toList());
+ if (isExport||newErrorMap.size() > 0) {
+ createRedisDatas(uuid + "-ok", templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap, true);
+ } else {
+ List<String> dataCBOIdList=new ArrayList<>();
+ //SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
+ List<ClientBusinessObject> finalNeedSaveCboList = needSaveCboList;
+ CodeClassifyTemplateVO finalTemplateVO = templateVO;
+ ruleRowIndexMap.keySet().parallelStream().forEach(ruleOid -> {
+ //VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+ List<String> rowIndexList = ruleRowIndexMap.get(ruleOid);
+ List<ClientBusinessObject> thisCbos = finalNeedSaveCboList.stream().filter(cbo -> rowIndexList.contains(cbo.getAttributeValue(IMPORT_ROW_INDEX)) && !errorMap.containsKey(cbo.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
+ List<BaseModel> dataCBOList=new ArrayList<>();
+ thisCbos.stream().forEach(clientBusinessObject -> {
+ BaseModel baseModel=new BaseModel();
+ BeanUtil.convert(clientBusinessObject,baseModel);
+ baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
+ dataCBOList.add(baseModel);
+ dataCBOIdList.add(baseModel.getOid());
+ });
+
+ if (!CollectionUtils.isEmpty(thisCbos)) {
+ try {
+ productCodeService.productCodeAndSaveData(classifyFullInfo, finalTemplateVO, ruleVOMap.get(ruleOid), null, dataCBOList);
+ } catch (Throwable e) {
+ log.error("鎵归噺浜х敓缂栫爜鐨勬椂鍊欏嚭閿欎簡", e);
+ thisCbos.stream().forEach(cbo -> {
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";绯荤粺閿欒锛屽瓨鍌ㄦ暟鎹殑鏃跺�欏嚭閿欎簡");
+ });
+ }
+ }
+ });
+ engineService.batchSaveSelectChar(templateVO, dataCBOIdList);
+ }
+ }
+ String excelFileName="";
+ if(isExport&&!CollectionUtils.isEmpty(shetNameMap)) {
+ excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + "閿欒淇℃伅.xls";
+ WriteExcelOption eo = new WriteExcelOption();
+ shetNameMap.forEach((shetName, errorDataList) -> {
+ eo.addSheetDataList(shetName, errorDataList);
+ });
+ try {
+ new File(excelFileName).createNewFile();
+ } catch (IOException e) {
+ throw new VciBaseException(LangBaseUtil.getErrorMsg(e));
+ }
+ ExcelUtil.writeDataToFile(excelFileName, eo);
+ }
+ CodeImProtRusultVO codeImProtRusultVO=new CodeImProtRusultVO();
+ if(StringUtils.isNotBlank(excelFileName)) {
+ codeImProtRusultVO.setFilePath(excelFileName);
+ codeImProtRusultVO.setFileOid("");
+ }
+ if(isCreateUUid){
+ codeImProtRusultVO.setRedisUuid(uuid);
+ }
+
+ return codeImProtRusultVO;
+ }
+
+ /***
+ * 浠巈xecl閲屾瀯寤哄璞�
+ * @param rowDataList
+ * @param errorMap
+ * @param needRowIndexList
+ * @param titleRowData
+ * @param shetNameMap
+ * @param templateVO
+ */
+ private void createWriteExcelData(Collection<SheetRowData> rowDataList, Map<String,String> errorMap,
+ List<String> needRowIndexList, List<String> titleRowData, Map<String,List<WriteExcelData>> shetNameMap, CodeClassifyTemplateVO templateVO){
+ List<WriteExcelData> errorDataList=new ArrayList<>();
+ Map<String, SheetRowData> rowIndexDataMap = rowDataList.stream().filter(s -> !needRowIndexList.contains(s.getRowIndex())).collect(Collectors.toMap(s -> s.getRowIndex(), t -> t));
+ errorDataList.add(new WriteExcelData(0,0,"閿欒淇℃伅"));
+ for (int i = 0; i < titleRowData.size(); i++) {
+ //閿欒淇℃伅鍦ㄦ渶鍚�
+ errorDataList.add(new WriteExcelData(0,i+1,titleRowData.get(i)));
+ }
+ Integer[] newRowIndex = new Integer[]{1};
+ errorMap.forEach((index,error)->{
+ //閿欒淇℃伅鍏ㄩ儴缁勫悎鍒颁竴璧�
+ SheetRowData rowData = rowIndexDataMap.getOrDefault(index, null);
+ if(rowData!=null){
+ errorDataList.add(new WriteExcelData(newRowIndex[0],0,error));
+ rowData.getData().forEach((colIndex,value)->{
+ errorDataList.add(new WriteExcelData(newRowIndex[0],colIndex+1,value));
+ });
+ newRowIndex[0]++;
+ }
+ });
+
+ shetNameMap.put(templateVO.getName(),errorDataList);
+ }
+
+ /***
+ *
+ * @param currentTemplateVO
+ * @param templateColumnVOMap
+ */
+
+ private void createTemplate(CodeClassifyTemplateVO currentTemplateVO,Map<String,List<ColumnVO>>templateColumnVOMap){
+
+ List<CodeClassifyTemplateAttrVO> templateAttrVOS = currentTemplateVO.getAttributes().stream().filter(s ->
+ !DEFAULT_ATTR_LIST.contains(s.getId())
+ && StringUtils.isBlank(s.getComponentRule())
+ && StringUtils.isBlank(s.getClassifyInvokeAttr())
+ && (VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
+ ).collect(Collectors.toList());
+ if(CollectionUtils.isEmpty(templateAttrVOS)){
+ throw new VciBaseException("妯℃澘娌℃湁閰嶇疆浠讳綍銆愯〃鍗曟樉绀恒�戜负銆愭槸銆戠殑灞炴��");
+ }
+ List<ColumnVO> columnVOList=new ArrayList<>();
+
+ ColumnVO errorMsgColumnVO=new ColumnVO();
+ errorMsgColumnVO.setTitle("閿欒淇℃伅");
+ errorMsgColumnVO.setField("errorMsg");
+ columnVOList.add(errorMsgColumnVO);
+
+
+
+ ColumnVO pathColumnVO=new ColumnVO();
+ pathColumnVO.setTitle("鍒嗙被璺緞");
+ pathColumnVO.setField("codeclsfid");
+ columnVOList.add(pathColumnVO);
+ templateAttrVOS.stream().forEach(codetemplateAttr ->{
+ String field=codetemplateAttr.getId();
+ String name=codetemplateAttr.getName();
+ ColumnVO columnVO=new ColumnVO();
+ columnVO.setTitle(name);
+ columnVO.setField(field);
+ columnVO.setWidth(codetemplateAttr.getAttrTableWidth()==0?columnVO.getWidth():codetemplateAttr.getAttrTableWidth());
+ columnVOList.add(columnVO);
+ });
+
+ templateColumnVOMap.put(currentTemplateVO.getOid(),columnVOList);
+ log.info("妯℃澘"+currentTemplateVO.getName()+"瀵瑰簲鐨勫睘鎬�"+columnVOList.size());
+ }
+
/**
* 閿欒淇℃伅杩斿洖excel
* @param rowDataList 鎵�鏈夌殑瀵煎叆鏁版嵁
@@ -492,23 +1315,23 @@
uuid="";
//瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
- /*dataCBOList = cboList.stream().filter(cbo -> {
+ needSaveCboList = cboList.stream().filter(cbo -> {
String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
return !newErrorMap.containsKey(rowIndex);
}).collect(Collectors.toList());
-*/ List<String> dataCBOIdList=new ArrayList<>();
- List<BaseModel> dataCBOList=new ArrayList<>();
- cboList.stream().forEach(clientBusinessObject -> {
- BaseModel baseModel=new BaseModel();
- BeanUtil.convert(clientBusinessObject,baseModel);
- baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
- dataCBOList.add(baseModel);
- dataCBOIdList.add(baseModel.getOid());
- });
if (!CollectionUtils.isEmpty(needSaveCboList)) {
//9.鎴戜滑澶勭悊涓氬姟鏁版嵁
//鐢熸垚缂栫爜鐨勫唴瀹�
+ List<String> dataCBOIdList=new ArrayList<>();
+ List<BaseModel> dataCBOList=new ArrayList<>();
+ cboList.stream().forEach(clientBusinessObject -> {
+ BaseModel baseModel=new BaseModel();
+ BeanUtil.convert(clientBusinessObject,baseModel);
+ baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
+ dataCBOList.add(baseModel);
+ dataCBOIdList.add(baseModel.getOid());
+ });
try {
codeList = productCodeService.productCodeAndSaveData(classifyFullInfo,templateVO,ruleVO, orderDTO.getSecDTOList(),dataCBOList);
//濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
@@ -599,6 +1422,161 @@
return dataGrid;
}
+ @Override
+ public R batchImportData(List<CodeImprotSaveDatVO> codeImprotSaveDatVOList, String classifyAttr, boolean isImprot) {
+ List<String> allNeedSaveCboList=new ArrayList<>();
+ codeImprotSaveDatVOList.stream().forEach(codeImprotSaveDatVO -> {
+ List<SheetRowData> rowDataList = new ArrayList<>();
+ List<ClientBusinessObject>cboList=new ArrayList<>();
+ List<String> colList=codeImprotSaveDatVO.getClos();
+ CodeOrderDTO orderDTO= codeImprotSaveDatVO.getOrderDTO();
+ List<Map<String, String>> dataList= codeImprotSaveDatVO.getDataList();
+ Map<Integer, String> fieldIndexMap = new HashMap();
+ for (int i=0;i<dataList.size();i++){
+ SheetRowData sheetRowData=new SheetRowData();
+ Map<String,String> dataMap= dataList.get(i);
+ Map<Integer, String> data = new HashMap();
+ final int[] colIndex = {0};
+ Map<Integer, String> finalFieldIndexMap = new HashMap<>();
+ dataMap.forEach((field, value)->{
+ if(!ROW_INDEX.equalsIgnoreCase(field) && !ERROR_MSG.equalsIgnoreCase(field)){
+ data.put(colIndex[0],value);
+ finalFieldIndexMap.put(colIndex[0]++,field);
+ }
+ });
+ fieldIndexMap=finalFieldIndexMap;
+ sheetRowData.setData(data);
+ sheetRowData.setRowIndex(i+"");
+ rowDataList.add(sheetRowData);
+ }
+ CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
+ log.info("鍒嗙被锛�"+classifyFullInfo.getCurrentClassifyVO().getName()+"鏁版嵁:"+codeImprotSaveDatVO.getDataList().size());
+
+ // CodeClassifyTemplateVO codeClassifyTemplateVO= engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());
+ CodeClassifyTemplateVO codeClassifyTemplateVO= templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
+ //瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
+ CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
+ //闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+ List<CodeClassifyTemplateAttrVO> attrVOS = codeClassifyTemplateVO.getAttributes().stream().filter(s ->
+ !DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+ ).collect(Collectors.toList());
+ String fullPath = getFullPath(classifyFullInfo);
+ excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList, codeClassifyTemplateVO,cboList,fullPath,!isImprot);
+ Map<String,String> errorMap=new HashMap<>();
+ if(isImprot) {
+ Map<String/**涓婚敭**/, String/**璺緞**/> childOidPathMap = getChildClassifyPathMap(classifyFullInfo, fullPath);
+ //閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+ //鎵炬墍鏈夌殑鍒嗙被璺緞,闇�瑕佹牎楠岃矾寰勬槸鍚︽纭紝鏄惁閮藉湪褰撳墠鐨勫垎绫荤殑涓嬬骇
+ List<CodeClassifyVO> childClassifyVOs = classifyService.listChildrenClassify(orderDTO.getCodeClassifyOid(), true, classifyAttr, true);
+ Map<String/**璺緞**/, CodeClassifyVO> pathMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getPath().startsWith("#") ? s.getPath().substring(1) : s.getPath(), t -> t));
+ Map<String/**涓婚敭**/, CodeClassifyVO> classifyVOMap = Optional.ofNullable(childClassifyVOs).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
+ classifyVOMap.put(classifyFullInfo.getCurrentClassifyVO().getOid(), classifyFullInfo.getCurrentClassifyVO());
+ pathMap.put("#current#", classifyFullInfo.getCurrentClassifyVO());
+ //鎴戜滑闇�瑕佸垽鏂繖浜涘垎绫荤殑妯℃澘鏄笉鏄竴鏍风殑锛屽彧闇�瑕佹牎楠岋紝涓嶇敤鑾峰彇
+ //妫�鏌ュ垎绫荤殑璺緞
+ checkClassifyPathInHistory(cboList, errorMap, pathMap, childOidPathMap);
+ }
+ //鍒嗙被娉ㄥ叆
+ batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,isImprot);
+ //boolean
+ reSwitchBooleanAttrOnOrder(attrVOS,cboList);
+ //4.鏍￠獙瑙勫垯
+ batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
+ //5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
+ batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
+ //7.澶勭悊鍙傜収鐨勬儏鍐�
+ batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
+ //6.鏃堕棿鏍煎紡鐨勯獙璇�
+ //6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+ batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
+ //璁剧疆榛樿鍊�
+ batchSwitchAttrDefault(attrVOS, cboList);
+ //鏈�鍚庡紕缁勫悎瑙勫垯
+ batchSwitchComponentAttrOnOrder(attrVOS,cboList);
+ //3.鍒ゆ柇鍏抽敭灞炴��
+ CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, codeClassifyTemplateVO, cboList);
+ Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
+ Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
+ if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
+ keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
+ });
+ }
+ //4.鏍￠獙瑙勫垯
+ batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
+
+
+ //SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
+ List<ClientBusinessObject>needSaveCboList = cboList.stream().filter(cbo -> {
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ return !errorMap.containsKey(rowIndex);
+ }).collect(Collectors.toList());
+
+ log.info("鍒嗙被锛�"+classifyFullInfo.getCurrentClassifyVO().getName()+"鏁版嵁:"+needSaveCboList.size());
+ if (!CollectionUtils.isEmpty(needSaveCboList)) {
+ List<BaseModel> dataCBOList=new ArrayList<>();
+ needSaveCboList.stream().forEach(clientBusinessObject -> {
+ BaseModel baseModel=new BaseModel();
+ BeanUtil.convert(clientBusinessObject,baseModel);
+ baseModel.setData(VciBaseUtil.objectToMapString(clientBusinessObject));
+ dataCBOList.add(baseModel);
+ allNeedSaveCboList.add(baseModel.getOid());
+ });
+ try {
+ //9.鎴戜滑澶勭悊涓氬姟鏁版嵁
+ if (isImprot) {
+ productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, ruleVO, null, dataCBOList);
+ }else {
+ productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ //濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
+ engineService.batchSaveSelectChar(codeClassifyTemplateVO, allNeedSaveCboList);
+ });
+ return R.success(isImprot?"鎵归噺鍘嗗彶瀵煎叆鎴愬姛":"鎵归噺鐢宠鎴愬姛");
+ }
+
+ /***
+ *鏍规嵁鏁版嵁oid浠庣紦瀛樹腑绉婚櫎鏁版嵁
+ * @param redisOid redisid
+ * @param codeClssifyOid 瀛樺偍瑙勫垯鐨刼id
+ * @param dataOids 鎵�闇�鍒犻櫎鐨勬暟鎹�
+ * @return
+ */
+ @Override
+ public R deleteDatas(String redisOid,String codeClssifyOid,String dataOids) {
+ VciBaseUtil.alertNotNull(redisOid, "鏁版嵁鍒犻櫎", redisOid, "鏁版嵁缂撳瓨涓婚敭");
+ VciBaseUtil.alertNotNull(codeClssifyOid, "鏁版嵁鍒犻櫎", codeClssifyOid, "缂栫爜瑙勫垯缂撳瓨涓婚敭");
+ VciBaseUtil.alertNotNull(dataOids, "鏁版嵁鍒犻櫎", dataOids, "鎵�闇�鍒犻櫎鐨勬暟鎹富閿�");
+ try {
+ List<CodeImprotDataVO> codeImprotDataVOs = bladeRedis.lRange(redisOid + "-" + codeClssifyOid,0,-1);
+ List<String> dataOidList = new ArrayList<>();
+ codeImprotDataVOs.stream().forEach(codeImprotDataVO -> {
+ List<Map<String, String>> newDataList = new ArrayList<>();
+ List<Map<String, String>> dataList = codeImprotDataVO.getDatas();
+ dataList.stream().forEach(dataMap -> {
+ String oid = dataMap.get("oid");
+ if (!dataOidList.contains(oid)) {
+ newDataList.add(dataMap);
+ }
+
+ });
+ codeImprotDataVO.setDatas(newDataList);
+
+ });
+ //閲嶆柊缂撳瓨
+ bladeRedis.del(redisOid + "-" + codeClssifyOid);
+ bladeRedis.set(redisOid + "-" + codeClssifyOid, codeImprotDataVOs);
+ bladeRedis.expire(redisOid + "-" + codeClssifyOid, BATCHADD_REDIS_TIME);
+ return R.success("鍒犻櫎缂撳瓨鏁版嵁鎴愬姛");
+ }catch (Throwable e){
+ return R.fail("鍒犻櫎缂撳瓨鏁版嵁澶辫触!");
+ }
+ }
+
/**
* 闆嗘垚鎵归噺鐢宠鏁版嵁
* @param orderDTO 鍒嗙被鐨勪富閿�
@@ -682,6 +1660,122 @@
return fullPath;
}
+ /**
+ * 妫�鏌ョ爜娈电殑闀垮害鏄惁绗﹀悎瑕佹眰
+ * @param cboList 鏁版嵁
+ * @param classifyVOMap 鍒嗙被鏄犲皠
+ * @param ruleVOMap 瑙勫垯瀵硅薄
+ * @param ruleOidMap 鍒嗙被鍖呭惈瑙勫垯
+ * @param errorMap 閿欒鐨勪俊鎭�
+ * @param ruleRowIndexMap 瑙勫垯鍖呭惈鐨勮鍙凤紝key鏄鍒欎富閿紝value鏄寘鍚殑鍏ㄩ儴琛屽彿
+ */
+ private void checkSecLengthInHistory(List<ClientBusinessObject> cboList,Map<String,CodeClassifyVO> classifyVOMap,Map<String,CodeRuleVO> ruleVOMap,
+ Map<String/**鍒嗙被涓婚敭**/,String/**瑙勫垯涓婚敭**/> ruleOidMap,Map<String,String> errorMap,Map<String,List<String>> ruleRowIndexMap){
+
+ cboList.stream().forEach(cbo-> {
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ String secLength = cbo.getAttributeValue(CODE_SEC_LENGTH_FIELD);
+ //鎵惧垎绫�
+ String classifyOid = cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD);
+ CodeClassifyVO classifyVO = classifyVOMap.get(classifyOid);
+ if (classifyVO != null) {
+ //2#2#4#1杩欐牱鐨勬柟寮�
+ CodeRuleVO ruleVO = ruleVOMap.getOrDefault(ruleOidMap.get(classifyVO.getOid()), null);
+ if(ruleVO!=null){
+ String[] secValues = secLength.split("#");
+ //鎬婚暱搴﹀拰缂栫爜鐨勯暱搴�
+ String code = cbo.getAttributeValue(CODE_FIELD);
+ if(code.length() != Arrays.stream(secValues).mapToInt(s->VciBaseUtil.getInt(s)).sum()){
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鐮佹瀹藉害涓庣郴缁熶腑鐨勭紪鐮佽鍒欎笉鍚�" );
+ }else if(secValues.length != ruleVO.getSecVOList().size()){
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鐮佹瀹藉害涓庣郴缁熶腑鐨勭紪鐮佽鍒欎笉鍚�" );
+ } else {
+ //姣忎竴涓暱搴﹂兘涓嶈兘瓒呰繃鐮佹鐨�
+ boolean fined = false;
+ for (int j = 0; j < ruleVO.getSecVOList().size(); j++) {
+ CodeBasicSecVO secVO = ruleVO.getSecVOList().get(j);
+ String length= secValues[j];
+ if(StringUtils.isNotBlank(secVO.getCodeSecLength())&&VciBaseUtil.getInt(length)>VciBaseUtil.getInt(secVO.getCodeSecLength())){
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鐮佹瀹藉害涓庣郴缁熶腑鐨勭紪鐮佽鍒欎笉鍚�" );
+ fined = true;
+ break;
+ }
+ }
+ /**for (int i = 0; i < secValues.length; i++) {
+ for (int j = 0; j < ruleVO.getSecVOList().size(); j++) {
+ CodeBasicSecVO secVO = ruleVO.getSecVOList().get(j);
+ if (VciBaseUtil.getInt(secValues[i]) > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鐮佹瀹藉害涓庣郴缁熶腑鐨勭紪鐮佽鍒欎笉鍚�" );
+ fined = true;
+ break;
+ }
+ }
+ if(fined){
+ break;
+ }
+ }***/
+ if(!fined){
+ //鏆傛椂涓嶅彇娴佹按鐨勫唴瀹癸紝鍥犱负璋冪敤produceCode鐨勬椂鍊欏幓澶勭悊
+ List<String> rowIndexList = ruleRowIndexMap.getOrDefault(ruleVO.getOid(), new ArrayList<>());
+ rowIndexList.add(rowIndex);
+ ruleRowIndexMap.put(ruleVO.getOid(),rowIndexList);
+ }
+ }
+ }else{
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍒嗙被娌℃湁璁剧疆缂栫爜瑙勫垯" );
+ }
+ }
+ });
+ }
+
+ /**
+ * excel杞崲涓篶bo鐨勫璞�
+ * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+ * @param codeImprotDataVO: 鍒嗙被瀵瑰簲鐨勬暟鎹�
+ * @param cboList 鏁版嵁鐨勫垪琛�
+ * @param newCode 鏄惁涓烘壒閲忕敵璇�
+ */
+ private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,CodeImprotDataVO codeImprotDataVO,List<ClientBusinessObject> cboList, boolean newCode){
+ String fullPath = getFullPath(classifyFullInfo);
+ codeImprotDataVO.getDatas().stream().forEach(rowData -> {
+ ClientBusinessObject cbo=new ClientBusinessObject();
+ DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmtypeid());
+ rowData.forEach((field,value)->{
+ try {
+ cbo.setAttributeValueWithNoCheck(field,value);
+ if(WebUtil.isDefaultField(field)){
+ WebUtil.setValueToField(field, cbo, value);
+ }
+ } catch (VciBaseException e) {
+ log.error("璁剧疆灞炴�х殑鍊奸敊璇�",e);
+ }
+ });
+ try {
+ cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD,codeImprotDataVO.getTemplateOid());
+ cbo.setAttributeValue(IMPORT_ROW_INDEX,rowData.get(IMPORT_ROW_INDEX));
+ if(newCode){
+ cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
+ cbo.setAttributeValue(CODE_FULL_PATH_FILED,fullPath);
+ //cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+ /*int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
+ if(secret == 0 || !secretService.checkDataSecret(secret) ){
+ Integer userSecret = VciBaseUtil.getCurrentUserSecret();
+ cbo.setAttributeValue(SECRET_FIELD,String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret));
+ }*/
+ }else{
+ //姝ゆ椂杩樻病鏈夎浆鎹㈣矾寰�
+ //cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
+ cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
+ }
+ rowData.put("oid",cbo.getOid());
+
+ }catch (Throwable e){
+ log.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�",e);
+ }
+ cboList.add(cbo);
+ });
+
+ }
/**
* excel杞崲涓篶bo鐨勫璞�
* @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
@@ -817,6 +1911,32 @@
});
}
}
+
+ /**
+ * 绯荤粺妯℃澘涓粯璁ゅ�艰缃�
+ * @param attrVOS 妯℃澘灞炴��
+ * @param dataList excel鐨勬暟鎹唴瀹�
+ */
+ private void batchSwitchAttrDefault(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList) {
+ Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getDefaultValue())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
+ dateAttrVOMap.forEach((attrId, attrVO) -> {
+ String defaultValue = attrVO.getDefaultValue();
+ dataList.stream().forEach(cbo -> {
+ String dataValue= cbo.getAttributeValue(attrId);
+ if(StringUtils.isBlank(dataValue)){
+ dataValue=defaultValue;
+ }
+ try {
+ cbo.setAttributeValue(attrId, dataValue);
+ }catch (Throwable e){
+ log.error("璁剧疆灞炴�х殑閿欒",e);
+ }
+ });
+ });
+ }
+ }
+
/**
* 杞Щboolean鍨嬬殑灞炴��
* @param attrVOS 灞炴�х殑瀵硅薄
@@ -968,7 +2088,136 @@
}
}
+ /**
+ * 鎵归噺妫�鏌ヤ紒涓氱紪鐮佹槸鍚﹀瓨鍦�
+ * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+ * @param cboList 鏁版嵁鐨勫垪琛�
+ * @param errorMap 閿欒鐨勪俊鎭�
+ */
+ private void batchCheckIdExistOnOrder(CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,Map<String ,String> errorMap){
+ List<String> existIds = new ArrayList<>();
+ VciBaseUtil.switchCollectionForOracleIn(cboList).stream().forEach(cbos -> {
+ Map<String, String> conditionMap = new HashMap<>();
+ conditionMap.put("id", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(cbos.stream().map(s -> s.getId()).collect(Collectors.toSet()).toArray(new String[0])) + ")");
+ R<BtmTypeVO> r= btmTypeClient.getDetail(templateVO.getBtmTypeId());
+ BtmTypeVO btmTypeVO =r.getData();
+ String tableName=btmTypeVO.getTableName();
+
+ StringBuffer sb=new StringBuffer();
+ sb.append(" select id from ");
+ sb.append(tableName);
+ sb.append(" where 1=1 ");
+ sb.append(" id in (");
+ sb.append(VciBaseUtil.toInSql(cbos.stream().map(s -> s.getId()).collect(Collectors.toSet()).toArray(new String[0])));
+ sb.append(")");
+ List<String> idList= commonsMapper.selectById(sb.toString());
+ //涓氬姟鏁版嵁濡傛灉鐮佸�煎洖鏀朵細鐩存帴鍒犻櫎鏁版嵁锛屾墍浠ヨ繖閲岀洿鎺ュ垽鏂槸鍚﹀瓨鍦ㄥ嵆鍙�
+ existIds.addAll(Optional.ofNullable(idList).orElseGet(() -> new ArrayList<>()).stream().map(s -> s.toLowerCase(Locale.ROOT)).collect(Collectors.toList()));
+ });
+ if(!CollectionUtils.isEmpty(existIds)){
+ String idFieldName = templateVO.getAttributes().stream().filter(s -> VciQueryWrapperForDO.ID_FIELD.equalsIgnoreCase(s.getId())).findFirst().orElseGet(() -> new CodeClassifyTemplateAttrVO()).getName();
+ if(StringUtils.isBlank(idFieldName)){
+ idFieldName = "浼佷笟缂栫爜";
+ }
+ String finalIdFieldName = idFieldName;
+ cboList.stream().forEach(cbo->{
+ String id = cbo.getId();
+ if(StringUtils.isBlank(id)){
+ id = cbo.getAttributeValue("id");
+ }
+ if(existIds.contains(id)){
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ String msg = errorMap.getOrDefault(rowIndex, "");
+ msg+=";" + finalIdFieldName + "鐨勫�煎湪绯荤粺涓凡缁忓瓨鍦�";
+ errorMap.put(rowIndex,msg);
+ }
+ });
+ }
+ }
+ /***
+ * 鏍￠獙鍒嗙被瀵瑰簲鐨勬ā鏉夸俊鎭�
+ * @param titleRowData
+ * @param sheetDataSetList
+ * @param shetNumber
+ * @param pathMap
+ * @param errorMap
+ * @return
+ * @throws Throwable
+ */
+ private LinkedList<CodeClassifyTemplateVO> checkSamesTemplate(List<String> titleRowData, List<SheetDataSet> sheetDataSetList,int shetNumber,Map<String/**璺緞**/, CodeClassifyVO> pathMap,Map<String,String>errorMap) throws Throwable {
+ Map<String,String>pathOidMap =new HashMap<>();
+ Map<String,String> templateIdRowIndex=new HashedMap();
+ SheetDataSet dataSet= sheetDataSetList.get(shetNumber);
+ LinkedHashMap<String,CodeClassifyTemplateVO> codeClassifyTemplateVOMap=new LinkedHashMap <String,CodeClassifyTemplateVO>();
+ for (int i=0; i<titleRowData.size();i++){
+ String title= titleRowData.get(i);
+ if(title.equals("鍒嗙被璺緞")) {
+ int finalI = i;
+ dataSet.getRowData().stream().forEach(sheetRowData -> {
+ String Path = sheetRowData.getData().get(finalI);
+ String rowIndex=sheetRowData.getRowIndex();
+ if(StringUtils.isBlank(Path)){
+ Path= "#current#";
+ }
+ CodeClassifyTemplateVO newTemplateVO=new CodeClassifyTemplateVO();
+ String templateOid="";
+ if(pathOidMap.containsKey(Path)){
+ templateOid= pathOidMap.get(Path) ;
+ newTemplateVO=codeClassifyTemplateVOMap.get(templateOid);
+ }else{
+ if (pathMap.containsKey(Path)) {
+ CodeClassifyVO codeClassifyVO = pathMap.get(Path);
+ newTemplateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
+ if (newTemplateVO != null) {
+ templateOid = newTemplateVO.getOid();
+ } else {
+ errorMap.put(rowIndex, "绗�" + rowIndex + "琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫绘ā鏉�");
+ }
+ } else {
+ errorMap.put(rowIndex, "绗�" + rowIndex + "琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫�");
+ }
+
+ }
+ pathOidMap.put(Path, templateOid);
+ codeClassifyTemplateVOMap.put(templateOid, newTemplateVO);
+ templateIdRowIndex.put(templateOid, templateIdRowIndex.getOrDefault(templateOid, "") + "锛�" +rowIndex );
+ });
+ break;
+ }
+ }
+ LinkedList<CodeClassifyTemplateVO> codeClassifyTemplateVOList=new LinkedList<>();
+ StringBuffer sb=new StringBuffer();
+ codeClassifyTemplateVOMap.keySet().forEach(tempateOid->{
+ String templateOidInExcel="";
+ String tempateName="";
+ CodeClassifyTemplateVO t= codeClassifyTemplateVOMap.get(tempateOid);
+ codeClassifyTemplateVOList.add(t);
+ if(!CollectionUtils.isEmpty(sheetDataSetList)
+ && sheetDataSetList.size()>1 && !CollectionUtils.isEmpty(sheetDataSetList.get(sheetDataSetList.size()-1).getColName())){
+ List<SheetRowData> rowData= sheetDataSetList.get(sheetDataSetList.size()-1).getRowData();
+ templateOidInExcel=rowData.get(shetNumber).getData().get(0);
+ tempateName=rowData.get(shetNumber).getData().get(2);
+ //templateOidInExcel = sheetDataSetList.get(sheetDataSetList.size()-1).getColName().get(sheetDataSetList.size()-i);
+ }
+ if(StringUtils.isBlank(templateOidInExcel) || !templateOidInExcel.equalsIgnoreCase(tempateOid)){
+ sb.append("妯℃澘銆�"+tempateName+"銆戜腑绗�"+templateIdRowIndex.get(tempateOid)+"琛屾暟鎹笉灞炰簬褰撳墠妯℃澘鐨勬暟鎹紝璇锋牳瀵�!");
+ }
+ });
+ if(StringUtils.isNotBlank(sb.toString())){
+ throw new Throwable(sb.toString());
+ }
+ if(codeClassifyTemplateVOList.size()>1){
+ String message="妯℃澘銆�"+dataSet.getSheetName()+"銆戞牴鎹垎绫昏矾寰勫垽鏂紝鍒嗙被瀛樺湪澶氫釜妯℃澘";
+
+ throw new Throwable(message);
+ }
+ if(codeClassifyTemplateVOList.size()==0){
+ String message="妯℃澘銆�"+dataSet.getSheetName()+"銆戞牴鎹暟鎹垎绫昏矾寰勫垽鏂紝鏈尮閰嶅埌瀵瑰簲妯℃澘";
+ throw new Throwable(message);
+ }
+ return codeClassifyTemplateVOList ;
+ }
/**
* 浠庡睘鎬т笂鑾峰彇鍙傜収鐨勫唴瀹�
* @param attrVO 灞炴�х殑淇℃伅
@@ -1211,6 +2460,109 @@
//resultVO.setSuccess(true);
return resultVO;
}
+
+ /**
+ * 妫�鏌ュ垎绫荤殑璺緞鏄惁瀛樺湪
+ * @param cboList 涓氬姟鏁版嵁
+ * @param errorMap 閿欒淇℃伅
+ * @param pathMap 璺緞鍜屽垎绫荤殑鏄犲皠
+ */
+ private void checkClassifyPathInHistory(List<ClientBusinessObject> cboList,
+ Map<String,String> errorMap, Map<String/**璺緞**/,CodeClassifyVO> pathMap,
+ Map<String/**涓婚敭**/, String/**璺緞**/> childOidPathMap) {
+ cboList.parallelStream().forEach(cbo -> {
+ String classifyPath = cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD);
+ //濡傛灉path涓虹┖锛屽垯琛ㄧず鏄鍏ュ綋鍓嶅垎绫�
+ if(StringUtils.isBlank(classifyPath)){
+ classifyPath = "#current#";
+ }
+ if ( !pathMap.containsKey(classifyPath)) {
+ String row_index = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ errorMap.put(row_index,errorMap.getOrDefault(row_index,"") + ";鍒嗙被璺緞涓嶅瓨鍦�");
+ } else {
+ //杞竴涓嬪垎绫荤殑涓婚敭
+ try {
+ String classifyOid = pathMap.get(classifyPath).getOid();
+ cbo.setAttributeValueWithNoCheck(CODE_CLASSIFY_OID_FIELD, classifyOid);
+ cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(classifyOid,classifyPath));
+ } catch (VciBaseException e) {
+ log.error("璁剧疆灞炴�х殑閿欒", e);
+ }
+ }
+ });
+ }
+
+ /**
+ * 妫�鏌ュ垎绫讳互鍙婂瓙鍒嗙被鏄惁閮芥湁缂栫爜瑙勫垯
+ * @param classifyVOMap 鍒嗙被鐨勬樉绀哄璞℃槧灏�
+ * @param ruleOidMap 瑙勫垯鐨勪富閿槧灏�
+ * @param unExistRuleClassifyOidList 涓嶅瓨鍦ㄧ紪鐮佽鍒欑殑鍒嗙被鐨勪富閿�
+ */
+ private void checkRuleOidInHistory( Map<String/**涓婚敭**/,CodeClassifyVO> classifyVOMap, Map<String/**鍒嗙被涓婚敭**/,String/**瑙勫垯涓婚敭**/> ruleOidMap,
+ List<String> unExistRuleClassifyOidList ){
+ if(!CollectionUtils.isEmpty(classifyVOMap)){
+ classifyVOMap.values().parallelStream().forEach(classifyVO->{
+ if(StringUtils.isNotBlank(classifyVO.getCoderuleoid())){
+ ruleOidMap.put(classifyVO.getOid(),classifyVO.getCoderuleoid());
+ }else{
+ //閫掑綊鎵句笂绾�
+ List<String> ruleOidList = new ArrayList<>();
+ recursionRule(classifyVOMap,classifyVO.getParentcodeclassifyoid(),ruleOidList);
+ if(!CollectionUtils.isEmpty(ruleOidList)){
+ ruleOidMap.put(classifyVO.getOid(),ruleOidList.get(0));
+ }else{
+ unExistRuleClassifyOidList.add(classifyVO.getOid());
+ }
+ }
+ });
+ }
+ log.info(";;;;");
+ }
+ /**
+ * 閫掑綊鎵剧紪鐮佽鍒�
+ * @param classifyVOMap 鍒嗙被鐨勬樉绀哄璞℃槧灏�
+ * @param classifyOid 鍒嗙被鐨勪富閿�
+ * @param ruleOidList 瑙勫垯鐨勪富閿甽ist
+ */
+ private void recursionRule(Map<String, CodeClassifyVO> classifyVOMap,String classifyOid,List<String> ruleOidList){
+ if(classifyVOMap.containsKey(classifyOid)){
+ CodeClassifyVO classifyVO = classifyVOMap.get(classifyOid);
+ if(StringUtils.isNotBlank(classifyVO.getCoderuleoid())){
+ ruleOidList.add(classifyVO.getCoderuleoid());
+ return;
+ }else{
+ recursionRule(classifyVOMap,classifyVO.getParentcodeclassifyoid(),ruleOidList);
+ }
+ }else{
+ Map<String, CodeClassifyVO> parentClassifyVOMap=new HashMap<>();
+ CodeClassifyVO codeClassifyVO= this.classifyService.getObjectByOid(classifyOid);
+ parentClassifyVOMap.put(codeClassifyVO.getOid(),codeClassifyVO);
+ recursionRule(parentClassifyVOMap,codeClassifyVO.getOid(),ruleOidList);
+ }
+ }
+
+ /**
+ * 鑾峰彇瀛愬垎绫荤殑璺緞
+ * @param classifyFullInfo 鍒嗙被鍏ㄩ儴淇℃伅
+ * @param fullPath 鍒嗙被鐨勫叏璺緞
+ * @return 瀛愬垎绫荤殑璺緞锛宬ey鏄垎绫荤殑涓婚敭
+ */
+ private Map<String/**鍒嗙被鐨勪富閿�**/,String/**鍒嗙被璺緞**/> getChildClassifyPathMap(CodeClassifyFullInfoBO classifyFullInfo,String fullPath){
+ List<CodeClassifyVO> childPathVOs = classifyService.listChildrenClassify(classifyFullInfo.getCurrentClassifyVO().getOid(), true, VciQueryWrapperForDO.OID_FIELD, true);
+ Map<String/**鍒嗙被鐨勪富閿�**/,String/**鍒嗙被鐨勪富閿�**/> childOidPathMap = new ConcurrentHashMap<>();
+ if(!CollectionUtils.isEmpty(childPathVOs)){
+ childPathVOs.parallelStream().forEach(childPath->{
+ // String thisClassifyPath = fullPath + "##" + childPath.getPath().replace("#" + classifyFullInfo.getCurrentClassifyVO().getOid() + "#","").replace("#","##");
+ List<String> list=Arrays.asList(childPath.getPath().split("#"));
+ List<String> newPahtList= list.stream().sorted(Comparator.comparing(s -> s,Comparator.reverseOrder())).collect(Collectors.toList());
+ String thisClassifyPath=StringUtils.join(newPahtList,"##")+fullPath;
+ childOidPathMap.put(childPath.getOid(),thisClassifyPath);
+ });
+ }
+ return childOidPathMap;
+ }
+
+
/**
* 鑾峰彇瀵煎叆鐨勫唴瀹逛腑鍏抽敭灞炴�ч噸澶嶇殑琛屽彿
* @param ketAttrMap 鍏抽敭灞炴�х殑鏄犲皠
@@ -1301,6 +2653,126 @@
}
/***
+ * 鏍规嵁涓嶅悓妯℃澘缁勭粐execl鏁版嵁
+ * @param dataSet
+ * @param pathMap
+ * @param errorMap
+ */
+ private void createExeclClassData(SheetDataSet dataSet,Map<String/**璺緞**/, CodeClassifyVO> pathMap,Map<String,String>errorMap,List<CodeImprotDataVO> codeClassifyDatas){
+
+ Map<String,CodeImprotDataVO> pathDatas=new HashMap<>();
+ List<String> titleRowData= dataSet.getColName();
+ List<SheetRowData> rowDataList= dataSet.getRowData();
+ LinkedHashMap<String,CodeClassifyTemplateVO> codeClassifyTemplateVOMap=new LinkedHashMap <String,CodeClassifyTemplateVO>();
+ LinkedHashMap<String,CodeRuleVO> codeRuleVOVOMap=new LinkedHashMap <String,CodeRuleVO>();
+
+ for (int i=0;i<titleRowData.size();i++){
+ String title= titleRowData.get(i);
+ if(title.equals("鍒嗙被璺緞")) {
+ int finalI = i;
+ rowDataList.stream().forEach(sheetRowData -> {
+ CodeImprotDataVO dataVO=new CodeImprotDataVO();
+ String Path = sheetRowData.getData().get(finalI);
+ String rowIndex=sheetRowData.getRowIndex();
+ Map<Integer, String> execlData= sheetRowData.getData();
+ CodeClassifyTemplateVO newTemplateVO=new CodeClassifyTemplateVO();
+ CodeRuleVO codeRuleVO=new CodeRuleVO();
+ if(StringUtils.isEmpty(Path)){
+ Path="#current#";
+ }
+
+ if(pathMap.containsKey(Path)){
+ CodeClassifyVO codeClassifyVO=pathMap.get(Path);
+ if(codeClassifyTemplateVOMap.containsKey(Path)){
+ newTemplateVO= codeClassifyTemplateVOMap.get(Path);
+ codeRuleVO= codeRuleVOVOMap.get(Path);
+ if(newTemplateVO==null||StringUtils.isBlank(newTemplateVO.getOid())){
+ errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫绘ā鏉�");
+ }
+ if(codeRuleVO==null||StringUtils.isBlank(codeRuleVO.getOid())){
+ errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫昏鍒�");
+ }
+ }else{
+ newTemplateVO =engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
+ if(newTemplateVO==null||StringUtils.isBlank(newTemplateVO.getOid())){
+ errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫绘ā鏉�");
+ }
+ codeRuleVO=engineService.getCodeRuleByClassifyOid(codeClassifyVO.getOid());
+ if(codeRuleVO==null||StringUtils.isBlank(codeRuleVO.getOid())){
+ errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫昏鍒�");
+ }
+ }
+ if(pathMap.containsKey(Path)){
+ dataVO=pathDatas.getOrDefault(Path,dataVO);
+ }
+ dataVO.setTemplateOid(newTemplateVO==null?"":newTemplateVO.getOid());
+ dataVO.setCodeClassifyTemplateVO(newTemplateVO);
+ dataVO.setCodeClassifyVO(codeClassifyVO);
+ dataVO.setCodeRuleVO(codeRuleVO);
+ dataVO.setRowIndex(rowIndex);
+ dataVO.setCodeClassifyOid(codeClassifyVO.getOid());//璁剧疆鍒嗙被oid
+ dataVO.setCodeRuleOid(codeRuleVO==null?"":codeRuleVO.getOid());
+ createExeclClassData(titleRowData,newTemplateVO,execlData,dataVO);
+ pathDatas.put(Path,dataVO);
+ codeClassifyTemplateVOMap.put(Path, newTemplateVO);
+ codeRuleVOVOMap.put(Path,codeRuleVO);
+ }else{
+ errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫�");
+ }
+ });
+ break;
+ }
+ }
+ List <CodeImprotDataVO> newCodeImprotDataVO= pathDatas.values().stream().collect(Collectors.toList());
+ codeClassifyDatas.addAll(newCodeImprotDataVO);
+ log.info("222");
+ }
+ /***
+ * @param titleRowData
+ * @param newTemplateVO
+ * @param execlData
+ * @param codeImprotDataVO
+ */
+ private void createExeclClassData(List<String> titleRowData, CodeClassifyTemplateVO newTemplateVO, Map<Integer, String> execlData, CodeImprotDataVO codeImprotDataVO){
+ //闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+ List<CodeClassifyTemplateAttrVO> attrVOS = newTemplateVO.getAttributes().stream().filter(s ->
+ !DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+ ).collect(Collectors.toList());
+ Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId()));
+ List<String> fields=new ArrayList<>();
+ Map<String,String> filedValueMap=new HashMap<>();
+ List<String> colNames=new ArrayList<>();
+ for (int i = 0; i < titleRowData.size(); i++) {
+ String title = titleRowData.get(i);
+ title=title.replace(KEY_ATTR_CHAR,"").replace(REQUIRED_CHAR,"");
+ String id = attrNameIdMap.getOrDefault(title,"");
+ if(StringUtils.isBlank(id) && "鍒嗙被璺緞".equalsIgnoreCase(title)){
+ id = CODE_CLASSIFY_OID_FIELD;
+ }
+ if(StringUtils.isBlank(id) && "鐮佹瀹藉害".equalsIgnoreCase(title)){
+ id = CODE_SEC_LENGTH_FIELD;
+ }
+ if(StringUtils.isBlank(id) && "浼佷笟缂栫爜".equalsIgnoreCase(title)){
+ id = CODE_FIELD;
+ }
+ if(StringUtils.isNotBlank(id)){
+ // fieldIndexMap.put(i,id);id
+ fields.add(id);
+ colNames.add(title);
+ String value= StringUtils.isNotBlank(execlData.get(i))?execlData.get(i):"";
+ filedValueMap.put(id,value);
+
+ }
+ }
+ // filedValueMap.put(CODE_CLASSIFY_OID_FIELD,codeImprotDataVO.getCodeClassifyOid());//灏嗗綋鍓嶅垎绫籵id瀛樺叆瀛楁涓�
+ filedValueMap.put("codeclassifyid",codeImprotDataVO.getCodeClassifyOid());
+ filedValueMap.put(IMPORT_ROW_INDEX,codeImprotDataVO.getRowIndex());
+ filedValueMap.put("codetemplateoid",newTemplateVO.getOid());
+ codeImprotDataVO.setFields(fields);
+ codeImprotDataVO.setColNames(colNames);
+ codeImprotDataVO.getDatas().add(filedValueMap);
+ }
+ /***
* 姝ｇ‘閿欒鏁版嵁redis缂撳瓨
* @param uuid
* @param templateVO
@@ -1359,6 +2831,50 @@
}
}
+ /******
+ * 鏍规嵁缂栫爜瑙勫垯缂撳瓨鏁版嵁
+ * @param uuid
+ * @param codeImprotDataVOs
+ * @param errorMap
+ * @param isok
+ */
+ private void createRedisDatas(String uuid, List<CodeImprotDataVO> codeImprotDataVOs, Map<String, String> errorMap, boolean isok){
+ codeImprotDataVOs.stream().forEach(codeImprotDataVO -> {
+ List<Map<String, String>> dataLists=new ArrayList<>();
+ CodeImprotDataVO newCodeImprotDataVO=new CodeImprotDataVO();
+ if(errorMap.size()>0) {
+ //瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
+ dataLists = codeImprotDataVO.getDatas().stream().filter(cbo -> {
+ String rowIndex=cbo.get(IMPORT_ROW_INDEX);
+ String msg=StringUtils.isBlank(errorMap.get(rowIndex))?"":errorMap.get(rowIndex);
+ cbo.put("errorMsg",msg);
+ return isok? !errorMap.containsKey(rowIndex):errorMap.containsKey(rowIndex);
+ }).collect(Collectors.toList());
+
+ }else{
+ dataLists= codeImprotDataVO.getDatas();
+ }
+ BeanUtilForVCI.copyPropertiesIgnoreCase(codeImprotDataVO,newCodeImprotDataVO);
+ newCodeImprotDataVO.setDatas(dataLists);
+ List<CodeImprotDataVO> codeImprotDataVOList=new ArrayList<>();
+ codeImprotDataVOList.add(newCodeImprotDataVO);
+ /***update 鏇存敼鎴愪互瑙勫垯鍒嗙粍*****/
+ String codeRuleOid=codeImprotDataVO.getCodeRuleOid();
+ log.info(uuid+"-"+codeRuleOid+":鏉＄洰鏁�"+codeImprotDataVOList.size());
+ if(codeImprotDataVOList.size()>0) {
+ bladeRedis.set(uuid + "-" + codeRuleOid, codeImprotDataVOList);
+ bladeRedis.expire(uuid + "-" + codeRuleOid, BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿
+
+ }
+
+ /*** String codeClassifyOid=codeImprotDataVO.getCodeClassifyOid();
+
+ redisService.setCacheList(uuid+"-"+codeClassifyOid,codeImprotDataVOList);
+ logger.info(uuid+"-"+codeClassifyOid+":鏉＄洰鏁�"+codeImprotDataVOList.size());
+ redisService.expire(uuid+"-"+codeClassifyOid,BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿***/
+ });
+ }
+
/****
* 鏁版嵁鐩镐技椤规暟鎹牎楠宺edis缂撳瓨
* @param codeClassifyOid
--
Gitblit v1.9.3