From 0b8990b4a3cfa8126287a594f0d3810ec97b2e15 Mon Sep 17 00:00:00 2001
From: wangting <675591594@qq.com>
Date: 星期五, 14 七月 2023 16:00:08 +0800
Subject: [PATCH] 弹窗展示
---
Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java | 7726 ++++++++++++++++++++++++++++++-----------------------------
1 files changed, 3,884 insertions(+), 3,842 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 a3bb336..5cfa714 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
@@ -1,67 +1,66 @@
package com.vci.ubcs.code.service.impl;
import com.alibaba.fastjson.JSONObject;
-import com.vci.ubcs.code.constant.MdmBtmTypeConstant;
-import com.vci.ubcs.code.constant.MdmEngineConstant;
+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.lifecycle.CodeDefaultLC;
-import com.vci.code.service.*;
-import com.vci.ubcs.code.vo.pagemodel.*;
-import com.vci.ubcs.code.vo.universalInter.attrmap.DataObjectVO;
-import com.vci.ubcs.code.vo.universalInter.attrmap.RowDatas;
-import com.vci.ubcs.code.vo.universalInter.result.xml.XMLResultDataObjectDetailDO;
-import com.vci.corba.common.VCIError;
-import com.vci.file.util.VciZipUtil;
-import com.vci.starter.poi.bo.*;
-import com.vci.starter.poi.util.ExcelUtil;
-import com.vci.starter.web.constant.QueryOptionConstant;
-import com.vci.starter.web.enumpck.BooleanEnum;
-import com.vci.starter.web.enumpck.UserSecretEnum;
-import com.vci.starter.web.enumpck.VciFieldTypeEnum;
-import com.vci.starter.web.exception.VciBaseException;
-import com.vci.starter.web.pagemodel.BaseResult;
-import com.vci.starter.web.pagemodel.DataGrid;
-import com.vci.starter.web.pagemodel.PageHelper;
-import com.vci.starter.web.pagemodel.SessionInfo;
-import com.vci.starter.web.toolmodel.DateConverter;
-import com.vci.starter.web.util.*;
-import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
+import com.vci.ubcs.code.mapper.CommonsMapper;
import com.vci.ubcs.code.service.*;
-import com.vci.web.pageModel.BatchCBO;
-import com.vci.web.pageModel.KeyValue;
-import com.vci.web.pageModel.OsLifeCycleVO;
-import com.vci.web.pageModel.UIFormReferVO;
-import com.vci.web.redis.RedisService;
-import com.vci.web.service.OsLifeCycleServiceI;
-import com.vci.web.service.WebBoServiceI;
-import com.vci.web.service.WebSecretServiceI;
-import com.vci.web.service.impl.FormulaServiceImpl;
-import com.vci.web.util.PlatformClientUtil;
-import com.vci.web.util.WebUtil;
-import org.apache.commons.collections.map.HashedMap;
-import org.apache.commons.lang3.StringUtils;
+import com.vci.ubcs.code.util.ClientBusinessObject;
+import com.vci.ubcs.code.vo.CodeKeyAttrRepeatVO;
+import com.vci.ubcs.code.vo.pagemodel.*;
+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.feign.IWebSecretClient;
+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;
+import com.vci.ubcs.starter.poi.bo.SheetDataSet;
+import com.vci.ubcs.starter.poi.bo.SheetRowData;
+import com.vci.ubcs.starter.poi.bo.WriteExcelOption;
+import com.vci.ubcs.starter.poi.util.ExcelUtil;
+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.UserSecretEnum;
+import com.vci.ubcs.starter.web.enumpck.VciFieldTypeEnum;
+import com.vci.ubcs.starter.web.pagemodel.*;
+import com.vci.ubcs.starter.web.toolmodel.DateConverter;
+import com.vci.ubcs.starter.web.util.*;
+import lombok.AllArgsConstructor;
+import lombok.RequiredArgsConstructor;
+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;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.RichTextString;
import org.apache.poi.ss.usermodel.Workbook;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
-import com.vci.ubcs.code.bo.CodeTemplateAttrSqlBO;
-import com.vci.ubcs.code.dto.CodeExportAttrDTO;
-import com.vci.ubcs.code.dto.CodeOrderDTO;
-import org.springblade.code.service.*;
-import org.springblade.code.vo.pagemodel.*;
+import org.springblade.core.cache.utils.CacheUtil;
+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.context.annotation.Lazy;
import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
-import plm.bs.bom.clientobject.ClientBusinessObject;
-
+import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.text.MessageFormat;
@@ -71,2984 +70,1652 @@
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.stream.Collectors;
+import static com.alibaba.druid.util.FnvHash.Constants.LIMIT;
+import static com.vci.ubcs.code.constant.MdmEngineConstant.*;
+import static com.vci.ubcs.starter.poi.util.ExcelUtil.*;
-/**
- * 涓绘暟鎹鍏ュ鍑烘湇鍔�
- * @author weidy
- * @date 2022-3-6
- */
+@RequiredArgsConstructor
@Service
-public class MdmIOServiceImpl implements MdmIOServiceI {
+@Slf4j
+public class MdmIOServiceImpl implements MdmIOService {
- @Value("${batchadd.exportattr.type:鍩烘湰淇℃伅}")
- public String BATCHADD_EXCEPORT_ATTR_TYPE;
+ /**
+ * 瀛楁
+ */
+ 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;
+ /**
+ * 涓婚搴撳垎绫荤殑鏈嶅姟
+ */
+ @Resource
+ private ICodeClassifyService classifyService;
- /**
- * 鐢熷懡鍛ㄦ湡鐨勬湇鍔�
- */
- @Autowired
- private OsLifeCycleServiceI lifeCycleService;
+ /**
+ * 閫氱敤鏌ヨ
+ */
+ @Resource
+ private CommonsMapper commonsMapper;
+ /****
+ * 鐮佸�兼湇鍔�
+ */
+ @Resource
+ ICodeAllCodeService codeAllCodeService;
- @Autowired
- private PlatformClientUtil platformClientUtil;
- /**
- * 鍒嗙被浣跨敤鐨勬祦绋嬫ā鏉� 鏈嶅姟
- */
- @Autowired
- private CodeClassifyProcessTempServiceI codeClassifyProcessTempService;
- /**
- * 涓婚搴撳垎绫荤殑鏈嶅姟
- */
- @Autowired
- private CodeClassifyServiceI classifyService;
+ /**
+ * 妯℃澘鐨勬湇鍔�
+ */
+ @Resource
+ private CodeClstemplateServiceImpl templateService;
- @Autowired
- private CodeClassifyTemplateServiceI templateServiceI;
- /**
- * 涓绘暟鎹紩鎿庣殑鏈嶅姟
- */
- @Autowired
- private MdmEngineServiceI engineService;
+ /**
+ * 涓绘暟鎹紩鎿庣殑鏈嶅姟
+ */
+ @Resource
+ private MdmEngineService engineService;
+ /***
+ * resdis缂撳瓨鏈嶅姟
+ */
+ private final BladeRedis bladeRedis;
+ /**
+ * 鐢熸垚缂栫爜鐨勬湇鍔�
+ */
+ @Resource
+ private MdmProductCodeService productCodeService;
+ /**
+ * 鍏抽敭灞炴�х殑閰嶇疆
+ */
+ @Autowired
+ private ICodeKeyAttrRepeatService keyRuleService;
- /**
- * 瑙勫垯鐨勬湇鍔�
- */
- @Autowired
- private CodeRuleServiceI ruleService;
+ /**
+ * 鍏紡鐨勬湇鍔�
+ */
+ @Autowired
+ private FormulaServiceImpl formulaService;
+ /**
+ * 瑙勫垯鐨勬湇鍔�
+ */
+ @Autowired
+ private ICodeRuleService ruleService;
+ /**
+ * 涓氬姟绫诲瀷鐨勬湇鍔�
+ */
+ @Autowired
+ private IBtmTypeClient btmTypeClient;
+ /***
+ * 瀵嗙骇鏈嶅姟
+ */
+ @Resource
+ private IWebSecretClient secretService;
+ /**
+ * 鎵归噺鐢宠锛氶�夊彇閫変腑鍒嗙被涓嬬殑鎵�鏈夋ā鏉垮叧閿睘鎬э紝鐩镐技灞炴�э紝蹇呭～灞炴�э紝鍐欏叆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=(StringUtils.isNotBlank(codetemplateAttr.getAttributeGroup())&& 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,"鍒嗙被灞傜骇"));
- /**
- * 鏁版嵁鐨勬湇鍔�
- */
- @Autowired
- @Lazy
- private WebBoServiceI boService;
-
- /**
- * 鍏紡鐨勬湇鍔�
- */
- @Autowired
- private FormulaServiceImpl formulaService;
-
- /**
- * 缂撳瓨鏈嶅姟
- */
- @Autowired
- private RedisService redisService;
-
- /**
- * 鍏抽敭灞炴��
- */
- public static final String KEY_ATTR_CHAR = "鈽�";
-
- /**
- * 瀛楁
- */
- public static final String ROW_INDEX = "LAY_TABLE_INDEX";
- /**
- * 蹇呰緭
- */
- public static final String REQUIRED_CHAR = "*";
- /**
- * 鏇挎崲瀛楃
- */
- public static final String SPECIAL_CHAR = "VCI";
- /**
- * 寮哄埗鍒嗛〉鐨勬暟閲�
- */
- public static final int LIMIT = 10000;
-
- /**
- * 鏃ュ織
- */
- private Logger logger = LoggerFactory.getLogger(getClass());
-
- /**
- * 鍏抽敭灞炴�х殑閰嶇疆
- */
- @Autowired
- private CodeKeyAttrRepeatRuleServiceI keyRuleService;
-
- /**
- * 缂栫爜鐢熸垚鏈嶅姟绫�
- */
- @Autowired
- private MdmProductCodeServiceI productCodeService;
-
- /**
- * 妯℃澘鐨勬湇鍔�
- */
- @Autowired
- private CodeClassifyTemplateServiceI templateService;
-
- /**
- * 瀵嗙骇鐨勬湇鍔�
- */
- @Autowired
- private WebSecretServiceI secretService;
-
- /**
- * 瀵煎嚭涓婚搴撶殑鏁版嵁
- *
- * @param exportAttrDTO 瀵煎嚭鐩稿叧鐨勯厤缃紝蹇呴』瑕佹湁涓婚搴撳垎绫荤殑涓婚敭
- * @return 瀵煎嚭鐨別xcel鐨勬枃浠�
- */
- @Override
- public String exportCode(CodeExportAttrDTO exportAttrDTO) {
- VciBaseUtil.alertNotNull(exportAttrDTO,"瀵煎嚭鐨勯厤缃�",exportAttrDTO.getCodeClassifyOid(),"涓婚搴撳垎绫荤殑涓婚敭");
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(exportAttrDTO.getCodeClassifyOid());
- //鑾峰彇鏈�鏂扮殑妯℃澘
- CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(exportAttrDTO.getCodeClassifyOid());
- //鍏堟煡璇㈡暟鎹�
- String btmTypeId = classifyFullInfo.getTopClassifyVO().getBtmtypeid();
- Map<String, String> conditionMap = exportAttrDTO.getConditionMap();
- if(conditionMap == null){
- conditionMap = new HashMap<>();
- }
- if(conditionMap.containsKey(VciQueryWrapperForDO.OID_FIELD)){
- conditionMap.put(VciQueryWrapperForDO.OID_FIELD,QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(conditionMap.get(VciQueryWrapperForDO.OID_FIELD)) + ")");
- }
- PageHelper pageHelper = new PageHelper(exportAttrDTO.getLimit()==null?-1:exportAttrDTO.getLimit());
- pageHelper.setPage(exportAttrDTO.getPage()==null?1:exportAttrDTO.getPage());
- pageHelper.setSort(exportAttrDTO.getSort());
- pageHelper.setOrder(exportAttrDTO.getOrder());
-
- pageHelper.addDefaultDesc("createTime");
- conditionMap.put("codeclsfpath","*" + exportAttrDTO.getCodeClassifyOid() + "*");
-
- //鍏堟煡璇㈡�绘暟
- int total = 0;
- if(exportAttrDTO.getEndPage()!=null && exportAttrDTO.getEndPage()>0
- &&exportAttrDTO.getPage() !=null && exportAttrDTO.getPage() >0
- &&exportAttrDTO.getEndPage()>exportAttrDTO.getPage()){
- //浠庡灏戦〉鍒板灏戦〉鐨勬煡璇㈡柟寮忥紝
- for(int i = exportAttrDTO.getPage() ;i <= exportAttrDTO.getEndPage();i++){
- PageHelper thisPage = new PageHelper(exportAttrDTO.getLimit()==null?-1:exportAttrDTO.getLimit());
- thisPage.setPage(exportAttrDTO.getPage()==null?1:exportAttrDTO.getPage());
- thisPage.setSort(exportAttrDTO.getSort());
- thisPage.setOrder(exportAttrDTO.getOrder());
- thisPage.addDefaultDesc("createTime");
- total += boService.queryCount(btmTypeId, conditionMap);
- }
- }else{
- total=boService.queryCount(btmTypeId, conditionMap);
- }
- List<String> selectFieldList = new ArrayList<>();
- if(!CollectionUtils.isEmpty(exportAttrDTO.getAttrIdIndexMap())){
- selectFieldList = exportAttrDTO.getAttrIdIndexMap().values().stream().map(s->s.toLowerCase(Locale.ROOT)).collect(Collectors.toList());
- }else{
- selectFieldList = templateVO.getAttributes().stream().filter(s->VciBaseUtil.getBoolean(s.getFormdisplayflag())
- ||VciBaseUtil.getBoolean(s.getTabledisplayflag())).map(s->s.getId().toLowerCase(Locale.ROOT)).collect(Collectors.toList());
- }
- //鍙傜収璁╁钩鍙扮洿鎺ユ煡璇㈠氨琛�
- List<String> finalSelectFieldList = selectFieldList;
- List<CodeClassifyTemplateAttrVO> referAttrVOs = templateVO.getAttributes().stream().filter(
- s -> StringUtils.isNotBlank(s.getReferbtmid())
- &&
- (finalSelectFieldList.size() ==0 || finalSelectFieldList.contains(s.getId().toLowerCase(Locale.ROOT)))
- ).collect(Collectors.toList());
- if(!CollectionUtils.isEmpty(referAttrVOs)){
- for (int i = 0; i < referAttrVOs.size(); i++) {
- selectFieldList.add(referAttrVOs.get(i).getId() + ".name");
- }
- }
- List<String> excelNameList = new CopyOnWriteArrayList<>();
- String tempFolder = LocalFileUtil.getDefaultTempFolder();
-
- if(total>LIMIT){
- //鍒嗙粍鏉ユ墽琛�
- int queryCount = (total-total%LIMIT)/LIMIT;
- if(total%LIMIT>0){
- queryCount = queryCount + 1;
- }
- List<Integer> indexList = new ArrayList<>();
- for (int i = 0; i <queryCount ; i++) {
- indexList.add(i);
- }
- Map<String, String> finalConditionMap = conditionMap;
- //骞惰鏌ヨ鐪嬬湅
- SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
- indexList.parallelStream().forEach(index->{
- //绾跨▼鐨勬柟寮忥紝鎵�浠ラ渶瑕佽缃綋鍓嶇敤鎴�
- VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
- PageHelper thisPage = new PageHelper(LIMIT);
- thisPage.setPage(index+1);
- thisPage.setSort(exportAttrDTO.getSort());
- thisPage.setOrder(exportAttrDTO.getOrder());
- thisPage.addDefaultDesc("createTime");
- selectDataAndExportExcelName(btmTypeId, finalConditionMap,thisPage,finalSelectFieldList,
- classifyFullInfo,templateVO,exportAttrDTO,
- excelNameList,tempFolder,index);
- });
- }else{
- pageHelper.setLimit(total);
- pageHelper.setPage(1);
- selectDataAndExportExcelName(btmTypeId,conditionMap,pageHelper,finalSelectFieldList,
- classifyFullInfo,templateVO,exportAttrDTO,
- excelNameList,tempFolder,1);
- }
- if(excelNameList.size() ==0){
- throw new VciBaseException("娌℃湁鏁版嵁鍙互琚鍑�");
- }
- if(excelNameList.size() == 1){
- return excelNameList.get(0);
- }
- //鏄涓紝鎴戜滑闇�瑕佹墦鎴愬帇缂╁寘
-
- String zipFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + classifyFullInfo.getCurrentClassifyVO().getId() + "_" + classifyFullInfo.getCurrentClassifyVO().getName() + "_瀵煎嚭_" + excelNameList.size()+".zip";
- VciZipUtil zipUtil = new VciZipUtil();
- File file = new File(tempFolder);
- zipUtil.addFileToZip(file,zipFileName);
- File[] files = file.listFiles();
- for (int i = 0; i < files.length; i++) {
- LocalFileUtil.deleteTempFile(files[i],false);
- }
- LocalFileUtil.deleteTempFile(file,true);
- return zipFileName;
- }
-
- /**
- * 鎵归噺鐢宠锛氶�夊彇閫変腑鍒嗙被涓嬬殑鎵�鏈夋ā鏉垮叧閿睘鎬э紝鐩镐技灞炴�э紝蹇呭～灞炴�э紝鍐欏叆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 ->
- !MdmEngineConstant.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.setKeyattrflag(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);
+ 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()));
+ 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 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]++;
- });
+ 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);
+ 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);
+ 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;
- }
+ String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + codeClassifyVO.getName() + "_瀵煎叆妯℃澘.xls";
+ // eo.addSheetDataList(templateVOList.size()+"妯℃澘淇℃伅銆愯鍕垮垹闄ゆ垨绉诲姩銆�",tempEDList);
+ ExcelUtil.writeDataToFile(excelName,eo);
+ return excelName;
+ }
- /**
- * 鐢熸垚瀵煎叆鐨勬枃浠�
- *
- * @param codeClassifyOid 鍒嗙被鐨勪富閿�
- * @param isHistory 鏄惁鍘嗗彶鏁版嵁瀵煎叆
- * @return excel鐨勬枃浠跺湴鍧�
- */
- @Override
- public String createImportExcel(String codeClassifyOid,boolean isHistory) {
- List<CodeClassifyTemplateVO> templateVOList=new ArrayList<>();
- VciBaseUtil.alertNotNull("瀵煎嚭妯℃澘","瀵煎嚭鐨勯厤缃�",codeClassifyOid,"涓婚搴撳垎绫荤殑涓婚敭");
- CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);
- if(isHistory){
- templateVOList= templateService.childTemplates(codeClassifyOid);
- }else{
- //鎵炬ā鏉�
- CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyOid);
- templateVOList.add(templateVO);
- }
+ /**
+ * 鐢熸垚瀵煎叆鐨勬枃浠�
+ *
+ * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+ * @param isHistory 鏄惁鍘嗗彶鏁版嵁瀵煎叆
+ * @return excel鐨勬枃浠跺湴鍧�
+ */
+ @Override
+ public String createImportExcel(String codeClassifyOid, boolean isHistory) {
+ List<CodeClassifyTemplateVO> templateVOList=new ArrayList<>();
- WriteExcelOption eo = new WriteExcelOption();
- eo.setAppend(true);
- //澧炲姞妯℃澘鐨勪俊鎭鍏�
- LinkedList<WriteExcelData> tempEDList = new LinkedList<>();
- tempEDList.add(new WriteExcelData(0,0,"妯℃澘涓婚敭"));
- tempEDList.add(new WriteExcelData(0,1,"妯℃澘浠ｅ彿"));
- tempEDList.add(new WriteExcelData(0,2,"妯℃澘鍚嶇О"));
- for(int j=0;j<templateVOList.size();j++){
- CodeClassifyTemplateVO templateVO=templateVOList.get(j);
+ VciBaseUtil.alertNotNull("瀵煎嚭妯℃澘","瀵煎嚭鐨勯厤缃�",codeClassifyOid,"涓婚搴撳垎绫荤殑涓婚敭");
- //缁勫悎鏍煎紡鐨勪笉瀵煎叆锛�
- // 鏋氫妇鐨勬彁渚涘簭鍒楃殑閫夋嫨
- //鏃堕棿鍏ㄩ儴缁熶竴涓簓yyy-MM-dd HH:mm:ss
- //鍙傜収鐨勮嚜琛岃緭鍏ュ悕绉�
- //鍒嗙被娉ㄥ叆鐨勪笉鐢紝閮芥槸瀵煎叆鍚庤嚜鍔ㄥ鐞嗙殑
- //缂栫爜锛岀姸鎬佺瓑瀛楁涓嶅鍏�
- List<CodeClassifyTemplateAttrVO> templateAttrVOS = templateVO.getAttributes().stream().filter(s ->
- !MdmEngineConstant.DEFAULT_ATTR_LIST.contains(s.getId())
- && StringUtils.isBlank(s.getComponentrule())
- && StringUtils.isBlank(s.getClassifyinvokeattr())
- && (isHistory || VciBaseUtil.getBoolean(s.getFormdisplayflag()))
- ).collect(Collectors.toList());
- if(CollectionUtils.isEmpty(templateAttrVOS)){
- throw new VciBaseException("妯℃澘娌℃湁閰嶇疆浠讳綍銆愯〃鍗曟樉绀恒�戜负銆愭槸銆戠殑灞炴��");
- }
- List<CodeClassifyTemplateAttrVO> idAttrVOList = templateVO.getAttributes().stream().filter(s -> s.getId().equalsIgnoreCase(MdmEngineConstant.CODE_FIELD)).collect(Collectors.toList());
- LinkedList<WriteExcelData> excelDataList = new LinkedList<>();
- Workbook workbook = new HSSFWorkbook();
- if(isHistory){
- excelDataList.add(new WriteExcelData(0,0,"鍒嗙被璺緞"));
- excelDataList.add(new WriteExcelData(0,1,"鐮佹瀹藉害"));
- excelDataList.add(new WriteExcelData(0,2,!CollectionUtils.isEmpty(idAttrVOList)?idAttrVOList.get(0).getName():"浼佷笟缂栫爜"));
- }
- for (int i = 0; i < templateAttrVOS.size(); i++) {
- CodeClassifyTemplateAttrVO attrVO = templateAttrVOS.get(i);
- Object text = attrVO.getName();
- text = exportKeyAndRequired(workbook,attrVO,text);
- int colIndex = (isHistory?3:0) + i;
- 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<>();
+ CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);
- 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(j+templateVO.getName(),excelDataList);
- tempEDList.add(new WriteExcelData(j+1,0,templateVO.getOid()));
- tempEDList.add(new WriteExcelData(j+1,1,templateVO.getId()));
- tempEDList.add(new WriteExcelData(j+1,2,templateVO.getName()));
- }
- String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + codeClassifyVO.getName() + (isHistory?"_鍘嗗彶鏁版嵁瀵煎叆妯℃澘.xls": "_瀵煎叆妯℃澘.xls");
- eo.addSheetDataList(templateVOList.size()+"妯℃澘淇℃伅銆愯鍕垮垹闄ゆ垨绉诲姩銆�",tempEDList);
- ExcelUtil.writeDataToFile(excelName,eo);
- return excelName;
- }
+ if(isHistory){
+ templateVOList= templateService.childTemplates(codeClassifyOid);
+ }else{
+ //鎵炬ā鏉�
+ CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyOid);
+ templateVOList.add(templateVO);
+ }
+
+ WriteExcelOption eo = new WriteExcelOption();
+ eo.setAppend(true);
+ //澧炲姞妯℃澘鐨勪俊鎭鍏�
+ LinkedList<WriteExcelData> tempEDList = new LinkedList<>();
+ tempEDList.add(new WriteExcelData(0,0,"妯℃澘涓婚敭"));
+ tempEDList.add(new WriteExcelData(0,1,"妯℃澘浠ｅ彿"));
+ tempEDList.add(new WriteExcelData(0,2,"妯℃澘鍚嶇О"));
+ for(int j=0;j<templateVOList.size();j++){
+ CodeClassifyTemplateVO templateVO=templateVOList.get(j);
+ CodeClassifyTemplateVO codeClassifyTemplateVO = new CodeClassifyTemplateVO();
+ BeanUtils.copyProperties(templateVO,codeClassifyTemplateVO);
+ //缁勫悎鏍煎紡鐨勪笉瀵煎叆锛�
+ // 鏋氫妇鐨勬彁渚涘簭鍒楃殑閫夋嫨
+ //鏃堕棿鍏ㄩ儴缁熶竴涓簓yyy-MM-dd HH:mm:ss
+ //鍙傜収鐨勮嚜琛岃緭鍏ュ悕绉�
+ //鍒嗙被娉ㄥ叆鐨勪笉鐢紝閮芥槸瀵煎叆鍚庤嚜鍔ㄥ鐞嗙殑
+ //缂栫爜锛岀姸鎬佺瓑瀛楁涓嶅鍏�
+ List<CodeClassifyTemplateAttrVO> codeClassifyTemplateAttrVOList=codeClassifyTemplateVO.getAttributes();
+ if(!CollectionUtils.isEmpty(codeClassifyTemplateAttrVOList)) {
+ if (CollectionUtils.isEmpty(codeClassifyTemplateAttrVOList)) {
+ throw new VciBaseException("妯℃澘娌℃湁閰嶇疆灞炴��");
+ }
+ }
+ List<CodeClassifyTemplateAttrVO> templateAttrVOS = codeClassifyTemplateAttrVOList.stream().filter(s ->
+ !DEFAULT_ATTR_LIST.contains(s.getId())
+ && StringUtils.isBlank(s.getComponentRule())
+ && StringUtils.isBlank(s.getClassifyInvokeAttr())
+ && (isHistory || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
+ ).collect(Collectors.toList());
+
+ if (CollectionUtils.isEmpty(templateAttrVOS)) {
+ throw new VciBaseException("妯℃澘娌℃湁閰嶇疆浠讳綍銆愯〃鍗曟樉绀恒�戜负銆愭槸銆戠殑灞炴��");
+ }
+
+ List<CodeClassifyTemplateAttrVO> idAttrVOList = codeClassifyTemplateVO.getAttributes().stream().filter(s -> s.getId().equalsIgnoreCase(CODE_FIELD)).collect(Collectors.toList());
+ LinkedList<WriteExcelData> excelDataList = new LinkedList<>();
+ Workbook workbook = new HSSFWorkbook();
+ if(isHistory){
+ excelDataList.add(new WriteExcelData(0,0,"鍒嗙被璺緞"));
+ excelDataList.add(new WriteExcelData(0,1,"鐮佹瀹藉害"));
+ excelDataList.add(new WriteExcelData(0,2,!CollectionUtils.isEmpty(idAttrVOList)?idAttrVOList.get(0).getName():"浼佷笟缂栫爜"));
+ }
+ for (int i = 0; i < templateAttrVOS.size(); i++) {
+ CodeClassifyTemplateAttrVO attrVO = templateAttrVOS.get(i);
+
+ Object text = attrVO.getName();
+ text = exportKeyAndRequired(workbook,attrVO,text);
+ int colIndex = (isHistory?3:0) + i;
+ 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(j+templateVO.getName(),excelDataList);
+ tempEDList.add(new WriteExcelData(j+1,0,templateVO.getOid()));
+ tempEDList.add(new WriteExcelData(j+1,1,templateVO.getId()));
+ tempEDList.add(new WriteExcelData(j+1,2,templateVO.getName()));
+ }
+ String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + codeClassifyVO.getName() + (isHistory?"_鍘嗗彶鏁版嵁瀵煎叆妯℃澘.xls": "_瀵煎叆妯℃澘.xls");
+ eo.addSheetDataList(templateVOList.size()+"妯℃澘淇℃伅銆愯鍕垮垹闄ゆ垨绉诲姩銆�",tempEDList);
+ ExcelUtil.writeDataToFile(excelName,eo);
+ return excelName;
+ }
+
+ /**
+ * 瀵煎嚭鐨勬椂鍊欏皝瑁呭繀杈撳拰鍏抽敭灞炴��
+ * @param attrVO 灞炴�х殑鏄剧ず瀵硅薄
+ * @param text 鍗曞厓鏍肩殑鍊�
+ */
+ private Object exportKeyAndRequired(Workbook workbook,CodeClassifyTemplateAttrVO attrVO,Object text){
+ //蹇呰緭鍔�*锛屽叧閿睘鎬т负钃濊壊
+ if (VciBaseUtil.getBoolean(attrVO.getRequireFlag()) || VciBaseUtil.getBoolean(attrVO.getKeyAttrFlag())) {
+ String value = text.toString();
+ if(VciBaseUtil.getBoolean(attrVO.getRequireFlag())) {
+ value += REQUIRED_CHAR;
+ }
+ if(VciBaseUtil.getBoolean(attrVO.getKeyAttrFlag())){
+ value += KEY_ATTR_CHAR;
+ }
+ RichTextString ts = new HSSFRichTextString(value);
+ if(VciBaseUtil.getBoolean(attrVO.getRequireFlag())){
+ Font font = workbook.createFont();
+ font.setColor(HSSFColor.HSSFColorPredefined.RED.getIndex());
+ ts.applyFont(font);
+ }
+
+ if(VciBaseUtil.getBoolean(attrVO.getKeyAttrFlag())){
+ Font font = workbook.createFont();
+ font.setColor(HSSFColor.HSSFColorPredefined.BLUE.getIndex());
+ ts.applyFont(font);
+ }
+ return ts;
+ }
+ return text;
+ }
- /**
- * 鐢熸垚瀵煎叆鐨勬枃浠�
- *
- * @param codeClassifyOid 鍒嗙被鐨勪富閿�
- * @param isHistory 鏄惁鍘嗗彶鏁版嵁瀵煎叆
- * @return excel鐨勬枃浠跺湴鍧�
- */
- /*@Override
- public String createImportExcel(String codeClassifyOid,boolean isHistory) {
- CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);
- if(isHistory && !templateService.checkChildHasSameTemplate(codeClassifyOid)){
- throw new VciBaseException("褰撳墠閫夋嫨鐨勪富棰樺簱鍒嗙被鐨勬墍鏈変笅绾ц妭鐐逛腑瀛樺湪涓嶅悓鐨勬ā鏉跨殑鎯呭喌");
- }
- //鎵炬ā鏉�
- CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
- //缁勫悎鏍煎紡鐨勪笉瀵煎叆锛�
- //鏋氫妇鐨勬彁渚涘簭鍒楃殑閫夋嫨
- //鏃堕棿鍏ㄩ儴缁熶竴涓簓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())
- && (isHistory || VciBaseUtil.getBoolean(s.getFormdisplayflag()))
- ).collect(Collectors.toList());
- if(CollectionUtils.isEmpty(templateAttrVOS)){
- throw new VciBaseException("妯℃澘娌℃湁閰嶇疆浠讳綍銆愯〃鍗曟樉绀恒�戜负銆愭槸銆戠殑灞炴��");
- }
- List<CodeClassifyTemplateAttrVO> idAttrVOList = templateVO.getAttributes().stream().filter(s -> s.getId().equalsIgnoreCase(CODE_FIELD)).collect(Collectors.toList());
- List<WriteExcelData> excelDataList = new ArrayList<>();
- Workbook workbook = new HSSFWorkbook();
- if(isHistory){
- excelDataList.add(new WriteExcelData(0,0,"鍒嗙被璺緞"));
- excelDataList.add(new WriteExcelData(0,1,"鐮佹瀹藉害"));
- excelDataList.add(new WriteExcelData(0,2,!CollectionUtils.isEmpty(idAttrVOList)?idAttrVOList.get(0).getName():"浼佷笟缂栫爜"));
- }
- for (int i = 0; i < templateAttrVOS.size(); i++) {
- CodeClassifyTemplateAttrVO attrVO = templateAttrVOS.get(i);
- Object text = attrVO.getName();
- text = exportKeyAndRequired(workbook,attrVO,text);
- int colIndex = (isHistory?3:0) + i;
- 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<>();
+ /**
+ * 鎵归噺鐢宠缂栫爜鏁版嵁
+ *
+ * @param orderDTO 缂栫爜鐢宠淇℃伅锛屽繀椤诲寘鍚垎绫讳富閿拰鐮佹鐨勪俊鎭�
+ * @param file excel鏂囦欢鐨勪俊鎭�
+ * @return 鏈夐敊璇俊鎭殑excel鐨勬枃浠�
+ */
+ @Override
+ public CodeImProtRusultVO batchImportCode(CodeOrderDTO orderDTO, File file) {
+ VciBaseUtil.alertNotNull(orderDTO,"缂栫爜鐢宠鐩稿叧鐨勬暟鎹�",orderDTO.getCodeClassifyOid(),"涓婚搴撳垎绫讳富閿�");
+ 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);
+ //鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
+ CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());
- 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);
- }
- }
- //澧炲姞妯℃澘鐨勪俊鎭鍏�
- List<WriteExcelData> tempEDList = new ArrayList<>();
- tempEDList.add(new WriteExcelData(0,0,templateVO.getOid()));
- tempEDList.add(new WriteExcelData(0,1,templateVO.getId()));
- tempEDList.add(new WriteExcelData(0,2,templateVO.getName()));
- String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + codeClassifyVO.getName() + (isHistory?"_鍘嗗彶鏁版嵁瀵煎叆妯℃澘.xls": "_瀵煎叆妯℃澘.xls");
- WriteExcelOption eo = new WriteExcelOption(excelDataList);
- eo.addSheetDataList("妯℃澘淇℃伅銆愯鍕垮垹闄ゆ垨绉诲姩銆�",tempEDList);
- ExcelUtil.writeDataToFile(excelName,eo);
- return excelName;
- }*/
-
- /**
- * 鎵归噺鐢宠缂栫爜鏁版嵁
- *
- * @param orderDTO 缂栫爜鐢宠淇℃伅锛屽繀椤诲寘鍚垎绫讳富閿拰鐮佹鐨勪俊鎭�
- * @param file excel鏂囦欢鐨勪俊鎭�
- * @return 鏈夐敊璇俊鎭殑excel鐨勬枃浠�
- */
- @Override
- public CodeImProtRusultVO batchImportCode(CodeOrderDTO orderDTO, File file) {
- VciBaseUtil.alertNotNull(orderDTO,"缂栫爜鐢宠鐩稿叧鐨勬暟鎹�",orderDTO.getCodeClassifyOid(),"涓婚搴撳垎绫讳富閿�");
- 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);
- //鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
- CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());
- //鏍￠獙妯℃澘鏄笉鏄渶鏂扮殑
- checkTemplateSync(sheetDataSetList,templateVO,0);
- //鍏堜笉鐢ㄧ灞炴�ф槸鍚﹂兘瀛樺湪锛屽厛杞崲涓�涓嬫暟鎹�
- Map<String,String> errorMap = new HashMap<>();
- String redisUUid=batchImportCodes(orderDTO,templateVO,dataSet,errorMap,true);
- CodeImProtRusultVO codeImProtRusultVO = new CodeImProtRusultVO();
- List<String> needRowIndexList = new ArrayList<>();
- String filePath = returnErrorToExcel(dataSet.getRowData(), errorMap, needRowIndexList, dataSet.getColName());
- if(StringUtils.isNotBlank(filePath)) {
- codeImProtRusultVO.setFilePath(filePath);
- }
- if(StringUtils.isNotBlank(redisUUid)){
- codeImProtRusultVO.setRedisUuid(redisUUid);
- }
- return codeImProtRusultVO;
- }
+ //鏍￠獙妯℃澘鏄笉鏄渶鏂扮殑
+ checkTemplateSync(sheetDataSetList,templateVO,0);
+ //鍏堜笉鐢ㄧ灞炴�ф槸鍚﹂兘瀛樺湪锛屽厛杞崲涓�涓嬫暟鎹�
+ Map<String,String> errorMap = new HashMap<>();
+ String redisUUid=batchImportCodes(orderDTO,templateVO,dataSet,errorMap,true);
+ CodeImProtRusultVO codeImProtRusultVO = new CodeImProtRusultVO();
+ List<String> needRowIndexList = new ArrayList<>();
+ String filePath = returnErrorToExcel(dataSet.getRowData(), errorMap, needRowIndexList, dataSet.getColName());
+ if(StringUtils.isNotBlank(filePath)) {
+ codeImProtRusultVO.setFilePath(filePath);
+ }
+ if(StringUtils.isNotBlank(redisUUid)){
+ codeImProtRusultVO.setRedisUuid(redisUUid);
+ }
+// return null;
+ return codeImProtRusultVO;
+ }
- /***
- * 鎵归噺澶勭悊鐢宠鏁版嵁
- * @param orderDTO
- * @param templateVO
- * @param dataSet
- * @return
- */
- private String batchImportCodes(CodeOrderDTO orderDTO,CodeClassifyTemplateVO templateVO,SheetDataSet dataSet,Map<String,String> errorMap,boolean isEnumType){
- List<String> codeList=new ArrayList<>();
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
- //瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
- CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
- //1.鍒ゆ柇瑙勫垯涓櫎浜嗘祦姘寸爜娈碉紝鏄惁鏈夊叾浠栫爜娈�
- engineService.checkSecValueOnOrder(ruleVO,orderDTO);
- List<SheetRowData> rowDataList = dataSet.getRowData();
+ /***
+ * 浠庨《灞傛壒閲忕敵璇峰鍏ユ柟娉�
+ * @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<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
- !MdmEngineConstant.DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormdisplayflag())
- ).collect(Collectors.toList());
- Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
- List<String> titleRowData = dataSet.getColName();
- Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT),(o1, o2)->o2));
- getFieldIndexMap(titleRowData,attrNameIdMap,fieldIndexMap);
+ 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);
- //闇�瑕佸垽鏂槸鍚︽墍鏈夌殑灞炴�ч兘鍦ㄦā鏉夸笂浜�
- List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
- && StringUtils.isBlank(s.getComponentrule()) && StringUtils.isBlank(s.getClassifyinvokeattr())//缁勫悎瑙勫垯鍜屽垎绫绘敞鍏ョ‘瀹炴病缁欑敤鎴峰鍑哄幓
- ).collect(Collectors.toList());
- if(!CollectionUtils.isEmpty(unExistAttrVOs)){
- throw new VciBaseException("銆�" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "銆戣繖浜涘睘鎬у湪鍒楄〃涓病鏈夋壘鍒�");
- }
- List<ClientBusinessObject> cboList = new ArrayList<>();
- String fullPath = getFullPath(classifyFullInfo);
- excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,true);
+ //鏍规嵁妯℃澘灏嗘暟鎹暣鍚堝湪涓�璧凤紝鍘绘牎楠�
+ 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<>();
- //閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
- //濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌excel涓�
- //2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
- batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);
- //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,"") + ";鍦ㄥ綋鍓嶅鐞嗙殑鏁版嵁鏂囦欢涓叧閿睘鎬ч噸澶�" );
- });
- }
- if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
- keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
- errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
- });
- }
- //鍒嗙被娉ㄥ叆
- batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
- //boolean
- reSwitchBooleanAttrOnOrder(attrVOS,cboList);
- //4.鏍￠獙瑙勫垯
- batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
- if(isEnumType) {//鏄惁闇�瑕佹牎楠屾灇涓�/鍙傜収
- //5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
- batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
- //7.澶勭悊鍙傜収鐨勬儏鍐�
- batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
- }
- //6.鏃堕棿鏍煎紡鐨勯獙璇�
- //6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
- batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
- //鏈�鍚庡紕缁勫悎瑙勫垯
- batchSwitchComponentAttrOnOrder(attrVOS,cboList);
- String uuid=redisService.getUUIDEveryDay();
- Map<String, ClientBusinessObject> rowIndexCboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((MdmEngineConstant.IMPORT_ROW_INDEX)), t -> t));
+ //鐩镐技鏁版嵁
+ // 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);
- if(errorMap.size()>0) {
- createRedisDatas(uuid + "-error",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, errorMap,false);
- }
- boolean isCreateUUid=false;
- List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.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(orderDTO.getCodeClassifyOid(),templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
- if(resembleMap.size()>0) {
- isCreateUUid=true;
- if(!CollectionUtils.isEmpty(dataResembleVOS)) {
- redisService.setCacheList(uuid + "-resemble-data", dataResembleVOS);
- createRedisDatas(uuid + "-resemble",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, resembleMap, false);
- }
- }
- //鎺掗櫎閿欒鐨勶紝鍓╀笅姝ｇ‘鐨�
- Map<String,String> newErrorMap=new HashMap<>();
- newErrorMap.putAll(resembleMap);
- newErrorMap.putAll(errorMap);
- needSaveCboList = cboList.stream().filter(cbo -> {
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- return !newErrorMap.containsKey(rowIndex);
- }).collect(Collectors.toList());
- if((errorMap.size()>0&&needSaveCboList.size()>0)||resembleMap.size()>0){
- isCreateUUid=true;
- }
- createRedisByCodeClassify(uuid + "-class",templateVO,dataSet,fieldIndexMap,false);
- if(newErrorMap.size()>0) {
- createRedisDatas(uuid + "-ok",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap,true);
- }else {
- uuid="";
- //瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
- needSaveCboList = cboList.stream().filter(cbo -> {
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- return !newErrorMap.containsKey(rowIndex);
- }).collect(Collectors.toList());
- if (!CollectionUtils.isEmpty(needSaveCboList)) {
- //9.鎴戜滑澶勭悊涓氬姟鏁版嵁
- //鐢熸垚缂栫爜鐨勫唴瀹�
- codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(), needSaveCboList);
- //濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
- engineService.batchSaveSelectChar(templateVO, needSaveCboList);
- }
- }
- if(!isCreateUUid){
- return uuid="";
- }
- return uuid;
- }
+ //闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+ List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
+ !DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+ ).collect(Collectors.toList());
- /***
- * 瀛樺偍鍒嗙被瀵硅薄鍙婂叾鍒楀悕
- * @param uuid
- * @param templateVOList
- * @param dataSet
- * @param fieldIndexMap
- * @param iscContain
- */
- private void createRedisByCodeClassify(String uuid,CodeClassifyTemplateVO templateVOList,SheetDataSet dataSet, Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap,boolean iscContain){
- List<ColumnVO> columnVOList = new ArrayList<>();
- List<String> outNameList = dataSet.getColName();
- fieldIndexMap.forEach((integer, s) -> {
- ColumnVO columnVOS = new ColumnVO();
- String field = fieldIndexMap.get(integer);
- String outName = outNameList.get(integer);
- columnVOS.setField(field);
- columnVOS.setTitle(outName);
- columnVOList.add(columnVOS);
- });
- CodeImportTemplateVO codeImportTemplateVO=new CodeImportTemplateVO();
- codeImportTemplateVO.setCodeClassifyTemplateVO(templateVOList);
- codeImportTemplateVO.setCloNamesList(columnVOList);
- List<CodeImportTemplateVO> codeImportTemplateVOs= new ArrayList<>();
- codeImportTemplateVOs.add(codeImportTemplateVO);
- redisService.setCacheList(uuid,codeImportTemplateVOs);
- redisService.expire(uuid,6000000);//redis杩囨湡鏃堕棿
- logger.info("");
- }
- private void createRedisDatas(String uuid,CodeClassifyTemplateVO templateVO,Map<String,ClientBusinessObject> rowIndexCbo, SheetDataSet dataSet, Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap,Map<String,String> errorMap,boolean isok){
- List<SheetRowData> needsheetRowDataList =new ArrayList<>();
- if(errorMap.size()>0) {
- //瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
- needsheetRowDataList = dataSet.getRowData().stream().filter(cbo -> {
- String rowIndex=cbo.getRowIndex();
- return isok? !errorMap.containsKey(rowIndex):errorMap.containsKey(rowIndex);
- }).collect(Collectors.toList());
+ Map<String/**妯℃澘灞炴�у瓧娈祇id**/, String /**妯℃澘灞炴�у閮ㄥ悕绉�**/> fieldNameMap =attrVOS.stream().collect(Collectors.toMap(CodeClassifyTemplateAttrVO::getId,s->s.getName()));
- }else{
- needsheetRowDataList= dataSet.getRowData();
- }
- Map<String/**涓枃鍚嶇О**/, SheetRowData/**鑻辨枃鍚嶇О**/> rowIdexDataMap = needsheetRowDataList.stream().collect(Collectors.toMap(s -> s.getRowIndex(), t -> t,(o1, o2)->o2));
- Map<String, CodeImprotDataVO> clsfDataMap=new HashMap<>();
- rowIndexCbo .forEach((rowIndex, cbo) -> {
- CodeImprotDataVO codeImprotDataVO = new CodeImprotDataVO();
- codeImprotDataVO.setTemplateOid(templateVO.getOid());
- List<Map<String, String>> dataList = new ArrayList<>();
- if(rowIdexDataMap.containsKey(rowIndex)){
- SheetRowData sheetRowData=rowIdexDataMap.get(rowIndex);
- Map<String, String> dataMap = new HashMap<>();
- Map<Integer, String> data = sheetRowData.getData();
- fieldIndexMap.forEach((integer, s) -> {
- String field = fieldIndexMap.get(integer);
- if (data.containsKey(integer)) {
- String vlues = data.get(integer);
- dataMap.put(field, vlues);
- }
- });
- dataMap.put("oid",cbo.getOid());
- dataList.add(dataMap);
- }
- if(clsfDataMap.containsKey(templateVO.getOid())){
- codeImprotDataVO=clsfDataMap.get(templateVO.getOid());
- dataList.addAll(codeImprotDataVO.getDatas());
- }
- codeImprotDataVO.setColNames(dataSet.getColName());
- codeImprotDataVO.setDatas(dataList);
- clsfDataMap.put(templateVO.getOid(),codeImprotDataVO);
- });
- if(!CollectionUtils.isEmpty(clsfDataMap)) {
- Collection codeImprotDataVOS=clsfDataMap.values();
- List<CodeImprotDataVO> codeImprotDataVOList=new ArrayList<>();
- codeImprotDataVOList.addAll(codeImprotDataVOS);
- redisService.setCacheList(uuid+"-"+templateVO.getOid(), codeImprotDataVOList);
- redisService.expire(uuid+"-"+templateVO.getOid(),6000000);//redis杩囨湡鏃堕棿
- }
- }
- /***
- * 鎵归噺澶勭悊鐢宠鏁版嵁
- * @param orderDTO
- * @param templateVO
- * @param dataSet
- * @return
- */
- @Override
- public List<String> batchImportCode(CodeOrderDTO orderDTO,CodeClassifyTemplateVO templateVO,SheetDataSet dataSet,Map<String,String> errorMap,boolean isEnumType){
- List<String> codeList=new ArrayList<>();
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
- //瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
- CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
- //1.鍒ゆ柇瑙勫垯涓櫎浜嗘祦姘寸爜娈碉紝鏄惁鏈夊叾浠栫爜娈�
- engineService.checkSecValueOnOrder(ruleVO,orderDTO);
- List<SheetRowData> rowDataList = dataSet.getRowData();
+ 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);//寰�鐗╁搧瀵硅薄閲屾坊鍔�
- //闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
- List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
- !MdmEngineConstant.DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormdisplayflag())
- ).collect(Collectors.toList());
- Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
- List<String> titleRowData = dataSet.getColName();
- Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT),(o1, o2)->o2));
- getFieldIndexMap(titleRowData,attrNameIdMap,fieldIndexMap);
+ });
- //闇�瑕佸垽鏂槸鍚︽墍鏈夌殑灞炴�ч兘鍦ㄦā鏉夸笂浜�
- List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
- && StringUtils.isBlank(s.getComponentrule()) && StringUtils.isBlank(s.getClassifyinvokeattr())//缁勫悎瑙勫垯鍜屽垎绫绘敞鍏ョ‘瀹炴病缁欑敤鎴峰鍑哄幓
- ).collect(Collectors.toList());
- if(!CollectionUtils.isEmpty(unExistAttrVOs)){
- throw new VciBaseException("銆�" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "銆戣繖浜涘睘鎬у湪鍒楄〃涓病鏈夋壘鍒�");
- }
- List<ClientBusinessObject> cboList = new ArrayList<>();
- String fullPath = getFullPath(classifyFullInfo);
- excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,true);
- //閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
- //濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌excel涓�
- //2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
- batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);
- //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,"") + ";鍦ㄥ綋鍓嶅鐞嗙殑鏁版嵁鏂囦欢涓叧閿睘鎬ч噸澶�" );
- });
- }
- if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
- keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
- errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
- });
- }
- //鍒嗙被娉ㄥ叆
- batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
- //boolean
- reSwitchBooleanAttrOnOrder(attrVOS,cboList);
- //4.鏍￠獙瑙勫垯
- batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
- if(isEnumType) {//鏄惁闇�瑕佹牎楠屾灇涓�/鍙傜収
- //5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
- batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
- //7.澶勭悊鍙傜収鐨勬儏鍐�
- batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
- }
- //6.鏃堕棿鏍煎紡鐨勯獙璇�
- //6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
- batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
- //鏈�鍚庡紕缁勫悎瑙勫垯
- batchSwitchComponentAttrOnOrder(attrVOS,cboList);
- //瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
- List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
- String rowIndex =cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- return !errorMap.containsKey(rowIndex);
- }).collect(Collectors.toList());
+ //閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+ //濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌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);
- if(!CollectionUtils.isEmpty(needSaveCboList)) {
- //9.鎴戜滑澶勭悊涓氬姟鏁版嵁
- //鐢熸垚缂栫爜鐨勫唴瀹�
- codeList= productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(), needSaveCboList);
- //濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
- engineService.batchSaveSelectChar(templateVO,needSaveCboList);
- }
- return codeList;
- }
- 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();
- 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)){
- throw new Throwable(sb.toString());
- }
- if(codeClassifyTemplateVOList.size()>1){
- String message="妯℃澘銆�"+dataSet.getSheetName()+"銆戞牴鎹垎绫昏矾寰勫垽鏂紝鍒嗙被瀛樺湪澶氫釜妯℃澘";
+ //6.鏃堕棿鏍煎紡鐨勯獙璇�
+ //6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+ batchSwitchDateAttrOnOrder(attrVOS,allCboList,errorMap);
+ //璁剧疆榛樿鍊�
+ batchSwitchAttrDefault(attrVOS, allCboList);
+ //鏈�鍚庡紕缁勫悎瑙勫垯
+ batchSwitchComponentAttrOnOrder(attrVOS,allCboList);
- throw new Throwable(message);
- }
- if(codeClassifyTemplateVOList.size()==0){
- String message="妯℃澘銆�"+dataSet.getSheetName()+"銆戞牴鎹暟鎹垎绫昏矾寰勫垽鏂紝鏈尮閰嶅埌瀵瑰簲妯℃澘";
- throw new Throwable(message);
- }
- return codeClassifyTemplateVOList ;
- }
- /**
- * 鏍￠獙妯℃澘鏄惁涓哄悓姝ョ殑
- * @param sheetDataSetList excel閲岀殑鍐呭
- * @param templateVO 妯℃澘鐨勪俊鎭�
- */
- private void checkTemplateSync(List<SheetDataSet> sheetDataSetList,CodeClassifyTemplateVO templateVO,int i){
- String templateOidInExcel = "";
- String templateName="";
- if(!CollectionUtils.isEmpty(sheetDataSetList)
- && sheetDataSetList.size()>1 && !CollectionUtils.isEmpty(sheetDataSetList.get(sheetDataSetList.size()-1).getColName())){
- List<SheetRowData> rowData= sheetDataSetList.get(sheetDataSetList.size()-1).getRowData();
- templateName=rowData.get(i).getData().get(2);
- templateOidInExcel=rowData.get(i).getData().get(0);
- //templateOidInExcel = sheetDataSetList.get(sheetDataSetList.size()-1).getColName().get(sheetDataSetList.size()-i);
- }
+
+ 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) throws Throwable{
+ 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<BaseModel> 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);
+ });
+
+ 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, "") + ";绯荤粺閿欒锛屽瓨鍌ㄦ暟鎹殑鏃跺�欏嚭閿欎簡");
+ });
+
+ }
+ }
+ });
+ if (errorMap.size() > 0) {
+ isExport = true;
+ }
+ createWriteExcelData(rowDataList, errorMap, new ArrayList<>(), titleRowData, shetNameMap, finalTemplateVO);
+ 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;
+ }
+ /*private void converBaseModels(List<ClientBusinessObject> clientBusinessObjects,List<BaseModel>dataCBOList){
+ clientBusinessObjects.stream().forEach(clientBusinessObject -> {
+ BaseModel baseModel=new BaseModel();
+ BeanUtil.convert(clientBusinessObject,baseModel);
+ Map<String,String> dataMap=new HashMap<>();
+ clientBusinessObject.getHisAttrValList()
+ baseModel.setData(VciBaseUtil.objectToMapString(baseModel));
+
+ AttributeValue[] newAttributeValue= clientBusinessObject.getNewAttrValList();
+ dataCBOList.add(baseModel);
+ });
+
+ }*/
+ /***
+ * 浠巈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 鎵�鏈夌殑瀵煎叆鏁版嵁
+ * @param errorMap 閿欒鐨勪俊鎭�
+ * @param needRowIndexList 闇�瑕佸啓鍏ョ殑鏁版嵁鐨勮鍙�
+ * @param titleRowData 鏍囬琛�
+ *
+ * @return 閿欒鐨別xcel鏂囦欢锛屾病鏈夐敊璇細杩斿洖绌�
+ */
+ private String returnErrorToExcel(Collection<SheetRowData> rowDataList,
+ Map<String,String> errorMap,
+ List<String> needRowIndexList,List<String> titleRowData){
+ if(CollectionUtils.isEmpty(errorMap)){
+ return "";
+ }
+ Map<String, SheetRowData> rowIndexDataMap = rowDataList.stream().filter(s -> !needRowIndexList.contains(s.getRowIndex())).collect(Collectors.toMap(s -> s.getRowIndex(), t -> t));
+ List<WriteExcelData> errorDataList = new ArrayList<>();
+ 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]++;
+ }
+ });
+ String excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + "閿欒淇℃伅.xls";
+ WriteExcelOption eo = new WriteExcelOption(errorDataList);
+ try {
+ new File(excelFileName).createNewFile();
+ } catch (IOException e) {
+ throw new VciBaseException(LangBaseUtil.getErrorMsg(e));
+ }
+ ExcelUtil.writeDataToFile(excelFileName,eo);
+ return excelFileName;
+ }
+
+ /**
+ * 鏍￠獙妯℃澘鏄惁涓哄悓姝ョ殑
+ * @param sheetDataSetList excel閲岀殑鍐呭
+ * @param templateVO 妯℃澘鐨勪俊鎭�
+ */
+ private void checkTemplateSync(List<SheetDataSet> sheetDataSetList,CodeClassifyTemplateVO templateVO,int i){
+ String templateOidInExcel = "";
+ String templateName="";
+ if(!CollectionUtils.isEmpty(sheetDataSetList)
+ && sheetDataSetList.size()>1 && !CollectionUtils.isEmpty(sheetDataSetList.get(sheetDataSetList.size()-1).getColName())){
+ List<SheetRowData> rowData= sheetDataSetList.get(sheetDataSetList.size()-1).getRowData();
+ templateName=rowData.get(i).getData().get(2);
+ templateOidInExcel=rowData.get(i).getData().get(0);
+ //templateOidInExcel = sheetDataSetList.get(sheetDataSetList.size()-1).getColName().get(sheetDataSetList.size()-i);
+ }
/* 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(i).getData().get(0);
//templateOidInExcel = sheetDataSetList.get(sheetDataSetList.size()-1).getColName().get(sheetDataSetList.size()-i);
}*/
- if(StringUtils.isBlank(templateOidInExcel) || !templateOidInExcel.equalsIgnoreCase(templateVO.getOid())){
- throw new VciBaseException("妯℃澘銆�"+templateName+"銆戜腑鐨勬暟鎹幏鍙栫殑妯＄増淇℃伅涓庡綋鍓嶆ā鏉夸笉鍖归厤锛岃纭繚excel鏂囦欢閲屾湁銆愭ā鏉夸俊鎭�-璇峰嬁绉诲姩鎴栧垹闄ゃ�戠殑宸ヤ綔琛紝涓旂‘淇濇瘡娆″鍏ラ兘鏄厛涓嬭浇鐨勫鍏ユā鏉垮悗娣诲姞鐨勬暟鎹�");
- }
+ if(StringUtils.isBlank(templateOidInExcel) || !templateOidInExcel.equalsIgnoreCase(templateVO.getOid())){
+ throw new VciBaseException("妯℃澘銆�"+templateName+"銆戜腑鐨勬暟鎹幏鍙栫殑妯＄増淇℃伅涓庡綋鍓嶆ā鏉夸笉鍖归厤锛岃纭繚excel鏂囦欢閲屾湁銆愭ā鏉夸俊鎭�-璇峰嬁绉诲姩鎴栧垹闄ゃ�戠殑宸ヤ綔琛紝涓旂‘淇濇瘡娆″鍏ラ兘鏄厛涓嬭浇鐨勫鍏ユā鏉垮悗娣诲姞鐨勬暟鎹�");
+ }
- }
+ }
- /***
- * 浠庨《灞傛壒閲忕敵璇峰鍏ユ柟娉�
- * @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);
- 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=redisService.getUUIDEveryDay();
- List<CodeImportTemplateVO> codeImportTemplateVOS=new ArrayList<>();
- //鎸夌収妯℃澘鍘绘暣鐞嗘暟鎹�
- templateDatasMap.keySet().stream().forEach(templateVOOid->{
- List<CodeImprotDataVO> codeImprotDataVOS= templateDatasMap.get(templateVOOid);
- CodeClassifyTemplateVO templateVO= templateServiceI.getObjectHasAttrByOid(templateVOOid);
+ /***
+ * 鎵归噺澶勭悊鐢宠鏁版嵁
+ * @param orderDTO
+ * @param templateVO
+ * @param dataSet
+ * @return
+ */
+ private String batchImportCodes(CodeOrderDTO orderDTO,CodeClassifyTemplateVO templateVO,SheetDataSet dataSet,Map<String,String> errorMap,boolean isEnumType){
+ List<String> codeList=new ArrayList<>();
+ CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
+ //瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
+ CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
+ //1.鍒ゆ柇瑙勫垯涓櫎浜嗘祦姘寸爜娈碉紝鏄惁鏈夊叾浠栫爜娈�
+ engineService.checkSecValueOnOrder(ruleVO,orderDTO);
+ List<SheetRowData> rowDataList = dataSet.getRowData();
- //闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
- List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
- !MdmEngineConstant.DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormdisplayflag())
- ).collect(Collectors.toList());
+ //闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+ List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
+ !DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+ ).collect(Collectors.toList());
+ Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
+ List<String> titleRowData = dataSet.getColName();
+ Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT),(o1, o2)->o2));
+ getFieldIndexMap(titleRowData,attrNameIdMap,fieldIndexMap);
- Map<String/**妯℃澘灞炴�у瓧娈祇id**/, String /**妯℃澘灞炴�у閮ㄥ悕绉�**/> fieldNameMap =attrVOS.stream().collect(Collectors.toMap(CodeClassifyTemplateAttrVO::getId,s->s.getName()));
+ //闇�瑕佸垽鏂槸鍚︽墍鏈夌殑灞炴�ч兘鍦ㄦā鏉夸笂浜�
+ List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
+ && StringUtils.isBlank(s.getComponentRule()) && StringUtils.isBlank(s.getClassifyInvokeAttr())//缁勫悎瑙勫垯鍜屽垎绫绘敞鍏ョ‘瀹炴病缁欑敤鎴峰鍑哄幓
+ ).collect(Collectors.toList());
+ if(!CollectionUtils.isEmpty(unExistAttrVOs)){
+ throw new VciBaseException("銆�" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "銆戣繖浜涘睘鎬у湪鍒楄〃涓病鏈夋壘鍒�");
+ }
+ List<ClientBusinessObject> cboList = new ArrayList<>();
+ String fullPath = getFullPath(classifyFullInfo);
+ excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,true);
- List<ClientBusinessObject> allCboList=new ArrayList<>();
- List<ColumnVO>columnVOList =new ArrayList();
- codeImprotDataVOS.stream().forEach(codeImprotDataVO -> {
- CodeImportTemplateVO codeImportTemplateVO=new CodeImportTemplateVO();
- codeImprotDataVO.getFields().stream().forEach(field->{
- ColumnVO columnVOS = new ColumnVO();
- String outName=fieldNameMap.get(field);
- columnVOS.setField(field);
- columnVOS.setTitle(outName);
- columnVOList.add(columnVOS);
+ //閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+ //濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌excel涓�
+ //2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
+ batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);
+ //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,"") + ";鍦ㄥ綋鍓嶅鐞嗙殑鏁版嵁鏂囦欢涓叧閿睘鎬ч噸澶�" );
+ });
+ }
+ if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
+ keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
+ });
+ }
+ //鍒嗙被娉ㄥ叆
+ batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
+ //boolean
+ reSwitchBooleanAttrOnOrder(attrVOS,cboList);
+ //4.鏍￠獙瑙勫垯
+ batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
+ if(isEnumType) {//鏄惁闇�瑕佹牎楠屾灇涓�/鍙傜収
+ //5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
+ batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
+ //7.澶勭悊鍙傜収鐨勬儏鍐�
+ batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
+ }
+ //6.鏃堕棿鏍煎紡鐨勯獙璇�
+ //6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+ batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
+ //鏈�鍚庡紕缁勫悎瑙勫垯
+ batchSwitchComponentAttrOnOrder(attrVOS,cboList);
+ String uuid=VciBaseUtil.getPk();
+ 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));
- });
- codeImportTemplateVO.setCodeClassifyVO( codeImprotDataVO.getCodeClassifyVO());
- codeImportTemplateVO.setCodeClassifyTemplateVO( codeImprotDataVO.getCodeClassifyTemplateVO());
- List<String> colNames=codeImprotDataVO.getColNames();
- codeImportTemplateVO.setCloNamesList(columnVOList);
- codeImportTemplateVOS.add(codeImportTemplateVO);
- List<ClientBusinessObject> cboList=new ArrayList<>();
- excelToCbo(classifyFullInfo,codeImprotDataVO,cboList,true);
- allCboList.addAll(cboList);
+ if(errorMap.size()>0) {
+ createRedisDatas(uuid + "-error",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, errorMap,false);
+ }
+ boolean isCreateUUid=false;
+ 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(orderDTO.getCodeClassifyOid(),templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
+ if(resembleMap.size()>0) {
+ isCreateUUid=true;
+ if(!CollectionUtils.isEmpty(dataResembleVOS)) {
+ bladeRedis.set(uuid + "-resemble-data", dataResembleVOS);
+ createRedisDatas(uuid + "-resemble",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, resembleMap, false);
+ }
+ }
+ //鎺掗櫎閿欒鐨勶紝鍓╀笅姝ｇ‘鐨�
+ 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;
+ }
+ createRedisByCodeClassify(uuid + "-class",templateVO,dataSet,fieldIndexMap,false);
+ if(newErrorMap.size()>0) {
+ createRedisDatas(uuid + "-ok",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap,true);
+ }else {
+ uuid="";
- });
+ //瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
+ needSaveCboList = cboList.stream().filter(cbo -> {
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ return !newErrorMap.containsKey(rowIndex);
+ }).collect(Collectors.toList());
+ 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閲岄潰
+ engineService.batchSaveSelectChar(templateVO, dataCBOList);
+ } catch (Exception e) {
+ e.printStackTrace();
+ log.error("鎵逛簡鐢宠鏃跺け璐�");
+ }
+ }
+ }
+ if(!isCreateUUid){
+ return uuid="";
+ }
+ return uuid;
+ }
- //閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
- //濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌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);
+ @Override
+ public List<CodeImportTemplateVO> gridclassifys(String redisOid) {
+ List<CodeImportTemplateVO> codeImportTemplateVOs=new ArrayList<>();
+ VciBaseUtil.alertNotNull(redisOid,"鍒嗙被",redisOid,"鍒嗙被缂撳瓨涓婚敭");
+ List<CodeImportTemplateVO> redisServiceCacheObjects=bladeRedis.get(redisOid);
+ if(redisServiceCacheObjects!=null){
+ codeImportTemplateVOs= redisServiceCacheObjects;
+ }
+ return codeImportTemplateVOs;
+ }
- //6.鏃堕棿鏍煎紡鐨勯獙璇�
- //6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
- batchSwitchDateAttrOnOrder(attrVOS,allCboList,errorMap);
- //鏈�鍚庡紕缁勫悎瑙勫垯
- batchSwitchComponentAttrOnOrder(attrVOS,allCboList);
+ /***
+ * 浠庣紦瀛橀噷鑾峰彇鍒伴渶瑕佸鍏ョ殑鐩稿叧鏁版嵁
+ * @param codeClssifyOid
+ * @param redisOid
+ * @return
+ */
+ @Override
+ public DataGrid<Map<String, String>> gridDatas(String codeClssifyOid, String redisOid) {
+ VciBaseUtil.alertNotNull(redisOid,"瀵煎叆鐩镐技鏁版嵁",redisOid,"鏁版嵁缂撳瓨涓婚敭");
+ List<CodeImprotDataVO> codeImprotDataVOs = bladeRedis.get(redisOid+"-"+codeClssifyOid);
+// redisService.getCacheList(redisOid+"-"+codeClssifyOid);
+ CodeImprotDataVO codeImprotDataVO=new CodeImprotDataVO();
+ if(!CollectionUtils.isEmpty(codeImprotDataVOs)){
+ if(StringUtils.isNotBlank(codeClssifyOid)){
+ Map<String/**鍒嗙被鍚嶇О**/, CodeImprotDataVO/**鑻辨枃鍚嶇О**/> codeClassifyDatasMap = codeImprotDataVOs.stream().collect(Collectors.toMap(s -> s.getCodeClassifyOid(), t -> t,(o1, o2)->o2));
+ if(codeClassifyDatasMap.containsKey(codeClssifyOid)){
+ codeImprotDataVO= codeClassifyDatasMap.get(codeClssifyOid);
+ }else{
+ codeImprotDataVO= codeImprotDataVOs.get(0);
+ }
+ }
+ }
+ DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
+ List<Map<String, String>> dataList = new ArrayList<>();
+ if(codeImprotDataVO!=null){
+ dataList= codeImprotDataVO.getDatas();
+ }
+ dataGrid.setData(dataList);
+ if (!CollectionUtils.isEmpty(dataList)) {
+ dataGrid.setTotal(dataList.size());
+ }
+ return dataGrid;
+ }
+ /**
+ *
+ * @param oid
+ * @param redisOid
+ * @return
+ */
+ @Override
+ public DataGrid<Map<String,String>> gridRowResemble(String oid,String redisOid){
+ VciBaseUtil.alertNotNull(redisOid,"瀵煎叆鐩镐技鏁版嵁",redisOid,"鏁版嵁缂撳瓨涓婚敭");
+ List<DataResembleVO> codeImprotDataVOs = bladeRedis.get(redisOid);;
+ DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
+ List<Map<String, String>> dataList = new ArrayList<>();
- Map<String, ClientBusinessObject> rowIndexCboMap = allCboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((MdmEngineConstant.IMPORT_ROW_INDEX)), t -> t));
+ if(!CollectionUtils.isEmpty(codeImprotDataVOs)){
+ Map<String/**鍒嗙被鍚嶇О**/, DataResembleVO/**鏁版嵁瀵硅薄**/> rowResembleDataMap = codeImprotDataVOs.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t,(o1, o2)->o2));
+ if(rowResembleDataMap.containsKey(oid)){
+ DataResembleVO dataResembleVO= rowResembleDataMap.get(oid);
+ dataList= dataResembleVO.getDataList();
+ }
+ }
- if(errorMap.size()>0) {
- createRedisDatas(uuid + "-error",templateVO,codeImprotDataVOS, errorMap,false);
- }
- List<ClientBusinessObject> needSaveCboList = allCboList.stream().filter(cbo -> {
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.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)) {
- redisService.setCacheList(uuid + "-resemble-data", dataResembleVOS);
- createRedisDatas(uuid + "-resemble",templateVO, codeImprotDataVOS, resembleMap, false);
- }
- }
- //鎺掗櫎閿欒鐨勶紝鍓╀笅姝ｇ‘鐨�
- Map<String,String> newErrorMap=new HashMap<>();
- newErrorMap.putAll(resembleMap);
- newErrorMap.putAll(errorMap);
- needSaveCboList = allCboList.stream().filter(cbo -> {
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- return !newErrorMap.containsKey(rowIndex);
- }).collect(Collectors.toList());
- createRedisDatas(uuid + "-ok",templateVO,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);
- redisService.setCacheList(uuid + "-class",codeImportTemplateVOS);
- // redisService.expire(uuid + "-class",6000000);
- }
- return codeImProtRusultVO;
- }
+ dataGrid.setData(dataList);
+ if (!CollectionUtils.isEmpty(dataList)) {
+ dataGrid.setTotal(dataList.size());
+ }
+ return dataGrid;
+ }
- /***
- * 鏍规嵁涓嶅悓妯℃澘缁勭粐execl鏁版嵁
- * @param dataSet
- * @param pathMap
- * @param errorMap
- */
- private void createExeclClassData(SheetDataSet dataSet,Map<String/**璺緞**/, CodeClassifyVO> pathMap,Map<String,String>errorMap,List<CodeImprotDataVO> codeClassifyDatas){
+ @Override
+ public R batchImportData(List<CodeImprotSaveDatVO> codeImprotSaveDatVOList, String classifyAttr, boolean isImprot) {
- Map<String,CodeImprotDataVO> pathDatas=new HashMap<>();
- List<String> titleRowData= dataSet.getColName();
- List<SheetRowData> rowDataList= dataSet.getRowData();
- 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;
- 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();
+ boolean success=true;
+ 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());
- if(StringUtils.isEmpty(Path)){
- Path="#current#";
- }
+ // 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<>();
+ Map<String/**璺緞**/, CodeClassifyVO> pathMap=new HashMap<>() ;
+ //鏍￠獙缂栫爜瑙勫垯鍜岀爜娈垫槸鍚︽纭�
+ Map<String, List<String>> ruleRowIndexMap = new ConcurrentHashMap<>();
+ Map<String, CodeRuleVO> ruleVOMap =new ConcurrentHashMap<>();
+ if(isImprot) {
+ Map<String/**涓婚敭**/, String/**璺緞**/> childOidPathMap = getChildClassifyPathMap(classifyFullInfo, fullPath);
+ //閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+ //鎵炬墍鏈夌殑鍒嗙被璺緞,闇�瑕佹牎楠岃矾寰勬槸鍚︽纭紝鏄惁閮藉湪褰撳墠鐨勫垎绫荤殑涓嬬骇
+ List<CodeClassifyVO> childClassifyVOs = classifyService.listChildrenClassify(orderDTO.getCodeClassifyOid(), true, classifyAttr, true);
+ 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);
+ //妫�鏌ヨ鍒�
+ Map<String/**鍒嗙被涓婚敭**/, String/**瑙勫垯涓婚敭**/> ruleOidMap = new ConcurrentHashMap<String, String>();
+ List<String> unExistRuleClassifyOidList = new CopyOnWriteArrayList<>();
+ checkRuleOidInHistory(classifyVOMap, ruleOidMap, unExistRuleClassifyOidList);
+ ruleVOMap = ruleService.listCodeRuleByIds(ruleOidMap.values(), true).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
- if(pathMap.containsKey(Path)){
- CodeClassifyVO codeClassifyVO=pathMap.get(Path);
- if(codeClassifyTemplateVOMap.containsKey(Path)){
- newTemplateVO= codeClassifyTemplateVOMap.get(Path);
- }else{
- newTemplateVO =engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
- if(newTemplateVO==null){
- errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫绘ā鏉�");
- }
- }
- if(pathMap.containsKey(Path)){
- dataVO=pathDatas.getOrDefault(Path,dataVO);
- }
- dataVO.setTemplateOid(newTemplateVO.getOid());
- dataVO.setCodeClassifyTemplateVO(newTemplateVO);
- dataVO.setCodeClassifyVO(codeClassifyVO);
- dataVO.setRowIndex(rowIndex);
- dataVO.setCodeClassifyOid(codeClassifyVO.getOid());//璁剧疆鍒嗙被oid
- dataVO.setCodeRuleOid(codeClassifyVO.getCoderuleoid());
- createExeclClassData(titleRowData,newTemplateVO,execlData,dataVO);
+ checkSecLengthInHistory(cboList, classifyVOMap, ruleVOMap, ruleOidMap, errorMap, ruleRowIndexMap);
+ }
- pathDatas.put(Path,dataVO);
- codeClassifyTemplateVOMap.put(Path, newTemplateVO);
- }else{
- errorMap.put(rowIndex,"绗�"+rowIndex+"琛岋紝鍒嗙被璺緞鏈煡璇㈠埌鐩稿簲鐨勫垎绫�");
- }
- });
- break;
- }
- }
- List <CodeImprotDataVO> newCodeImprotDataVO= pathDatas.values().stream().collect(Collectors.toList());
- codeClassifyDatas.addAll(newCodeImprotDataVO);
- logger.info("222");
- }
+ //鍒嗙被娉ㄥ叆
+ 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);
- /**
- * 瀵煎叆鍘嗗彶鏁版嵁
- *
- * @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 = redisService.getUUIDEveryDay();
- 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涓�
+ if(isImprot){
+ List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ return !errorMap.containsKey(rowIndex);
+ }).collect(Collectors.toList());
+ List<ClientBusinessObject> finalNeedSaveCboList = needSaveCboList;
+ Map<String, CodeRuleVO> finalRuleVOMap = ruleVOMap;
+ ruleRowIndexMap.keySet().parallelStream().forEach(ruleOid -> {
+ List <BaseModel>dataCBOList=new CopyOnWriteArrayList<>();
+ List<String> rowIndexList = ruleRowIndexMap.get(ruleOid);
+ List<ClientBusinessObject> thisCbos = needSaveCboList.stream().filter(cbo -> rowIndexList.contains(cbo.getAttributeValue(IMPORT_ROW_INDEX)) && !errorMap.containsKey(cbo.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
+ if (!CollectionUtils.isEmpty(thisCbos)) {
+ thisCbos.stream().forEach(clientBusinessObject -> {
+ BaseModel baseModel = new BaseModel();
+ BeanUtil.convert(clientBusinessObject, baseModel);
+ dataCBOList.add(baseModel);
+ });
+ try {
+ productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, finalRuleVOMap.get(ruleOid), null, dataCBOList);
+ } catch (Throwable e) {
+ //success=false;
+ log.error("鎵归噺浜х敓缂栫爜鐨勬椂鍊欏嚭閿欎簡", e);
+ thisCbos.stream().forEach(cbo -> {
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";绯荤粺閿欒锛屽瓨鍌ㄦ暟鎹殑鏃跺�欏嚭閿欎簡");
+ });
+ }
+ }
+ engineService.batchSaveSelectChar(codeClassifyTemplateVO, dataCBOList);
+ });
+ }else {
+ List<BaseModel> dataCBOList=new ArrayList<>();
+ 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)) {
+ needSaveCboList.stream().forEach(clientBusinessObject -> {
+ BaseModel baseModel = new BaseModel();
+ BeanUtil.convert(clientBusinessObject, baseModel);
+ dataCBOList.add(baseModel);
+ });
+ try {
+ productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ //濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
+ engineService.batchSaveSelectChar(codeClassifyTemplateVO, dataCBOList);
+ }
+ }
+ });
+ return R.success(isImprot?"鎵归噺鍘嗗彶瀵煎叆鎴愬姛":"鎵归噺鐢宠鎴愬姛");
+ }
- //鏌ヨ鍒嗙被鍜屾ā鏉�
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
+ /***
+ *鏍规嵁鏁版嵁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);
+ }
- //鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
- SheetDataSet dataSet = sheetDataSetList.get(i);
- List<SheetRowData> rowDataList = dataSet.getRowData();
+ });
+ codeImprotDataVO.setDatas(newDataList);
- //鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
- 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<>();
- try {
- List<CodeClassifyTemplateVO> templateVOList= checkSamesTemplate(titleRowData,sheetDataSetList,i,pathMap,errorMap);
- templateVO= templateVOList.get(0);
- }catch (Throwable e){
- throw new VciBaseException(e.getMessage());
- }
+ });
+ //閲嶆柊缂撳瓨
+ 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("鍒犻櫎缂撳瓨鏁版嵁澶辫触!");
+ }
+ }
- List<SheetRowData> needowDataList = rowDataList.stream().filter(cbo -> {
- String rowIndex = cbo.getRowIndex();
- return !errorMap.containsKey(rowIndex);
- }).collect(Collectors.toList());
+ /**
+ * 闆嗘垚鎵归噺鐢宠鏁版嵁
+ * @param orderDTO 鍒嗙被鐨勪富閿�
+ * @param dataObjectVO 鏁版嵁淇℃伅
+ * @param resultDataObjectDetailDOs 閿欒淇℃伅
+ * @return 鏈夐敊璇俊鎭殑excel
+ */
+ @Override
+ public void batchSyncApplyCode(CodeOrderDTO orderDTO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs) {
+ Map<String,String> errorMap=new HashMap<>();
+ VciBaseUtil.alertNotNull(orderDTO,"缂栫爜鐢宠鐩稿叧鐨勬暟鎹�",orderDTO.getCodeClassifyOid(),"涓婚搴撳垎绫讳富閿�");
+ CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
+ //瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
+ CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
+ //1.鍒ゆ柇瑙勫垯涓櫎浜嗘祦姘寸爜娈碉紝鏄惁鏈夊叾浠栫爜娈�
+ //engineService.checkSecValueOnOrder(ruleVO,orderDTO);
+ //鏌ヨ鍒嗙被鍜屾ā鏉�
+ //鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
+ List<RowDatas> rowDataList = dataObjectVO.getRowData();
+ Map<String , RowDatas>rowDataMap=new LinkedHashMap<>();
+ rowDataList.stream().forEach(rowData->{
+ rowDataMap.put(rowData.getRowIndex(),rowData);
+ });
+ //鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
+ CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());
- //checkTemplateSync(sheetDataSetList, templateVO,i);
- //杩欓噷涓嶉櫎鍘婚粯璁ょ殑灞炴��
- List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes();
- Map<Integer/**鍒楀彿**/, String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
+ //鏍￠獙妯℃澘鏄笉鏄渶鏂扮殑
+ //checkTemplateSync(sheetDataSetList,templateVO);
+ //闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+ List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->!DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+ ).collect(Collectors.toList());
+ Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
+ List<String> titleRowData = dataObjectVO.getColName();
+ Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT),(o1, o2)->o2));
+ getFieldIndexMap(titleRowData,attrNameIdMap,fieldIndexMap);
- 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);
+ //闇�瑕佸垽鏂槸鍚︽墍鏈夌殑灞炴�ч兘鍦ㄦā鏉夸笂浜�
+ List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
+ && com.alibaba.cloud.commons.lang.StringUtils.isBlank(s.getComponentRule()) && com.alibaba.cloud.commons.lang.StringUtils.isBlank(s.getClassifyInvokeAttr())//缁勫悎瑙勫垯鍜屽垎绫绘敞鍏ョ‘瀹炴病缁欑敤鎴峰鍑哄幓
+ ).collect(Collectors.toList());
+ if(!CollectionUtils.isEmpty(unExistAttrVOs)){
+ throw new VciBaseException("銆�" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "銆戣繖浜涘睘鎬у湪excel涓病鏈夋壘鍒�");
+ }
+ List<ClientBusinessObject> cboList = new ArrayList<>();
+ String fullPath = getFullPath(classifyFullInfo);
+ // List<CodeClassifyProcessTempVO> codeClassifyProcessTempVOS=codeClassifyProcessTempService.listProcessTemplate(templateVO.getOid(),"code_cls_flow_use_order");
+ boolean isProcess=false;
+ //娉ㄩ噴鎺夋澶勪笅闈㈡墍鏈夐兘鎸夌収涓嶅垽鏂祦绋嬪瓨鍌ㄧ姸鎬佷簡
+ /** if(!CollectionUtils.isEmpty(codeClassifyProcessTempVOS)){
+ isProcess=true;
+ }***/
+ Map<String,String> codeOidToSystemOidMap=new HashMap<>();//瀛樺偍缂栫爜鏁版嵁鍜岄泦鎴愮郴缁熸暟鎹畂id瀵圭収鏄犲皠
+ excelToCbo(classifyFullInfo,titleRowData,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,isProcess,"create",errorMap,codeOidToSystemOidMap);
- 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());
+ //閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
+ //濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌excel涓�
+ //2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
+ batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);
- //鍒ゆ柇缂栧彿鍦╡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(MdmEngineConstant.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涓�
+ /**
+ * 鍏抽敭鐔熸倝閿欒鎻愮ず
+ */
+ Map<String,String> errorKeyMap=new HashMap<>();
- //鎴戜滑鏍规嵁鍑洪敊鐨勫垎绫荤殑涓婚敭锛屽幓鎵捐鍙�
- if (!CollectionUtils.isEmpty(unExistRuleClassifyOidList)) {
- cboList.stream().forEach(cbo -> {
- if (unExistRuleClassifyOidList.contains(cbo.getAttributeValue(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD))) {
- String row_index = cbo.getAttributeValue(MdmEngineConstant.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);
- //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.listCodeRuleByOids(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(MdmEngineConstant.IMPORT_ROW_INDEX)) && !errorMap.containsKey(cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX))).collect(Collectors.toList());
-//鎴戜滑闇�瑕佸厛鏌ヨ涓�涓嬶紝鍐呭鏄惁宸茬粡瀛樺湪
- if(!CollectionUtils.isEmpty(thisCbos)){
- List<String> existIds = new ArrayList<>();
- VciBaseUtil.switchCollectionForOracleIn(thisCbos).stream().forEach(cbos -> {
- Map<String, String> conditionMap = new HashMap<>();
- conditionMap.put("coderuleoid", ruleOid);
- conditionMap.put("id", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(cbos.stream().map(s -> s.getId()).collect(Collectors.toSet()).toArray(new String[0])) + ")");
- conditionMap.put(VciQueryWrapperForDO.LC_STATUS_FIELD, QueryOptionConstant.NOTIN + "('" + CodeAllCodeLC.TASK_BACK.getValue() + "','" + CodeAllCodeLC.OBSOLETED.getValue() + "')");
- existIds.addAll(Optional.ofNullable(boService.queryCBO(MdmBtmTypeConstant.CODE_ALL_CODE, conditionMap, new PageHelper(-1), Arrays.stream(new String[]{"id"})
- .collect(Collectors.toList()))).orElseGet(() -> new ArrayList<>()).stream().map(s -> {
- String id = s.getId();
- if (StringUtils.isBlank(id)) {
- id = s.getAttributeValue("id");
- }
- 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(MdmEngineConstant.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((MdmEngineConstant.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(MdmEngineConstant.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)) {
- redisService.setCacheList(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((MdmEngineConstant.IMPORT_ROW_INDEX)), t -> t.getAttributeValue(MdmEngineConstant.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(MdmEngineConstant.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(MdmEngineConstant.IMPORT_ROW_INDEX))).map(s -> s.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX)).collect(Collectors.toList());
- if (isExport||newErrorMap.size() > 0) {
- createRedisDatas(uuid + "-ok", templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap, true);
- } else {
- 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(MdmEngineConstant.IMPORT_ROW_INDEX)) && !errorMap.containsKey(cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX))).collect(Collectors.toList());
- if (!CollectionUtils.isEmpty(thisCbos)) {
- try {
- productCodeService.productCodeAndSaveData(classifyFullInfo, finalTemplateVO, ruleVOMap.get(ruleOid), null, thisCbos);
- } catch (Throwable e) {
- logger.error("鎵归噺浜х敓缂栫爜鐨勬椂鍊欏嚭閿欎簡", e);
- thisCbos.stream().forEach(cbo -> {
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- errorMap.put(rowIndex, errorMap.getOrDefault(rowIndex, "") + ";绯荤粺閿欒锛屽瓨鍌ㄦ暟鎹殑鏃跺�欏嚭閿欎簡");
- });
- }
- }
- });
- engineService.batchSaveSelectChar(templateVO, cboList);
- }
- }
- 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;
- }
- 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 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(MdmEngineConstant.IMPORT_ROW_INDEX);
- String secLength = cbo.getAttributeValue(MdmEngineConstant.CODE_SEC_LENGTH_FIELD);
- //鎵惧垎绫�
- String classifyOid = cbo.getAttributeValue(MdmEngineConstant.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(MdmEngineConstant.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 fieldIndexMap 瀛楁鐨勪綅缃�
- * @param rowDataList excel閲岀殑琛屾暟鎹�
- * @param templateVO 妯℃澘鐨勬樉绀哄璞�
- * @param cboList 鏁版嵁鐨勫垪琛�
- * @param fullPath 鍏ㄨ矾寰�
- * @param newCode 鏄惁涓烘壒閲忕敵璇�
- */
- private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,Map<Integer,String> fieldIndexMap,List<SheetRowData> rowDataList,
- CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,
- String fullPath,boolean newCode){
- rowDataList.stream().forEach(rowData -> {
- ClientBusinessObject cbo = boService.createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid());
- rowData.getData().forEach((index,value)->{
- String field = fieldIndexMap.get(index);
- if(StringUtils.isBlank(field)){
- throw new VciBaseException("绗�" + (index + 1) + "鍒楃殑鏍囬鍦ㄧ郴缁熶腑涓嶅瓨鍦�");
- }
- try {
- cbo.setAttributeValueWithNoCheck(field,value);
- if(WebUtil.isDefaultField(field)){
- WebUtil.setValueToField(field, cbo, value);
- }
- } catch (VCIError e) {
- logger.error("璁剧疆灞炴�х殑鍊奸敊璇�",e);
- }
- });
- try {
- if(newCode){
- cbo.setAttributeValue(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
- cbo.setAttributeValue(MdmEngineConstant.CODE_FULL_PATH_FILED,fullPath);
- //cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
- int secret = VciBaseUtil.getInt(cbo.getAttributeValue(MdmEngineConstant.SECRET_FIELD));
- if(secret == 0 || !secretService.checkDataSecret(secret) ){
- Integer userSecret = VciBaseUtil.getCurrentUserSecret();
- cbo.setAttributeValue(MdmEngineConstant.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());
- }
- cbo.setAttributeValue(MdmEngineConstant.CODE_TEMPLATE_OID_FIELD,templateVO.getOid());
- cbo.setAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX,rowData.getRowIndex());
- }catch (Throwable e){
- logger.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�",e);
- }
- cboList.add(cbo);
- });
-
- }
-
- /**
- * excel杞崲涓篶bo鐨勫璞�
- * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
- * @param fieldIndexMap 瀛楁鐨勪綅缃�
- * @param rowDataList excel閲岀殑琛屾暟鎹�
- * @param templateVO 妯℃澘鐨勬樉绀哄璞�
- * @param cboList 鏁版嵁鐨勫垪琛�
- * @param fullPath 鍏ㄨ矾寰�
- * @param operation 鎿嶄綔绫诲瀷
- * @param errorMap 閿欒淇℃伅璁板綍
- */
- private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,List<String> titleRowData,Map<Integer,String> fieldIndexMap,List<RowDatas> rowDataList,
- CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,
- String fullPath,boolean isProcess,String operation,Map<String,String> errorMap,Map<String,String> codeOidToSystemOidMap){
- rowDataList.stream().forEach(rowData -> {
- String oid=rowData.getOid();
- String rowNumber=rowData.getRowIndex();
- ClientBusinessObject cbo = boService.createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid());
- rowData.getData().forEach((index,value)->{
- String field = fieldIndexMap.get(index);
- if(StringUtils.isBlank(field)){
- errorMap.put(rowNumber,"灞炴�э細銆�" +titleRowData.get(index)+ "銆戝湪绯荤粺涓笉瀛樺湪");
- }
- try {
- cbo.setAttributeValueWithNoCheck(field,value);
- if(WebUtil.isDefaultField(field)){
- WebUtil.setValueToField(field, cbo, value);
- }
- } catch (VCIError e) {
- logger.error("璁剧疆灞炴�х殑鍊奸敊璇�",e);
- errorMap.put(rowNumber,"灞炴�э細銆�" +titleRowData.get(index)+ "銆戝湪绯荤粺涓笉瀛樺湪");
- }
- });
- try {
- if(operation.equals("create")){
- logger.info("鍒嗙被瀵硅薄锛�"+classifyFullInfo.getCurrentClassifyVO());
- logger.info("codeClassoid:"+classifyFullInfo.getCurrentClassifyVO().getOid());
- cbo.setAttributeValue(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
- cbo.setAttributeValue(MdmEngineConstant.CODE_FULL_PATH_FILED,fullPath);
- int secret = VciBaseUtil.getInt(cbo.getAttributeValue(MdmEngineConstant.SECRET_FIELD));
- if(secret == 0 || !secretService.checkDataSecret(secret) ){
- Integer userSecret = VciBaseUtil.getCurrentUserSecret();
- cbo.setAttributeValue(MdmEngineConstant.SECRET_FIELD,String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret));
- }
- if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//鍋滅敤
- cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
- }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//缂栬緫
- cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
- }else if(rowData.getStatus().equals(CodeDefaultLC.AUDITING.getValue())) {//瀹℃壒涓�
- cbo.setLcStatus(CodeDefaultLC.AUDITING.getValue());
- }else if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//鍥炴敹
- cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
- }else{
- cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());//鍙戝竷
- }
- /** if(!isProcess){
- cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
- }else {
- if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//鍋滅敤
- cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
- }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//缂栬緫
- cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
- }else {//鍙戝竷
- cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
- }
- }***/
- cbo.setCreator(rowData.getCreator());
- cbo.setLastModifier(rowData.getEditor()==null?"":rowData.getEditor());
- }else if(operation.equals("update")){
- //姝ゆ椂杩樻病鏈夎浆鎹㈣矾寰�
- //cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
- if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//鍋滅敤
- cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
- }else if(rowData.getStatus().equals(CodeDefaultLC.RELEASED.getValue())){//鍙戝竷
- cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
- }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//缂栬緫
- cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
- }else if(rowData.getStatus().equals(CodeDefaultLC.AUDITING.getValue())) {//瀹℃壒涓�
- cbo.setLcStatus(CodeDefaultLC.AUDITING.getValue());
- }else if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//鍥炴敹
- cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
- }
- cbo.setLastModifier(rowData.getEditor() == null ? "" : rowData.getEditor());//淇敼鑰�
- }else if(operation.equals("delete")){
- if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//鍥炴敹
- cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
- }else{
- cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());//鍋滅敤
- }
- }
- cbo.setAttributeValue(MdmEngineConstant.CODE_TEMPLATE_OID_FIELD,templateVO.getOid());
- cbo.setAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX,rowData.getRowIndex());
- }catch (Throwable e){
- logger.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�",e);
- errorMap.put(rowNumber,"璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�"+e.getMessage());
- }finally {
- codeOidToSystemOidMap.put(cbo.getOid(),oid);
- }
- cboList.add(cbo);
- });
-
- }
-
- /**
- * 妫�鏌ュ垎绫荤殑璺緞鏄惁瀛樺湪
- * @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(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD);
- //濡傛灉path涓虹┖锛屽垯琛ㄧず鏄鍏ュ綋鍓嶅垎绫�
- if(StringUtils.isBlank(classifyPath)){
- classifyPath = "#current#";
- }
- if ( !pathMap.containsKey(classifyPath)) {
- String row_index = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- errorMap.put(row_index,errorMap.getOrDefault(row_index,"") + ";鍒嗙被璺緞涓嶅瓨鍦�");
- } else {
- //杞竴涓嬪垎绫荤殑涓婚敭
- try {
- String classifyOid = pathMap.get(classifyPath).getOid();
- cbo.setAttributeValueWithNoCheck(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD, classifyOid);
- cbo.setAttributeValue(MdmEngineConstant.CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(classifyOid,classifyPath));
- } catch (VCIError e) {
- logger.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());
- }
- }
- });
- }
- logger.info(";;;;");
- }
- /**
- * 鑾峰彇瀛愬垎绫荤殑璺緞
- * @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 classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
- * @return 鍏ㄨ矾寰�
- */
- private String getFullPath(CodeClassifyFullInfoBO classifyFullInfo){
- String fullPath = "";
- if(!CollectionUtils.isEmpty(classifyFullInfo.getParentClassifyVOs())){
- fullPath = classifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel())))
- .map(CodeClassifyVO::getOid).collect(Collectors.joining("##"));
- }else{
- fullPath = classifyFullInfo.getCurrentClassifyVO().getOid();
- }
- return fullPath;
- }
-
- /***
- * @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 ->
- !MdmEngineConstant.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 = MdmEngineConstant.CODE_CLASSIFY_OID_FIELD;
- }
- if(StringUtils.isBlank(id) && "鐮佹瀹藉害".equalsIgnoreCase(title)){
- id = MdmEngineConstant.CODE_SEC_LENGTH_FIELD;
- }
- if(StringUtils.isBlank(id) && "浼佷笟缂栫爜".equalsIgnoreCase(title)){
- id = MdmEngineConstant.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(MdmEngineConstant.IMPORT_ROW_INDEX,codeImprotDataVO.getRowIndex());
- codeImprotDataVO.setFields(fields);
- codeImprotDataVO.setColNames(colNames);
- codeImprotDataVO.getDatas().add(filedValueMap);
- }
-
- /**
- * excel鐨勬爣棰樹笂鑾峰彇瀛楁鎵�鍦ㄧ殑浣嶇疆
- * @param titleRowData 鏍囬鐨勫唴瀹�
- * @param attrNameIdMap 妯℃澘涓睘鎬у悕绉板拰鑻辨枃鐨勬槧灏�
- * @param fieldIndexMap 浣嶇疆鍜岃嫳鏂囧瓧娈电殑鏄犲皠
- */
- private void getFieldIndexMap(List<String> titleRowData,Map<String/**鍚嶇О**/,String/**瀛楁鍚�**/> attrNameIdMap,Map<Integer/**浣嶇疆**/,String/**鑻辨枃鍚嶅瓧**/> fieldIndexMap){
- for (int i = 0; i < titleRowData.size(); i++) {
- String title = titleRowData.get(i);
- String id = attrNameIdMap.getOrDefault(title.replace(KEY_ATTR_CHAR,"").replace(REQUIRED_CHAR,""),"");
- if(StringUtils.isBlank(id) && "鍒嗙被璺緞".equalsIgnoreCase(title)){
- id = MdmEngineConstant.CODE_CLASSIFY_OID_FIELD;
- }
- if(StringUtils.isBlank(id) && "鐮佹瀹藉害".equalsIgnoreCase(title)){
- id = MdmEngineConstant.CODE_SEC_LENGTH_FIELD;
- }
- if(StringUtils.isBlank(id) && "浼佷笟缂栫爜".equalsIgnoreCase(title)){
- id = MdmEngineConstant.CODE_FIELD;
- }
- if(StringUtils.isNotBlank(id)){
- fieldIndexMap.put(i,id);
- }
- }
- }
-
-
- /**
- * 閫掑綊鎵剧紪鐮佽鍒�
- * @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);
- }
- }
-
-
- /**
- * 閿欒淇℃伅杩斿洖excel
- * @param rowDataList 鎵�鏈夌殑瀵煎叆鏁版嵁
- * @param errorMap 閿欒鐨勪俊鎭�
- * @param needRowIndexList 闇�瑕佸啓鍏ョ殑鏁版嵁鐨勮鍙�
- * @param titleRowData 鏍囬琛�
- *
- * @return 閿欒鐨別xcel鏂囦欢锛屾病鏈夐敊璇細杩斿洖绌�
- */
- private String returnErrorToExcel(Collection<SheetRowData> rowDataList,
- Map<String,String> errorMap,
- List<String> needRowIndexList,List<String> titleRowData){
- if(CollectionUtils.isEmpty(errorMap)){
- return "";
- }
- Map<String, SheetRowData> rowIndexDataMap = rowDataList.stream().filter(s -> !needRowIndexList.contains(s.getRowIndex())).collect(Collectors.toMap(s -> s.getRowIndex(), t -> t));
- List<WriteExcelData> errorDataList = new ArrayList<>();
- 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]++;
- }
- });
- String excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + "閿欒淇℃伅.xls";
- WriteExcelOption eo = new WriteExcelOption(errorDataList);
- try {
- new File(excelFileName).createNewFile();
- } catch (IOException e) {
- throw new VciBaseException(LangBaseUtil.getErrorMsg(e));
- }
- ExcelUtil.writeDataToFile(excelFileName,eo);
- return excelFileName;
- }
-
- /**
- * 鑾峰彇灞炴�у湪excel涓殑琛屾暟
- * @param fieldIndexIdMap 鍒楀彿-瀛楁鏄犲皠
- * @param attrId 灞炴�х殑缂栧彿
- * @return 鍒楀彿
- */
- private Integer getIndexInRowData(Map<Integer,String> fieldIndexIdMap,String attrId){
- return fieldIndexIdMap.keySet().stream().filter(
- index -> attrId.equalsIgnoreCase(fieldIndexIdMap.get(index))).findFirst().orElseGet(()->0);
- }
-
- /**
- * 澶勭悊鏋氫妇鐨勬樉绀哄璞�
- * @param attrVOS 妯℃澘灞炴��
- * @param dataList excel鐨勬暟鎹唴瀹�
- * @param errorMap 閿欒淇℃伅鐨勬槧灏�
- */
- private void batchSwitchEnumAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,
- Map<String,String> errorMap ) {
- Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(
- s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumid()))
- ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
- dateAttrVOMap.forEach((attrId, attrVO) -> {
- dataList.stream().forEach(cbo -> {
- String text = cbo.getAttributeValue(attrId);
- if(StringUtils.isNotBlank(text)){
- List<KeyValue> valueList = engineService.listComboboxItems(attrVO);
- boolean fined = false;
- for (int i = 0; i < valueList.size(); i++) {
- KeyValue keyValue = valueList.get(i);
- //if(keyValue.getValue().equalsIgnoreCase(text)){
- if(keyValue.getValue().equalsIgnoreCase(text)||keyValue.getKey().equalsIgnoreCase(text)){
- try {
- cbo.setAttributeValue(attrId, keyValue.getKey());
- }catch (Throwable e){
- logger.error("璁剧疆灞炴�у嚭閿�");
- }
- fined = true;
- break;
- }
- }
- if(!fined){
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";灞炴�" + attrVO.getName() + "]鐨勫�间笉绗﹀悎涓嬫媺鐨勮姹�");
- }
- }
- });
- });
- }
- }
-
- /**
- * 杞Щboolean鍨嬬殑灞炴��
- * @param attrVOS 灞炴�х殑瀵硅薄
- * @param dataList 鏁版嵁
- */
- private void reSwitchBooleanAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList){
- Map<String, CodeClassifyTemplateAttrVO> booleanAttrMap = attrVOS.stream().filter(
- s -> VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(s.getAttributedatatype())
- ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (!CollectionUtils.isEmpty(booleanAttrMap)) {
- booleanAttrMap.forEach((attrId, attrVO) -> {
- dataList.stream().forEach(cbo -> {
- String text = cbo.getAttributeValue(attrId);
- try {
- if (BooleanEnum.TRUE.getValue().equalsIgnoreCase(text) || "鏄�".equalsIgnoreCase(text)) {
- cbo.setAttributeValue(attrId, BooleanEnum.TRUE.getValue());
- } else {
- cbo.setAttributeValue(attrId, BooleanEnum.FASLE.getValue());
- }
- }catch (Throwable e){
-
- }
- });
- });
- }
- }
-
- /**
- * 杞崲鍙傜収鐨勫��
- * @param attrVOS 灞炴�х殑鏄剧ず瀵硅薄
- * @param dataList 鏁版嵁鍒楄〃
- * @param errorMap 閿欒鐨勪俊鎭�
- */
- private void batchSwitchReferAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,Map<String,String> errorMap){
- Map<String, CodeClassifyTemplateAttrVO> referAttrVOMap = attrVOS.stream().filter(
- s -> (StringUtils.isNotBlank(s.getReferbtmid()) || StringUtils.isNotBlank(s.getReferConfig()))
- ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if(!CollectionUtils.isEmpty(referAttrVOMap)){
- Map<String/**琛ㄦ牸鍜屽�肩殑灞炴��**/,Map<String/**鏄剧ず灞炴�х殑鍊�**/,List<String>/**琛ㄦ牸閲岀殑鍊�**/>> linkValueMap = new HashMap<>();
- referAttrVOMap.forEach((attrId,attrVO)->{
- dataList.stream().forEach(cbo -> {
- String text = cbo.getAttributeValue(attrId);
- if(StringUtils.isNotBlank(text)){
- UIFormReferVO referVO = getReferVO(attrVO);
- String valueField = getValueField(referVO);
- String showText = getTextField(referVO);
- String tableAndAttr = VciBaseUtil.getTableName(referVO.getReferType()) + "#" + valueField;
- Map<String, List<String>> showTextMap = linkValueMap.getOrDefault(tableAndAttr, new HashMap<>());
- List<String> textList = showTextMap.getOrDefault(showText, new ArrayList<>());
- if(!textList.contains(text)) {
- textList.add(text);
- }
- showTextMap.put(showText,textList);
- linkValueMap.put(tableAndAttr,showTextMap);
- }
- });
- });
- if(!CollectionUtils.isEmpty(linkValueMap)){
- //闇�瑕侀�愪釜琛ㄧ殑鍊煎瓧娈碉紝閫愪釜鏌ヨ
- Map<String/**琛ㄦ牸鍜屽�煎睘鎬�**/,Map<String/**鏄剧ず灞炴��**/, Map<String/**鍊�**/,String/**鏄剧ず鐨勫��**/>>> linkCboMap = new HashMap<>();
- linkValueMap.forEach((tableAndAttr,showValueMap)->{
- String[] split = tableAndAttr.split("#");
- String table = split[0];
- String valueField = split[1].toLowerCase(Locale.ROOT);
- Map<String,Map<String,String>> dataMap = new HashMap<>();
- showValueMap.forEach((showText,valueList)->{
- Map<String,String> valueOidTextMap = new HashMap<>();
- List<List<String>> valueCollections = VciBaseUtil.switchListForOracleIn(valueList);
- String sql = "select " + valueField + "," + showText.toLowerCase(Locale.ROOT) +" from " + table + " where " + showText + " in (%s)";
- valueCollections.stream().forEach(values->{
- List<ClientBusinessObject> cbos = boService.queryByOnlySql(String.format(sql, VciBaseUtil.toInSql(values.toArray(new String[0]))));
- if(!CollectionUtils.isEmpty(cbos)){
- valueOidTextMap.putAll(cbos.stream().collect(Collectors.toMap(s->s.getAttributeValue(valueField),t->t.getAttributeValue(showText))));
- }
- });
- dataMap.put(showText,valueOidTextMap);
- });
- linkCboMap.put(tableAndAttr,dataMap);
- });
- referAttrVOMap.forEach((attrId,attrVO)->{
- dataList.stream().forEach(cbo -> {
- String text = cbo.getAttributeValue(attrId);
- if (StringUtils.isNotBlank(text)) {
- UIFormReferVO referVO = getReferVO(attrVO);
- String valueField = getValueField(referVO);
- String showText = getTextField(referVO);
- String tableAndAttr = VciBaseUtil.getTableName(referVO.getReferType()) + "#" + valueField;
- if(!linkCboMap.containsKey(tableAndAttr)){
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍙傛暟灞炴�" + attrVO.getName() + "]鐨勫�煎湪绯荤粺涓笉瀛樺湪" );
-
- }else{
- Map<String, Map<String, String>> dataMap = linkCboMap.get(tableAndAttr);
- if(!dataMap.containsKey(showText)){
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍙傛暟灞炴�" + attrVO.getName() + "]鐨勫�煎湪绯荤粺涓笉瀛樺湪" );
- }else{
- Map<String, String> data = dataMap.get(showText);
- final boolean[] fined = {false};
- data.forEach((key,value)->{
- if(value.equalsIgnoreCase(text)){
- fined[0] = true;
- try {
- cbo.setAttributeValue(attrId, key);
- }catch (Throwable e){
-
- }
- }
- });
- if(!fined[0]){
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍙傛暟灞炴�" + attrVO.getName() + "]鐨勫�煎湪绯荤粺涓笉瀛樺湪" );
- }
- }
- }
- }
- });
- });
- }
- }
-
- }
-
- /**
- * 浠庡睘鎬т笂鑾峰彇鍙傜収鐨勫唴瀹�
- * @param attrVO 灞炴�х殑淇℃伅
- * @return 鍙傜収鐨勫唴瀹�
- */
- private UIFormReferVO getReferVO(CodeClassifyTemplateAttrVO attrVO){
- UIFormReferVO referVO = null;
- if(StringUtils.isNotBlank(attrVO.getReferConfig())){
- referVO = JSONObject.parseObject(attrVO.getReferConfig(),UIFormReferVO.class);
- }else{
- referVO = new UIFormReferVO();
- referVO.setReferType(attrVO.getReferbtmid());
- referVO.setValueField(VciQueryWrapperForDO.OID_FIELD);
- referVO.setTextField("name");
- }
- return referVO;
- }
-
- /**
- * 鑾峰彇鍙傜収涓殑鍊肩殑瀛楁
- * @param referVO 鍙傜収鐨勫璞�
- * @return 榛樿涓篛id锛屾湁澶氫釜鐨勬椂鍊欙紝鑾峰彇绗竴涓�
- */
- private String getValueField(UIFormReferVO referVO){
- String showText = referVO.getValueField();
- if(StringUtils.isBlank(showText)){
- return "oid";
- }
- if(showText.contains(",")){
- //闃叉涓囦竴鏈夊涓紝鐪嬬湅鏈夋病鏈塷id
- List<String> strings = VciBaseUtil.str2List(showText);
- if(strings.contains("oid")){
- showText = "oid";
- }else{
- showText = strings.get(0);
- }
- }
- return showText;
- }
-
- /**
- * 鑾峰彇鍙傜収涓殑鏄剧ず鍐呭鐨勫瓧娈�
- * @param referVO 鍙傜収鐨勫璞�
- * @return 榛樿涓簄ame锛屾湁澶氫釜鐨勬椂鍊欙紝鑾峰彇绗竴涓�
- */
- private String getTextField(UIFormReferVO referVO){
- String showText = referVO.getTextField();
- if(StringUtils.isBlank(showText)){
- return "name";
- }
- if(showText.contains(",")){
- //闃叉涓囦竴鏈夊涓紝鐪嬬湅鏈夋病鏈塶ame
- List<String> strings = VciBaseUtil.str2List(showText);
- if(strings.contains("name")){
- showText = "name";
- }else{
- showText = strings.get(0);
- }
- }
- return showText;
- }
-
-
-
- /**
- * 澶勭悊鍒嗙被娉ㄥ叆
- * @param attrVOS 妯℃澘灞炴��
- * @param dataList excel鐨勬暟鎹唴瀹�
- * @param classifyFullInfo 鍒嗙被鐨勫叏璺緞
- */
- private void batchSwitchClassifyAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,
- CodeClassifyFullInfoBO classifyFullInfo,boolean isImPort) {
- Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(
- s -> StringUtils.isNotBlank(s.getClassifyinvokeattr()) && StringUtils.isNotBlank(s.getClassifyinvokelevel())
- ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- Map<String,CodeClassifyFullInfoBO> classifyFullInfoMap=new HashMap<>();
- classifyFullInfoMap.put(classifyFullInfo.getCurrentClassifyVO().getOid(),classifyFullInfo);
- if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
- dataList.stream().forEach(cbo -> {
- dateAttrVOMap.forEach((attrId, attrVO) -> {
- //鍒嗙被娉ㄥ叆鐨勭紪鍙锋垨鑰呭悕绉帮紝
- //灞傜骇鍖呭惈鎸囧畾灞傚拰鏈�灏忓眰
- CodeClassifyVO classifyVO = null;
- if(!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyinvokelevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyinvokelevel())) {
- //鎸囧畾浜嗗眰绾х殑
- //娉ㄦ剰锛屽洜涓烘煡璇笂绾у垎绫诲嚭鏉ョ殑灞傜骇鏄�掑簭鐨勶紝鍗抽《灞傝妭鐐规槸鏈�澶х殑鍊�
- if(isImPort){
- if(!classifyFullInfoMap.containsKey(cbo.getAttributeValue(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD))) {
- CodeClassifyFullInfoBO currentClassifyFullInfo = classifyService.getClassifyFullInfo(cbo.getAttributeValue(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD));
- classifyFullInfoMap.put(currentClassifyFullInfo.getCurrentClassifyVO().getOid(), currentClassifyFullInfo);
- }
- }
- CodeClassifyFullInfoBO newClassifyFullInfo= classifyFullInfoMap.get(cbo.getAttributeValue(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD));
- List<CodeClassifyVO> classifyVOS = newClassifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
- int level = VciBaseUtil.getInt(attrVO.getClassifyinvokelevel());
- if (classifyVOS.size()>=level && level > 0 ) {
- classifyVO = classifyVOS.get(level-1);
- }
- }else{
- //褰撳墠鐨勫垎绫�
- classifyVO = classifyFullInfo.getCurrentClassifyVO();
- }
- try {
- if (classifyVO == null) {
- //璇存槑灞傜骇鏈夎
- cbo.setAttributeValue(attrId, "鍒嗙被鏍戜笂娌℃湁灞傜骇[" + attrVO.getClassifyinvokelevel() + "]");
- } else {
- Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
- String value = classifyDataMap.getOrDefault(attrVO.getClassifyinvokeattr(), "");
- cbo.setAttributeValue(attrId, value);
- }
- } catch (Throwable e) {
- logger.error("璁剧疆灞炴�ч敊璇�", e);
- }
- });
- });
- }
- }
-
- /**
- * 澶勭悊缁勫悎瑙勫垯
- * @param attrVOS 妯℃澘灞炴��
- * @param dataList excel鐨勬暟鎹唴瀹�
- */
- private void batchSwitchComponentAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList) {
- Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getComponentrule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
- dateAttrVOMap.forEach((attrId, attrVO) -> {
- dataList.stream().forEach(cbo -> {
- //浠巈xcel涓婃妸灞炴�ц浆鎹负map
- Map<String,String> thisRowDataMap = new HashMap<>();
- WebUtil.copyValueToMapFromCbos(cbo,thisRowDataMap);
- //缁勫悎鍐呭
- String value = formulaService.getValueByFormula(thisRowDataMap,attrVO.getComponentrule());
- if(value == null){
- value = "";
- }
- try {
- cbo.setAttributeValue(attrId, value);
- }catch (Throwable e){
- logger.error("璁剧疆灞炴�х殑閿欒",e);
- }
- });
- });
- }
- }
-
- /**
- * 鎵归噺杞崲鏃堕棿閮戒负鎸囧畾鐨勬牸寮�
- * @param attrVOS 妯℃澘灞炴��
- * @param cboList 鏁版嵁鐨勫垪琛�
- * @param errorMap 閿欒鐨勪俊鎭�
- */
- private void batchSwitchDateAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> cboList,Map<String,String> errorMap){
- Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap =attrVOS.stream().filter(s ->
- StringUtils.isNotBlank(s.getCodedateformat()) && VciBaseUtil.getBoolean(s.getFormdisplayflag()) && StringUtils.isBlank(s.getComponentrule())
- && StringUtils.isBlank(s.getClassifyinvokeattr())
- ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
- dateAttrVOMap.forEach((attrId, attrVO) -> {
- cboList.stream().forEach(cbo -> {
- String value = cbo.getAttributeValue(attrId);
- if (value == null) {
- value = "";
- }
- if (StringUtils.isNotBlank(value)) {
- boolean formated = false;
- if(StringUtils.isNotBlank(attrVO.getCodedateformat())){
- try {
- Date date = VciDateUtil.str2Date(value, attrVO.getCodedateformat());
- if(date!=null){
- cbo.setAttributeValue(attrId,value);
- formated = true;
- }
- } catch (Exception e) {
- //璇存槑涓嶆槸杩欎釜鏍煎紡
- }
- }
- if(!formated) {
- try {
- DateConverter dateConverter = new DateConverter();
- dateConverter.setAsText(value);
- value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
- cbo.setAttributeValue(attrId,value);
- }catch (Throwable e){
- //杞崲涓嶄簡
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";灞炴�" + attrVO.getName() + "]鏃堕棿鏍煎紡涓嶆纭�" );
- }
- }
- }
- });
- });
- }
- }
-
- /**
- * 鏍￠獙鏄惁鏋氫妇鐨勫彇鍊艰寖鍥�
- * @param attrVOS 妯℃澘灞炴��
- * @param dataList 鏁版嵁鐨勫垪琛�
- * @return 涓嶇鍚堟灇涓惧彇鍊艰繑鍥炵殑琛屾暟
- */
- private Set<String> batchCheckEnumOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS, List<ClientBusinessObject> dataList) {
- //濡傛灉鏋氫妇鍙互淇敼锛屽垯涓嶉渶瑕佹牎楠屾槸鍚︾鍚堟灇涓剧殑閫夐」
- Map<String, CodeClassifyTemplateAttrVO> enumAttrVOMap = attrVOS.stream().filter(s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumid())) && !VciBaseUtil.getBoolean(s.getEnumeditflag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if(!CollectionUtils.isEmpty(enumAttrVOMap)){
- return dataList.stream().filter(cbo->
- enumAttrVOMap.keySet().stream().anyMatch(attrId-> {
- String value = cbo.getAttributeValue(attrId);
- if(StringUtils.isNotBlank(value)) {
- CodeClassifyTemplateAttrVO attrVO = enumAttrVOMap.get(attrId);
- List<KeyValue> comboboxKVs = engineService.listComboboxItems(attrVO);
- return !comboboxKVs.stream().anyMatch(s -> value.equalsIgnoreCase(s.getValue()));
- }else{
- return false;
- }
- })).map(s->s.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX)).collect(Collectors.toSet());
- }
- return new HashSet<>();
- }
-
- /**
- * 妫�鏌ユ牎楠岃鍒欐病鏈夐�氳繃鐨勫唴瀹�
- * @param attrVOS 闇�瑕佹牎楠岀殑灞炴��
- * @param dataList 鏁版嵁鐨勫垪琛�
- * @param errorMap 閿欒鐨勪俊鎭槧灏�
- * @return 鏍￠獙涓嶉�氳繃鐨勮鏁�
- */
- private void batchCheckVerifyOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS, List<ClientBusinessObject> dataList,Map<String,String> errorMap) {
- Map<String, CodeClassifyTemplateAttrVO> verifyAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getVerifyrule()) && StringUtils.isBlank(s.getComponentrule())
- &&StringUtils.isBlank(s.getClassifyinvokeattr())
- ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if(!CollectionUtils.isEmpty(verifyAttrVOMap)){
- Map<String/**琛屽彿**/,List<String>/**鏍￠獙涓嶉�氳繃鐨勫睘鎬�**/> unPassCheckMap = new HashMap<>();
- verifyAttrVOMap.forEach((attrId,attrVO)->{
- dataList.stream().forEach(cbo -> {
- String value = cbo.getAttributeValue(attrId);
- if(StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyrule())){
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- List<String> unPassAttrs = unPassCheckMap.getOrDefault(rowIndex, new ArrayList<>());
- unPassAttrs.add(attrVO.getName());
- unPassCheckMap.put(rowIndex,unPassAttrs);
- }
- });
- });
- if(!CollectionUtils.isEmpty(unPassCheckMap)){
- unPassCheckMap.forEach((rowIndex,unPassAttrs)->{
- errorMap.put(rowIndex,";灞炴�" + unPassAttrs.stream().collect(Collectors.joining(",")) + "]鍐呭涓嶇鍚堟牎楠岃鍒欑殑瑕佹眰");
- });
- }
- }
- }
-
- private void bathcResembleQuery(String codeClassifyOid, CodeClassifyTemplateVO templateVO, List<ClientBusinessObject> cboList,Map<String,String>resembleMap,String btmtypeid,List<DataResembleVO> dataResembleVOS){
- CodeClassifyFullInfoBO fullInfoBO = classifyService.getClassifyFullInfo(codeClassifyOid);
- Map<String, String> conditionMap = new HashMap<>();
- CodeResembleRuleVO resembleRuleVO = Optional.ofNullable(engineService.getUseResembleRule(fullInfoBO, fullInfoBO.getCurrentClassifyVO())).orElseGet(() -> new CodeResembleRuleVO());
- //闇�瑕佽幏鍙栨槸鍚︽湁鐩镐技鏌ヨ灞炴��
- Map<String, CodeClassifyTemplateAttrVO> attrVOs = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSamerepeatattrflag())).collect(Collectors.toMap(s -> s.getId(), t -> t));
- if (CollectionUtils.isEmpty(attrVOs)) {
- return;
- }
- Map<String, CodeImprotResembleVO> codeImprotResembleVOMap=new HashMap<>();
- List<CodeImprotResembleVO> codeImprotResembleVOList=new ArrayList<>();
- Map<String,String> rowIndePathMap=new HashMap<>();
- cboList.stream().forEach(clientBusinessObject -> {
- CodeImprotResembleVO codeImprotResembleVO=new CodeImprotResembleVO();
- final String[] path = {""};
- List<String> fieldList=new ArrayList<>();
- List<String> rowIndeList=new ArrayList<>();
- String rowIndex = clientBusinessObject.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- attrVOs.forEach((attrId, attrVO) -> {
- String value="";
- /*if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
- value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
- }else {*/
- value= clientBusinessObject.getAttributeValue(attrId);
- // }
- fieldList.add(attrId);
- value=StringUtils.isBlank(value)?"":value;
- path[0] +=value+"#";
- engineService.wrapperResembleConditionMap(value, resembleRuleVO, attrId, conditionMap);
- });
- List<Map<String,String>> dataMap=new ArrayList<>();
- if(codeImprotResembleVOMap.containsKey(path[0])) {
- codeImprotResembleVO=codeImprotResembleVOMap.get(path[0]);
- rowIndeList=codeImprotResembleVO.getRownIndex();
- dataMap= codeImprotResembleVO.getDataList();
- resembleMap.put(rowIndex, "瀛樺湪鐩镐技鏁版嵁");
- }else{
- if (!CollectionUtils.isEmpty(conditionMap)) {
- Map<String, String> andConditionMap = new HashMap<>();
- andConditionMap.put("islastr", "1");
- andConditionMap.put("islastv", "1");
- conditionMap.putAll(andConditionMap);
- PageHelper pageHelper = new PageHelper(-1);
- pageHelper.addDefaultDesc("id");
- CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(btmtypeid, templateVO, conditionMap, pageHelper);
- List<ClientBusinessObject> resembleCboList=boService.queryByOnlySql(sqlBO.getSqlUnPage());
- if(!CollectionUtils.isEmpty(resembleCboList)) {
- List<Map<String, String>> finalDataMap = dataMap;
- resembleCboList.stream().forEach(cbo->{
- Map<String,String> resembDataMap=new HashMap<>();
- fieldList.stream().forEach(field->{
- String value=cbo.getAttributeValue(field);
- value=StringUtils.isBlank(value)?"":value;
- resembDataMap.put(field,value);
- });
- resembDataMap.put("id",StringUtils.isBlank(cbo.getAttributeValue("id"))?"":cbo.getAttributeValue("id"));
- resembDataMap.put("rowIndex","");
- finalDataMap.add(resembDataMap);
- });
- resembleMap.put(rowIndex, "瀛樺湪鐩镐技鏁版嵁");
-
- }
- }
- }
- rowIndePathMap.put(rowIndex,path[0]);
- rowIndeList.add(rowIndex);
- codeImprotResembleVO.setPath(path[0]);
- codeImprotResembleVO.setRownIndex(rowIndeList);
- codeImprotResembleVO.setConditionMap(conditionMap);
- codeImprotResembleVO.setFields(fieldList);
- codeImprotResembleVO.setDataList(dataMap);
- codeImprotResembleVOMap.put(path[0],codeImprotResembleVO);
- });
- Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((MdmEngineConstant.IMPORT_ROW_INDEX)), t -> t));
- if(!CollectionUtils.isEmpty(rowIndePathMap)){
- rowIndePathMap.forEach((rowIndex, path) -> {
- if(codeImprotResembleVOMap.containsKey(path)){
- CodeImprotResembleVO codeImprotResembleVO= codeImprotResembleVOMap.get(path);
- List<String> fieldList=codeImprotResembleVO.getFields();
- List<String> rownIndexList= codeImprotResembleVO.getRownIndex();
- List<String> newRownIndexList = rownIndexList.stream().filter(cbo -> {
- return rowIndex!=cbo;
- }).collect(Collectors.toList());
- newRownIndexList.stream().forEach(s -> {
- resembleMap.put(s, "瀛樺湪鐩镐技鏁版嵁");
- });
- List<Map<String, String>>newDataList=new ArrayList<>();
- DataResembleVO dataResembleVO=new DataResembleVO();
- dataResembleVO.setOid(cboMap.get(rowIndex).getOid());
- List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
- String newRowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- return rownIndexList.contains(newRowIndex)&&(!newRowIndex.equalsIgnoreCase(rowIndex));
- }).collect(Collectors.toList());
- if(!CollectionUtils.isEmpty(needSaveCboList)) {
- needSaveCboList.stream().forEach(cbo -> {
- String newRowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- Map<String, String> resembDataMap = new HashMap<>();
- fieldList.stream().forEach(field -> {
- String value = cbo.getAttributeValue(field);
- value = StringUtils.isBlank(value) ? "" : value;
- resembDataMap.put(field, value);
- });
- resembDataMap.put("id",StringUtils.isBlank(cbo.getAttributeValue("id"))?"":cbo.getAttributeValue("id"));
- resembDataMap.put("rowIndex", newRowIndex);
- newDataList.add(resembDataMap);
- });
- }
- List<Map<String, String>>dataList=codeImprotResembleVO.getDataList();
- newDataList.addAll(dataList);
- dataResembleVO.setDataList(newDataList);
- dataResembleVOS.add(dataResembleVO);
- }
- });
- }
- }
-
- /**
- * 鏍￠獙鍏抽敭灞炴��
- * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
- * @param templateVO 妯℃澘鐨勫唴瀹癸紝蹇呴』鍖呭惈妯℃澘灞炴��
- * @param cboList 鎵归噺鐨勬暟鎹�
- */
- private CodeImportResultVO batchCheckKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO,
- List<ClientBusinessObject> cboList) {
- //涓嶮dmEngineServiceImpl閲岀殑checkKeyAttrOnOrder鐩镐技
- //鍏堣幏鍙栧叧閿睘鎬х殑瑙勫垯锛屼篃鍒╃敤缁ф壙鐨勬柟寮�
- CodeKeyAttrRepeatRuleVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
- //娉ㄦ剰鐨勬槸keyRuleVO鍙兘涓虹┖锛岃〃绀轰笉浣跨敤瑙勫垯鎺у埗
- //鑾峰彇鎵�鏈夌殑鍏抽敭灞炴��
- Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyattrflag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
-
- boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
- //鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
- boolean trim =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
- boolean ignoreCase = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
- boolean ignoreWidth = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
-
- //1. 鎴戜滑闇�瑕佸厛鍒ゆ柇excel瀵煎叆鐨勫唴瀹规槸鍚︽纭�
- CodeImportResultVO resultVO = new CodeImportResultVO();
- resultVO.setKeyAttrRuleInfo(String.format(keyRuleVO ==null?"":"鏌ヨ瑙勫垯锛氬幓闄ょ┖鏍�--{0},蹇界暐澶у皬鍐�--{1},蹇界暐鍏ㄥ崐瑙�--{2},蹇界暐鍏ㄩ儴绌烘牸--{3}",
- new String[]{trim?"鏄�":"鍚�",ignoreCase?"鏄�":"鍚�",ignoreWidth?"鏄�":"鍚�",trimAll?"鏄�":"鍚�"}));
- resultVO.setSelfRepeatRowIndexList(getSelfRepeatRowIndex(ketAttrMap,cboList,keyRuleVO));
- if(!CollectionUtils.isEmpty(resultVO.getSelfRepeatRowIndexList())){
- //鎴戜滑绉婚櫎鏈韩閲嶅鐨勬暟鎹�
- cboList = cboList.stream().filter(s->!resultVO.getSelfRepeatRowIndexList().contains(s.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX))).collect(Collectors.toList());
- }
- //2.鍒ゆ柇鍏抽敭灞炴�у湪绯荤粺閲屾槸鍚﹂噸澶�
- //鍥犱负鏁版嵁閲忓緢澶э紝鎵�浠ュ緱鎯冲姙娉曞苟琛�
- SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
- Map<String,List<ClientBusinessObject>> indexTODataMap=new HashMap<>();
- List<ClientBusinessObject> repeatDataMap = cboList.parallelStream().filter(cbo -> {
- //姣忚閮藉緱鏌ヨ.濡傛灉鍏朵腑鍑虹幇浜嗛敊璇紝鎴戜滑灏辩洿鎺ユ姏鍑哄紓甯革紝鍏朵綑鐨勬樉绀�
- VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
- Map<String, String> conditionMap = new HashMap<>();
- ketAttrMap.forEach((attrId, attrVO) -> {
- String value =cbo.getAttributeValue(attrId.toLowerCase(Locale.ROOT));
- if (value == null) {
- value = "";
- }
- value= value.replace(REQUIRED_CHAR,SPECIAL_CHAR);
- engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
- });
- if (!CollectionUtils.isEmpty(ketAttrMap)) {
- CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), templateVO, conditionMap, null);
- boolean isKeyCheck= boService.queryCountBySql(sqlBO.getSqlCount(), new HashMap<>()) > 0;
- if(isKeyCheck){
- List<ClientBusinessObject> newCboList= boService.queryByOnlySql(sqlBO.getSqlUnPage());
- indexTODataMap.put(cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX),newCboList);
- }
- return isKeyCheck;
- }else{
- return false;
- }
- }).collect(Collectors.toList());
- if(!CollectionUtils.isEmpty(repeatDataMap)){
- resultVO.setKeyAttrRepeatRowIndexList(repeatDataMap.stream().map(s->s.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX)).collect(Collectors.toSet()));
- }
- resultVO.setIndexTODataMap(indexTODataMap);
- resultVO.setSuccess(true);
- return resultVO;
- }
-
- /**
- * 鑾峰彇瀵煎叆鐨勫唴瀹逛腑鍏抽敭灞炴�ч噸澶嶇殑琛屽彿
- * @param ketAttrMap 鍏抽敭灞炴�х殑鏄犲皠
- * @param dataList 瀵煎叆鐨勬暟鎹�
- * @param keyRuleVO 鍏抽敭灞炴�ф帶鍒惰鍒�
- * @return 閲嶅鐨勮鍙�
- */
- private Set<String> getSelfRepeatRowIndex(Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> ketAttrMap,
- List<ClientBusinessObject> dataList,CodeKeyAttrRepeatRuleVO keyRuleVO){
- Set<String> selfRepeatRowIndexList = new CopyOnWriteArraySet<>();
- boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
- //鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
- boolean trim =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
- boolean ignoreCase = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
- boolean ignoreWidth = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
- //蹇呴』灏嗗睘鎬ф寜鐓ч『搴忔帓搴忓ソ
- List<CodeClassifyTemplateAttrVO> attrVOList = ketAttrMap.values().stream().sorted(((o1, o2) -> o1.getOrdernum().compareTo(o2.getOrdernum()))).collect(Collectors.toList());
- Map<String/**琛屽彿**/,String/**鍏抽敭灞炴�х殑缁勫悎鍐呭**/> rowIndexKeyStringMap = new HashMap<>();
- dataList.parallelStream().forEach(cbo-> {
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- StringBuilder sb = new StringBuilder();
- for (int i = 0; i < attrVOList.size(); i++) {
- CodeClassifyTemplateAttrVO attrVO = attrVOList.get(i);
- String attrId = attrVO.getId().toLowerCase(Locale.ROOT);
- String value = cbo.getAttributeValue( attrId);
- if (value == null) {
- value = "";
- }
- if(trim){
- value = value.trim();
- }
- if(trimAll){
- value = value.replace(" ","");
- }
- if(ignoreCase){
- value = value.toLowerCase(Locale.ROOT);
- }
- if(ignoreWidth){
- value = VciBaseUtil.toDBC(value);
- }
- sb.append(value).append("${ks}");
- }
- String keyString = sb.toString();
- if(rowIndexKeyStringMap.containsValue(keyString) && StringUtils.isNotBlank(keyString)){
- selfRepeatRowIndexList.add(rowIndex);
- }else {
- rowIndexKeyStringMap.put(rowIndex, sb.toString());
- }
- });
- //鍥犱负鍙槸鍏抽敭灞炴�ч噸澶嶏紝鎵�浠ユ垜浠笉鑳介噸澶嶇殑澶氭潯閫変竴鏉℃潵鎶ラ敊
- return selfRepeatRowIndexList;
- }
-
- /**
- * 瀵煎嚭鐨勬椂鍊欏皝瑁呭繀杈撳拰鍏抽敭灞炴��
- * @param attrVO 灞炴�х殑鏄剧ず瀵硅薄
- * @param text 鍗曞厓鏍肩殑鍊�
- */
- private Object exportKeyAndRequired(Workbook workbook,CodeClassifyTemplateAttrVO attrVO,Object text){
- //蹇呰緭鍔�*锛屽叧閿睘鎬т负钃濊壊
- if (VciBaseUtil.getBoolean(attrVO.getRequireflag()) || VciBaseUtil.getBoolean(attrVO.getKeyattrflag())) {
- String value = text.toString();
- if(VciBaseUtil.getBoolean(attrVO.getRequireflag())) {
- value += REQUIRED_CHAR;
- }
- if(VciBaseUtil.getBoolean(attrVO.getKeyattrflag())){
- value += KEY_ATTR_CHAR;
- }
- RichTextString ts = new HSSFRichTextString(value);
- if(VciBaseUtil.getBoolean(attrVO.getRequireflag())){
- Font font = workbook.createFont();
- font.setColor(HSSFColor.HSSFColorPredefined.RED.getIndex());
- ts.applyFont(font);
- }
-
- if(VciBaseUtil.getBoolean(attrVO.getKeyattrflag())){
- Font font = workbook.createFont();
- font.setColor(HSSFColor.HSSFColorPredefined.BLUE.getIndex());
- ts.applyFont(font);
- }
- return ts;
- }
- return text;
- }
-
- /**
- * 鏌ヨ鏁版嵁骞跺鍑哄埌excel
- * @param btmTypeId 涓氬姟绫诲瀷
- * @param conditionMap 鏌ヨ鏉′欢
- * @param pageHelper 鍒嗛〉
- * @param selectFieldList 鏌ヨ鐨勫瓧娈�
- * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
- * @param templateVO 妯℃澘鐨勪俊鎭�
- * @param exportAttrDTO 瀵煎嚭鐨勫睘鎬�
- * @param excelNameList excel鐨勬枃浠跺悕绉�
- * @param tempFolder 涓存椂鏂囦欢澶�
- * @param excelIndex excel鐨勯『搴�
- */
- private void selectDataAndExportExcelName(String btmTypeId, Map<String, String> conditionMap, PageHelper pageHelper, List<String> selectFieldList,
- CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO, CodeExportAttrDTO exportAttrDTO,
- List<String> excelNameList, String tempFolder,
- Integer excelIndex) {
- DataGrid<Map<String, String>> dataGrid = engineService.queryGrid(btmTypeId, templateVO, conditionMap, pageHelper);
- if(dataGrid == null || CollectionUtils.isEmpty(dataGrid.getData())){
- return;
- }
- //杞崲鏁版嵁
- List<Map<String, String>> dataMap = dataGrid.getData();
- //灏佽鏌ヨ鍑烘潵鐨勬暟鎹�
- engineService.wrapperData(dataMap, templateVO, selectFieldList,false);
- //modify by weidy@2022-09-27
- //鍥犱负鍦ㄥ垪琛ㄥ拰琛ㄥ崟鐨勬樉绀虹殑鏃跺�欙紝鎴戜滑鐨勫紑鍏崇被鍨嬮〉闈細澶勭悊锛屼絾鏄湪瀵煎嚭鐨勬椂鍊欙紝鎴戜滑闇�瑕佸皢true鍜宖alse閮芥浛鎹㈡垚涓枃
- engineService.wrapperBoolean(dataMap,templateVO);
- Map<String, CodeClassifyTemplateAttrVO> attrVOMap = templateVO.getAttributes().stream().filter(s->selectFieldList.contains(s.getId().toLowerCase(Locale.ROOT))).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- Map<Integer, String> attrIdIndexMap = exportAttrDTO.getAttrIdIndexMap();
- if (CollectionUtils.isEmpty(attrIdIndexMap)) {
- attrIdIndexMap = templateVO.getAttributes().stream().filter(s->selectFieldList.contains(s.getId().toLowerCase(Locale.ROOT))).collect(Collectors.toMap(s -> s.getOrdernum(), t -> t.getId()));
- }
- List<Integer> indexList = attrIdIndexMap.keySet().stream().sorted().collect(Collectors.toList());
-
- String excelName = tempFolder + File.separator +
- classifyFullInfo.getCurrentClassifyVO().getId() + "_" + classifyFullInfo.getCurrentClassifyVO().getName() + "_瀵煎嚭_" + excelIndex + ".xls";
- try {
- new File(excelName).createNewFile();
- } catch (Throwable e) {
- throw new VciBaseException(LangBaseUtil.getErrorMsg(e), new String[]{excelName}, e);
- }
- excelNameList.add(excelName);
- List<WriteExcelData> excelDataList = new ArrayList<>();
- Workbook workbook = new HSSFWorkbook();
- for (int i = 0; i < indexList.size(); i++) {
- String attrId = attrIdIndexMap.get(indexList.get(i)).toLowerCase(Locale.ROOT);
- if (attrVOMap.containsKey(attrId)) {
- CodeClassifyTemplateAttrVO attrVO = attrVOMap.get(attrId);
- Object text = attrVO.getName();
- text = exportKeyAndRequired(workbook,attrVO,text);
- WriteExcelData excelData = new WriteExcelData(0, i, text);
- if(text instanceof RichTextString){
- excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
- }
- excelDataList.add(excelData);
- }
- }
- final Integer[] rowIndex = {0};
- Map<Integer, String> finalAttrIdIndexMap = attrIdIndexMap;
- dataMap.stream().forEach(data -> {
- rowIndex[0]++;
- for (int i = 0; i < indexList.size(); i++) {
- Integer index = indexList.get(i);
- String attrId = finalAttrIdIndexMap.get(index).toLowerCase(Locale.ROOT);
- if (attrVOMap.containsKey(attrId)) {
- CodeClassifyTemplateAttrVO attrVO = attrVOMap.get(attrId);
- if (StringUtils.isNotBlank(attrVO.getEnumid()) || StringUtils.isNotBlank(attrVO.getEnumString())) {
- attrId = attrId + "Text";
- }
- if (StringUtils.isNotBlank(attrVO.getReferbtmid()) || StringUtils.isNotBlank(attrVO.getReferConfig())) {
- attrId = attrId + "name";
- }
- if(VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(attrId)){
- attrId = VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT);
- }
- excelDataList.add(new WriteExcelData(rowIndex[0], i, data.getOrDefault(attrId, "")));
- }
- }
- });
- WriteExcelOption excelOption = new WriteExcelOption(excelDataList);
- ExcelUtil.writeDataToFile(excelName, excelOption);
- }
-
- /**
- * 鎵归噺鏍￠獙鏁版嵁鐨勪俊鎭�
- * @param templateVO 妯℃澘鐨勬樉绀哄璞�
- * @param cboList 鏁版嵁鐨勫唴瀹�
- */
- private void batchCheckRequiredAttrOnOrder(CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,Map<String,String> errorMap){
- Map<String, CodeClassifyTemplateAttrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(s ->
- VciBaseUtil.getBoolean(s.getRequireflag()) && StringUtils.isBlank(s.getComponentrule()) && StringUtils.isBlank(s.getClassifyinvokeattr())//涓嶈兘鏄粍鍚堢殑鍜屽垎绫绘敞鍏ョ殑
- ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- //涓嶮dmEngineServiceImpl閲岄潰鐨刢heckRequiredAttrOnOrder 閫昏緫搴旇鐩镐技
- if(!CollectionUtils.isEmpty(requiredAttrMap)) {
- Set<String> nullRowIndex = cboList.stream().filter(cbo -> requiredAttrMap.keySet().stream().anyMatch(attrId -> StringUtils.isBlank(cbo.getAttributeValue(attrId)))).map(cbo -> cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX)).collect(Collectors.toSet());
- if(!CollectionUtils.isEmpty(nullRowIndex)){
- String checkAttr = requiredAttrMap.values().stream().map(CodeClassifyTemplateAttrVO::getName).collect(Collectors.joining(","));
- nullRowIndex.stream().forEach(rowIndex->{
- errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鏍￠獙瑙勫垯涓嶉�氳繃锛屾湁鏍￠獙鐨勫睘鎬т负" + checkAttr);
- });
- }
- }
- }
-
- /**
- * 鎵归噺妫�鏌ヤ紒涓氱紪鐮佹槸鍚﹀瓨鍦�
- * @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])) + ")");
- //涓氬姟鏁版嵁濡傛灉鐮佸�煎洖鏀朵細鐩存帴鍒犻櫎鏁版嵁锛屾墍浠ヨ繖閲岀洿鎺ュ垽鏂槸鍚﹀瓨鍦ㄥ嵆鍙�
- existIds.addAll(Optional.ofNullable(boService.queryCBO(templateVO.getBtmTypeId(), conditionMap, new PageHelper(-1), Arrays.stream(new String[]{"id"})
- .collect(Collectors.toList()))).orElseGet(() -> new ArrayList<>()).stream().map(s -> s.getAttributeValue("id")).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(MdmEngineConstant.IMPORT_ROW_INDEX);
- String msg = errorMap.getOrDefault(rowIndex, "");
- msg+=";" + finalIdFieldName + "鐨勫�煎湪绯荤粺涓凡缁忓瓨鍦�";
- errorMap.put(rowIndex,msg);
- }
- });
- }
- }
-
- /**
- * 浠巑ap閲岃幏鍙栧��
- * @param dataMap 鍊肩殑鏄犲皠
- * @param attrId 灞炴�х殑缂栧彿
- * @return 鍊�
- */
- private String getValueFormMap(Map<String,String> dataMap,String attrId){
- attrId = attrId.toLowerCase(Locale.ROOT);
- return dataMap.getOrDefault(attrId,"");
- }
-
- /**
- * 璁剧疆鍊煎埌map涓�
- * @param dataMap 鍊肩殑鏄犲皠鍐呭
- * @param attrId 灞炴�х殑缂栧彿
- * @param value 灞炴�х殑鍊�
- */
- private void setValueToMap(Map<String,String> dataMap,String attrId,String value){
- attrId = attrId.toLowerCase(Locale.ROOT);
- dataMap.put(attrId,value);
- }
- /**
- * 闆嗘垚鎵归噺鐢宠鏁版嵁
- * @param orderDTO 鍒嗙被鐨勪富閿�
- * @param dataObjectVO 鏁版嵁淇℃伅
- * @param resultDataObjectDetailDOs 閿欒淇℃伅
- * @return 鏈夐敊璇俊鎭殑excel
- */
- @Override
- public void batchSyncApplyCode(CodeOrderDTO orderDTO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs) {
- Map<String,String> errorMap=new HashMap<>();
- VciBaseUtil.alertNotNull(orderDTO,"缂栫爜鐢宠鐩稿叧鐨勬暟鎹�",orderDTO.getCodeClassifyOid(),"涓婚搴撳垎绫讳富閿�");
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
- //瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
- CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
- //1.鍒ゆ柇瑙勫垯涓櫎浜嗘祦姘寸爜娈碉紝鏄惁鏈夊叾浠栫爜娈�
- engineService.checkSecValueOnOrder(ruleVO,orderDTO);
- //鏌ヨ鍒嗙被鍜屾ā鏉�
- //鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
- List<RowDatas> rowDataList = dataObjectVO.getRowData();
- Map<String ,RowDatas>rowDataMap=new LinkedHashMap<>();
- rowDataList.stream().forEach(rowData->{
- rowDataMap.put(rowData.getRowIndex(),rowData);
- });
- //鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
- CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());
-
- //鏍￠獙妯℃澘鏄笉鏄渶鏂扮殑
- //checkTemplateSync(sheetDataSetList,templateVO);
- //闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
- List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->!MdmEngineConstant.DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormdisplayflag())
- ).collect(Collectors.toList());
- Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
- List<String> titleRowData = dataObjectVO.getColName();
- Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT),(o1, o2)->o2));
- getFieldIndexMap(titleRowData,attrNameIdMap,fieldIndexMap);
-
- //闇�瑕佸垽鏂槸鍚︽墍鏈夌殑灞炴�ч兘鍦ㄦā鏉夸笂浜�
- List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
- && StringUtils.isBlank(s.getComponentrule()) && StringUtils.isBlank(s.getClassifyinvokeattr())//缁勫悎瑙勫垯鍜屽垎绫绘敞鍏ョ‘瀹炴病缁欑敤鎴峰鍑哄幓
- ).collect(Collectors.toList());
- if(!CollectionUtils.isEmpty(unExistAttrVOs)){
- throw new VciBaseException("銆�" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "銆戣繖浜涘睘鎬у湪excel涓病鏈夋壘鍒�");
- }
- List<ClientBusinessObject> cboList = new ArrayList<>();
- String fullPath = getFullPath(classifyFullInfo);
-
- // List<CodeClassifyProcessTempVO> codeClassifyProcessTempVOS=codeClassifyProcessTempService.listProcessTemplate(templateVO.getOid(),"code_cls_flow_use_order");
- boolean isProcess=false;
- //娉ㄩ噴鎺夋澶勪笅闈㈡墍鏈夐兘鎸夌収涓嶅垽鏂祦绋嬪瓨鍌ㄧ姸鎬佷簡
- /** if(!CollectionUtils.isEmpty(codeClassifyProcessTempVOS)){
- isProcess=true;
- }***/
- Map<String,String> codeOidToSystemOidMap=new HashMap<>();//瀛樺偍缂栫爜鏁版嵁鍜岄泦鎴愮郴缁熸暟鎹畂id瀵圭収鏄犲皠
- excelToCbo(classifyFullInfo,titleRowData,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,isProcess,"create",errorMap,codeOidToSystemOidMap);
-
- //閮借浆鎹㈠畬浜嗐�傞渶瑕佹壒閲忔鏌�
- //濡傛灉鍑洪敊浜嗭紝鎴戜滑渚濈劧鎵ц鏈夋晥鐨勬暟鎹紝鏃犳晥鐨勬暟鎹啓鍥炲埌excel涓�
- //2.鍒ゆ柇蹇呰緭椤广�傘�傞渶瑕佸叏閮ㄧ殑灞炴�э紝濡傛灉鏄繀杈擄紝浣嗘槸琛ㄥ崟閲岄潰涓嶆樉绀虹殑锛屽彧鑳芥槸鍒嗙被娉ㄥ叆鎴栬�呯粍鍚堣鍒�
- batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);
-
-
- /**
- * 鍏抽敭鐔熸倝閿欒鎻愮ず
- */
- Map<String,String> errorKeyMap=new HashMap<>();
-
-
- //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->{
+ //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->{
/* //浼犲叆鏁版嵁涔嬮棿鍏抽敭灞炴�х殑鏍￠獙
RowDatas rowData= rowDataMap.get(rowIndex);
XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
@@ -3058,15 +1725,15 @@
resultDataObjectDetailDO.setMsg(errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�ч噸澶�");
resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
*/
- errorKeyMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";浼犲叆鐨勬暟鎹腑鍏抽敭灞炴�ч噸澶�");
- });
- }
- /****
- * 鍏抽敭灞炴�т笌绯荤粺涓噸澶嶇殑鍒ゆ柇
- */
- if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
- keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
- //浼犲叆鏁版嵁涔嬮棿鍏抽敭灞炴�х殑鏍￠獙
+ errorKeyMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";浼犲叆鐨勬暟鎹腑鍏抽敭灞炴�ч噸澶�");
+ });
+ }
+ /****
+ * 鍏抽敭灞炴�т笌绯荤粺涓噸澶嶇殑鍒ゆ柇
+ */
+ if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
+ keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
+ //浼犲叆鏁版嵁涔嬮棿鍏抽敭灞炴�х殑鏍￠獙
/* RowDatas rowData= rowDataMap.get(rowIndex);
XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
resultDataObjectDetailDO.setCode("");
@@ -3075,135 +1742,144 @@
resultDataObjectDetailDO.setMsg(errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
*/
- errorKeyMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
- });
- }
- //鍒嗙被娉ㄥ叆
- batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
- //boolean
- reSwitchBooleanAttrOnOrder(attrVOS,cboList);
- // cboList.stream().forEach(cbo->{
- //4.鏍￠獙瑙勫垯
- batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
- //5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
- batchSwitchEnumAttrOnOrder(attrVOS,cboList,errorMap);
- //6.鏃堕棿鏍煎紡鐨勯獙璇�
- //6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
- batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
- //7.澶勭悊鍙傜収鐨勬儏鍐�
- batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
- //鏍￠獙灞炴�ф槸鍚︽纭敊璇俊鎭�
- if(errorMap.size()>0){
- String[] newMsg = {""};
- cboList.stream().forEach(cbo -> {
- String rowIndex =cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- if(errorMap.containsKey(rowIndex)){
- String oid=cbo.getOid();
- String sourceOid=oid;
- if(codeOidToSystemOidMap.containsKey(oid)){
- sourceOid=codeOidToSystemOidMap.get(oid);
- }
- String code="";
- String errorid="103";
- String mes=errorMap.get(rowIndex);
- XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
- resultDataObjectDetailDO.setCode(code);
- resultDataObjectDetailDO.setId(sourceOid);
- resultDataObjectDetailDO.setErrorid(errorid);
- resultDataObjectDetailDO.setMsg(mes);
- resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
- }
- });
+ errorKeyMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍏抽敭灞炴�т笌绯荤粺涓殑閲嶅" );
+ });
+ }
+ //鍒嗙被娉ㄥ叆
+ batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
+ //boolean
+ reSwitchBooleanAttrOnOrder(attrVOS,cboList);
+ // cboList.stream().forEach(cbo->{
+ //4.鏍￠獙瑙勫垯
+ batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
+ //5.鏍￠獙鏋氫妇鏄惁姝ｇ‘
+ batchSwitchEnumAttrOnOrder(attrVOS,cboList,errorMap);
+ //6.鏃堕棿鏍煎紡鐨勯獙璇�
+ //6.鏃堕棿鐨勶紝蹇呴』缁熶竴涓簓yyy-MM-dd HH:mm:ss
+ batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
+ //7.澶勭悊鍙傜収鐨勬儏鍐�
+ batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
+ //鏍￠獙灞炴�ф槸鍚︽纭敊璇俊鎭�
+ if(errorMap.size()>0){
+ String[] newMsg = {""};
+ cboList.stream().forEach(cbo -> {
+ String rowIndex =cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ if(errorMap.containsKey(rowIndex)){
+ String oid=cbo.getOid();
+ String sourceOid=oid;
+ if(codeOidToSystemOidMap.containsKey(oid)){
+ sourceOid=codeOidToSystemOidMap.get(oid);
+ }
+ String code="";
+ String errorid="103";
+ String mes=errorMap.get(rowIndex);
+ XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+ resultDataObjectDetailDO.setCode(code);
+ resultDataObjectDetailDO.setId(sourceOid);
+ resultDataObjectDetailDO.setErrorid(errorid);
+ resultDataObjectDetailDO.setMsg(mes);
+ resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+ }
+ });
- }
+ }
- Map<String,String> newKeyMap=new HashedMap();
- if(errorKeyMap.size()>0 ) {
- errorKeyMap.keySet().forEach(key->{
- if(!errorMap.containsKey(key)){
- newKeyMap.put(key,errorKeyMap.get(key));
- }
- });
- if(newKeyMap.size()>0) {
- Set<ClientBusinessObject> editBoList = new HashSet<>();
- Map<String, List<ClientBusinessObject>> indexTodataMap = keyResultVO.getIndexTODataMap();
- cboList.stream().forEach(cbo -> {
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- if (indexTodataMap.containsKey(rowIndex)) {
- String oid = cbo.getOid();
- String sourceOid = oid;
- String code = "";
- String errorid = "201";
- if(codeOidToSystemOidMap.containsKey(oid)){
- sourceOid=codeOidToSystemOidMap.get(oid);
- }
- List<ClientBusinessObject> newCboList = indexTodataMap.get(rowIndex);
- if (!CollectionUtils.isEmpty(newCboList)) {
- ClientBusinessObject newCbo= newCboList.get(0);
- String lcstatus =newCbo.getAttributeValue("lcstatus");
- String newOid =newCbo.getAttributeValue("oid");
- String ts =newCbo.getAttributeValue("ts");
- code=newCbo.getAttributeValue("id");
- String lastmodifier=newCbo.getAttributeValue("lastmodifier");
- if (!lcstatus.equals(CodeDefaultLC.RELEASED.getValue())) {
- newCbo.setBusinessObject(cbo.getBusinessObject());
- newCbo.setOid(newOid);
- newCbo.setLastModifier(lastmodifier);
- newCbo.setId(code);
- newCbo.setTs(ts);
- cbo.setLastModifier(cbo.getLastModifier());
- editBoList.add(newCbo);
- }
- String mes = errorKeyMap.get(rowIndex);
- XMLResultDataObjectDetailDO resultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
- resultDataObjectDetailDO.setCode(code);
- resultDataObjectDetailDO.setId(sourceOid);
- resultDataObjectDetailDO.setErrorid(errorid);
- resultDataObjectDetailDO.setMsg(mes);
- resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
- }
- }
- });
- //鍏抽敭鐔熸倝鏇存敼
- if (!CollectionUtils.isEmpty(editBoList)) {
- BatchCBO batchCbos = new BatchCBO();
- batchCbos.setUpdateCbos(editBoList);
- this.boService.persistenceBatch(batchCbos);//鏇存敼鏁版嵁
- }
- errorMap.putAll(errorKeyMap);
- }
- }
+ Map<String,String> newKeyMap=new HashedMap();
+ if(errorKeyMap.size()>0 ) {
+ errorKeyMap.keySet().forEach(key->{
+ if(!errorMap.containsKey(key)){
+ newKeyMap.put(key,errorKeyMap.get(key));
+ }
+ });
+ if(newKeyMap.size()>0) {
+ List<BaseModel> editBoList = new ArrayList<>();
+ Map<String, List<BaseModel>> indexTodataMap = keyResultVO.getIndexTODataMap();
+ cboList.stream().forEach(cbo -> {
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ if (indexTodataMap.containsKey(rowIndex)) {
+ String oid = cbo.getOid();
+ String sourceOid = oid;
+ String code = "";
+ String errorid = "201";
+ if(codeOidToSystemOidMap.containsKey(oid)){
+ sourceOid=codeOidToSystemOidMap.get(oid);
+ }
+ List<BaseModel> newCboList = indexTodataMap.get(rowIndex);
+ if (!CollectionUtils.isEmpty(newCboList)) {
+ BaseModel newCbo= newCboList.get(0);
+ String lcstatus =newCbo.getLcStatus();
+ String newOid =newCbo.getOid();
+ Date ts =newCbo.getTs();
+ code=newCbo.getId();
+ String lastmodifier=newCbo.getLastModifier();
+ if (!lcstatus.equals(CodeDefaultLC.RELEASED.getValue())) {
+ newCbo.setOid(newOid);
+ newCbo.setLastModifier(lastmodifier);
+ newCbo.setId(code);
+ newCbo.setTs(ts);
+ cbo.setLastModifier(cbo.getLastModifier());
+ editBoList.add(newCbo);
+ }
+ String mes = errorKeyMap.get(rowIndex);
+ XMLResultDataObjectDetailDO resultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
+ resultDataObjectDetailDO.setCode(code);
+ resultDataObjectDetailDO.setId(sourceOid);
+ resultDataObjectDetailDO.setErrorid(errorid);
+ resultDataObjectDetailDO.setMsg(mes);
+ resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+ }
+ }
+ });
+ //鍏抽敭鐔熸倝鏇存敼
+ if (!CollectionUtils.isEmpty(editBoList)) {
+ engineService.updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmTypeId(),editBoList);//淇濆瓨鏁版嵁
+ }
+ errorMap.putAll(errorKeyMap);
+ }
+ }
- // });
- //鏈�鍚庡紕缁勫悎瑙勫垯
- batchSwitchComponentAttrOnOrder(attrVOS,cboList);
- //瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
- List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
- String rowIndex =cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- return !errorMap.containsKey(rowIndex);
- }).collect(Collectors.toList());
- List<String> needRowIndexList = new ArrayList<>();
- if(!CollectionUtils.isEmpty(needSaveCboList)) {
- //9.鎴戜滑澶勭悊涓氬姟鏁版嵁
- //鐢熸垚缂栫爜鐨勫唴瀹�
- try {
- productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(), needSaveCboList);
- //濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
- engineService.batchSaveSelectChar(templateVO, needSaveCboList);
- // if(!isProcess){
- needSaveCboList.stream().forEach(needSaveCbo->{
- XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
- resultDataObjectDetailDO.setCode(needSaveCbo.getId());
- String oid=needSaveCbo.getOid();
- String sourceOid=oid;
- if(codeOidToSystemOidMap.containsKey(oid)){
- sourceOid=codeOidToSystemOidMap.get(oid);
- }
- resultDataObjectDetailDO.setId(sourceOid);
- resultDataObjectDetailDO.setErrorid("0");
- resultDataObjectDetailDO.setMsg("鐢宠缂栫爜鎴愬姛");
- resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
- });
+ // });
+ //璁剧疆榛樿鍊�
+ batchSwitchAttrDefault(attrVOS, cboList);
+ //鏈�鍚庡紕缁勫悎瑙勫垯
+ batchSwitchComponentAttrOnOrder(attrVOS,cboList);
+ //瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
+ List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+ String rowIndex =cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ return !errorMap.containsKey(rowIndex);
+ }).collect(Collectors.toList());
+ List<String> needRowIndexList = new ArrayList<>();
+ if(!CollectionUtils.isEmpty(needSaveCboList)) {
+ //9.鎴戜滑澶勭悊涓氬姟鏁版嵁
+ //鐢熸垚缂栫爜鐨勫唴瀹�
+
+ List<String>allNeedSaveCboList=new ArrayList<>();
+ List<BaseModel> dataCBOList=new ArrayList<>();
+ needSaveCboList.stream().forEach(clientBusinessObject -> {
+ BaseModel baseModel=new BaseModel();
+ BeanUtil.convert(clientBusinessObject,baseModel);
+ //(VciBaseUtil.objectToMapString(clientBusinessObject));
+ dataCBOList.add(baseModel);
+ allNeedSaveCboList.add(baseModel.getOid());
+ });
+ try {
+ productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(), dataCBOList);
+ //濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
+ engineService.batchSaveSelectChar(templateVO, dataCBOList);
+ // if(!isProcess){
+ needSaveCboList.stream().forEach(needSaveCbo->{
+ XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+ resultDataObjectDetailDO.setCode(needSaveCbo.getId());
+ String oid=needSaveCbo.getOid();
+ String sourceOid=oid;
+ if(codeOidToSystemOidMap.containsKey(oid)){
+ sourceOid=codeOidToSystemOidMap.get(oid);
+ }
+ resultDataObjectDetailDO.setId(sourceOid);
+ resultDataObjectDetailDO.setErrorid("0");
+ resultDataObjectDetailDO.setMsg("鐢宠缂栫爜鎴愬姛");
+ resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+ });
/* }else{
needSaveCboList.stream().forEach(needSaveCbo->{
XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
@@ -3220,797 +1896,2163 @@
});
}*/
- }catch (Throwable e){
- e.printStackTrace();
- needSaveCboList.stream().forEach(needSaveCbo->{
- XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
- resultDataObjectDetailDO.setCode("");
- String oid=needSaveCbo.getOid();
- String sourceOid=oid;
- if(codeOidToSystemOidMap.containsKey(oid)){
- sourceOid=codeOidToSystemOidMap.get(oid);
- }
- resultDataObjectDetailDO.setId(sourceOid);
- resultDataObjectDetailDO.setErrorid("1");
- resultDataObjectDetailDO.setMsg("淇濆瓨鍑虹幇闂:"+e.getMessage());
- resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
- });
+ }catch (Throwable e){
+ e.printStackTrace();
+ needSaveCboList.stream().forEach(needSaveCbo->{
+ XMLResultDataObjectDetailDO resultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+ resultDataObjectDetailDO.setCode("");
+ String oid=needSaveCbo.getOid();
+ String sourceOid=oid;
+ if(codeOidToSystemOidMap.containsKey(oid)){
+ sourceOid=codeOidToSystemOidMap.get(oid);
+ }
+ resultDataObjectDetailDO.setId(sourceOid);
+ resultDataObjectDetailDO.setErrorid("1");
+ resultDataObjectDetailDO.setMsg("淇濆瓨鍑虹幇闂:"+e.getMessage());
+ resultDataObjectDetailDOs.add(resultDataObjectDetailDO);
+ });
- }
- }
- }
+ }
+ }
- /***
- * 闆嗘垚鎵归噺鍚屾鏇存柊鎺ュ彛
- * @param codeClassifyVO;
- * @param dataObjectVO 鏁版嵁淇℃伅
- * @param resultDataObjectDetailDOs 閿欒淇℃伅
- */
- @Override
- public void batchSyncEditDatas(CodeClassifyVO codeClassifyVO,DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs) {
- String errorid="";
- String msg="";
- //鏌ヨ鍒嗙被鍜屾ā鏉�
- //鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
- List<RowDatas> rowDataList = dataObjectVO.getRowData();
- Map<String, RowDatas> rowDataMap = new LinkedHashMap<>();
- Map<String, RowDatas> codeDataMap = new LinkedHashMap<>();
- rowDataList.stream().forEach(rowData -> {
- rowDataMap.put(rowData.getRowIndex(), rowData);
- codeDataMap.put(rowData.getCode(), rowData);
- });
- //鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
- CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
- // 搴旇閮芥槸涓�涓垎绫讳笅鐨勪笟鍔℃暟鎹紝鎵剧涓�鏉＄殑灏辫
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
- //鏍￠獙妯℃澘鏄笉鏄渶鏂扮殑
- //checkTemplateSync(sheetDataSetList,templateVO);
- //闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
- List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !MdmEngineConstant.DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormdisplayflag())
- ).collect(Collectors.toList());
- Map<Integer/**鍒楀彿**/, String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
- List<String> titleRowData = dataObjectVO.getColName();
- Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT), (o1, o2) -> o2));
- getFieldIndexMap(titleRowData, attrNameIdMap, fieldIndexMap);
- Map<String, String> cboOidMap = new HashMap<>();
- cboOidMap.put("id", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(codeDataMap.keySet().toArray(new String[0])) + ")");
- List<ClientBusinessObject> cboList = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), cboOidMap);
- Map<String, ClientBusinessObject> codeSystemObjectMap = cboList.stream().filter(systeDataObject -> systeDataObject != null && StringUtils.isNotBlank(systeDataObject.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
- Map<String, String> errorMap = new HashMap<>();
- List<CodeOrderDTO> codeOrderDTOList = new ArrayList<>();
- this.getCodeOrderDTOs(codeClassifyVO, templateVO, codeDataMap, codeSystemObjectMap, codeOrderDTOList, errorMap);
- // List<CodeClassifyProcessTempVO> codeClassifyProcessTempVOS=codeClassifyProcessTempService.listProcessTemplate(templateVO.getOid(),"code_cls_flow_use_order");
- boolean isProcess=false;
- /** if(!CollectionUtils.isEmpty(codeClassifyProcessTempVOS)){
- isProcess=true;
- }**/
+ }
+ /***
+ * 闆嗘垚鎵归噺鍚屾鏇存柊鎺ュ彛
+ * @param codeClassifyVO;
+ * @param dataObjectVO 鏁版嵁淇℃伅
+ * @param resultDataObjectDetailDOs 閿欒淇℃伅
+ */
+ @Transactional(rollbackFor = VciBaseException.class)
+ @Override
+ public void batchSyncEditDatas(CodeClassifyVO codeClassifyVO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs) {
+ String errorid="";
+ String msg="";
+ //鏌ヨ鍒嗙被鍜屾ā鏉�
+ //鍏堟壘鍒版瘡涓�琛岀殑鏍囬锛岀劧鍚庢牴鎹爣棰樻潵鑾峰彇瀵瑰簲鐨勫睘鎬�
+ List<RowDatas> rowDataList = dataObjectVO.getRowData();
+ Map<String, RowDatas> rowDataMap = new LinkedHashMap<>();
+ Map<String, RowDatas> codeDataMap = new LinkedHashMap<>();
+ rowDataList.stream().forEach(rowData -> {
+ rowDataMap.put(rowData.getRowIndex(), rowData);
+ codeDataMap.put(rowData.getCode(), rowData);
+ });
+ //鎵剧涓�琛岋紝涓轰簡鎵炬爣棰�
+ CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyVO.getOid());
+ // 搴旇閮芥槸涓�涓垎绫讳笅鐨勪笟鍔℃暟鎹紝鎵剧涓�鏉＄殑灏辫
+ CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyVO.getOid());
+ //鏍￠獙妯℃澘鏄笉鏄渶鏂扮殑
+ //checkTemplateSync(sheetDataSetList,templateVO);
+ //闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
+ List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s -> !DEFAULT_SYNC_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormDisplayFlag())
+ ).collect(Collectors.toList());
+ Map<Integer/**鍒楀彿**/, String/**瀛楁鐨勫悕绉�**/> fieldIndexMap = new HashMap<>();
+ List<String> titleRowData = dataObjectVO.getColName();
+ Map<String/**涓枃鍚嶇О**/, String/**鑻辨枃鍚嶇О**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT), (o1, o2) -> o2));
+ getFieldIndexMap(titleRowData, attrNameIdMap, fieldIndexMap);
+ Map<String, String> cboOidMap = new HashMap<>();
+ cboOidMap.put("id", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(codeDataMap.keySet().toArray(new String[0])) + ")");
+ String tableName ="";
+ try {
+ R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(templateVO.getBtmTypeId());
+ if(r.getCode()!=200) {
+ throw new Throwable(r.getMsg());
+ }
+ BtmTypeVO btmTypeVO = r.getData();
+ if (btmTypeVO == null) {
+ throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷瀵硅薄锛�");
+ }
+ tableName = btmTypeVO.getTableName();
+ if (StringUtils.isBlank(tableName)) {
+ throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷鐩稿叧鑱旂殑琛�");
+ }
+ }catch (Throwable e){
+ log.error("鏌ヨ涓氬姟瀵硅薄琛�"+e);
+ XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+ xmlResultDataObjectDetailDO.setErrorid("103");
+ xmlResultDataObjectDetailDO.setMsg("鏌ヨ涓氬姟瀵硅薄琛�"+e);
+ xmlResultDataObjectDetailDO.setId("");
+ xmlResultDataObjectDetailDO.setCode("");
+ resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
+ return;
+ }
- Map<String, CodeOrderDTO> orderDTOMap = codeOrderDTOList.stream().filter(orderDTO -> orderDTO != null && StringUtils.isNotBlank(orderDTO.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
- List<ClientBusinessObject> updateList = new ArrayList<>();
- List<ClientBusinessObject> deleteList = new ArrayList<>();
+ StringBuffer sb=new StringBuffer();
+ sb.append(" select * from ");
+ sb.append(tableName);
+ sb.append(" where 1=1 ");
+ sb.append(" id in (");
+ sb.append(VciBaseUtil.toInSql(codeDataMap.keySet().toArray(new String[0])));
+ sb.append(")");
+ List<Map<String,String>> dataMapList=commonsMapper.queryByOnlySqlForMap(sb.toString());
+ List<ClientBusinessObject> cboList= ChangeMapTOClientBusinessObjects(dataMapList);
+ Map<String, ClientBusinessObject> codeSystemObjectMap = cboList.stream().filter(systeDataObject -> systeDataObject != null && StringUtils.isNotBlank(systeDataObject.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
+ Map<String, String> errorMap = new HashMap<>();
+ List<CodeOrderDTO> codeOrderDTOList = new ArrayList<>();
+ this.getCodeOrderDTOs(codeClassifyVO, templateVO, codeDataMap, codeSystemObjectMap, codeOrderDTOList, errorMap);
+ // List<CodeClassifyProcessTempVO> codeClassifyProcessTempVOS=codeClassifyProcessTempService.listProcessTemplate(templateVO.getOid(),"code_cls_flow_use_order");
+ boolean isProcess=false;
+ /** if(!CollectionUtils.isEmpty(codeClassifyProcessTempVOS)){
+ isProcess=true;
+ }**/
- BatchCBO batchCBO = new BatchCBO();
- CodeClassifyTemplateVO firstTemplateVO = templateService.getObjectHasAttrByOid(orderDTOMap.values().stream().findFirst().get().getTemplateOid());
- Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
- // boolean finalIsProcess = isProcess;
- orderDTOMap.keySet().stream().forEach(code -> {
- CodeOrderDTO orderDTO = orderDTOMap.get(code);
- ClientBusinessObject cbo = cboMap.get(code);
- String dataStatus=cbo.getLcStatus();
- RowDatas rowData=codeDataMap.get(code);
- String status=rowData.getStatus();
- String operation=rowData.getOperation();
- if (!cbo.getTs().contains(VciDateUtil.date2Str(orderDTO.getTs(), VciDateUtil.DateTimeFormat))) {
- // throw new VciBaseException("鏁版嵁涓嶆槸鏈�鏂扮殑锛屽彲鑳戒粬浜哄凡缁忎慨鏀癸紝璇峰埛鏂板悗鍐嶈瘯");
- errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";鏁版嵁涓嶆槸鏈�鏂扮殑锛屽彲鑳戒粬浜哄凡缁忎慨鏀癸紝璇峰埛鏂板悗鍐嶈瘯");
- }
+ Map<String, CodeOrderDTO> orderDTOMap = codeOrderDTOList.stream().filter(orderDTO -> orderDTO != null && StringUtils.isNotBlank(orderDTO.getId())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
+ List<BaseModel> updateList = new ArrayList<>();
+ List<CodeAllCode> codeAllCodeList = new ArrayList<>();
+ List<String> deleteList = new ArrayList<>();
+
+ CodeClassifyTemplateVO firstTemplateVO = templateService.getObjectHasAttrByOid(orderDTOMap.values().stream().findFirst().get().getTemplateOid());
+ Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getId(), t -> t));
+ // boolean finalIsProcess = isProcess;
+ orderDTOMap.keySet().stream().forEach(code -> {
+ CodeOrderDTO orderDTO = orderDTOMap.get(code);
+ ClientBusinessObject cbo = cboMap.get(code);
+ String dataStatus=cbo.getLcStatus();
+ RowDatas rowData=codeDataMap.get(code);
+ String status=rowData.getStatus();
+ String operation=rowData.getOperation();
+ if (cbo.getTs().compareTo(orderDTO.getTs())==0?true:false) {
+ // throw new VciBaseException("鏁版嵁涓嶆槸鏈�鏂扮殑锛屽彲鑳戒粬浜哄凡缁忎慨鏀癸紝璇峰埛鏂板悗鍐嶈瘯");
+ errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";鏁版嵁涓嶆槸鏈�鏂扮殑锛屽彲鑳戒粬浜哄凡缁忎慨鏀癸紝璇峰埛鏂板悗鍐嶈瘯");
+ }
/* if (!CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(cbo.getLcStatus()) && !orderDTO.isEditInProcess()) {
throw new VciBaseException("鏁版嵁涓嶆槸{0}鐨勭姸鎬侊紝涓嶅厑璁镐慨鏀�", new String[]{CodeDefaultLC.EDITING.getText()});
}*/
- if(operation.equals("update")) {
- //1. 鍒ゆ柇蹇呰緭椤�
- checkRequiredAttrOnOrder(templateVO, orderDTO, errorMap);
- //2.鍏堟敞鍏ワ紝鍐嶇粍鍚堬紝鏈�鍚庢牎楠�
- switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO, errorMap);
- //3.澶勭悊缁勫悎瑙勫垯銆傜粍鍚堣鍒欎笉鑳戒娇鐢ㄧ紪鐮佺殑灞炴�э紝鍥犱负缂栫爜鐨勭敓鎴愬彲鑳芥槸闇�瑕佸睘鎬х殑
- switchComponentAttrOnOrder(templateVO, orderDTO);
- //4.鏍￠獙瑙勫垯
- checkVerifyOnOrder(templateVO, orderDTO, errorMap);
- //5.鍒ゆ柇鍏抽敭灞炴��
- checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO, errorMap);
- //6.鏍￠獙鏋氫妇鐨勫唴瀹规槸鍚︽纭�
- checkEnumOnOrder(templateVO, orderDTO, errorMap);
- //7.澶勭悊鏃堕棿鏍煎紡锛屽湪鏁版嵁搴撻噷闈笉璁烘槸瀛楃涓茶繕鏄棩鏈熸牸寮忥紝閮戒娇鐢ㄧ浉鍚岀殑鏍煎紡瀛樺偍
- switchDateAttrOnOrder(templateVO, orderDTO);
- //榛樿鐨勫唴瀹逛笉鑳藉彉锛屾墍浠ュ彧闇�瑕佹嫹璐濊嚜瀹氫箟鐨勭浉鍏冲睘鎬у嵆鍙�
- copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true, errorMap);
- //浼佷笟鐮佸拰闆嗗洟鐮佺殑涓嶄慨鏀�
- cbo.setDescription(orderDTO.getDescription());
- cbo.setName(orderDTO.getName());
- try {
- cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
- cbo.setAttributeValue("name", orderDTO.getName());
- // if(finalIsProcess){//鍦ㄦ祦绋嬩腑涓嶅厑璁告洿鏀�
- // errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";鏁版嵁"+code+"鍦ㄦ祦绋嬩腑锛屼笉鍏佽鏇存敼!"));
- // }else{
- cbo.setLcStatus(status);
- cbo.setAttributeValue("lcstatus",status);
- // }
- } catch (VCIError e) {
- e.printStackTrace();
- }
- updateList.add(cbo);
- }else if(operation.equals("delete")){//濡傛灉鍦ㄦ祦绋嬩腑涓嶅厑璁稿垹闄わ紝涓嶅湪娴佺▼涓姸鎬佷负鍙戝竷鎴栬�呭仠鐢ㄧ殑鏁版嵁涓嶅厑璁稿垹闄わ紝灏嗗叾鏇存敼涓哄仠鐢紝鍏朵粬鐨勬儏鍐电洿鎺ュ垹闄�
- // if(finalIsProcess){
- // errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";鏁版嵁"+code+"鍦ㄦ祦绋嬩腑锛屼笉鍏佽鍒犻櫎!"));
- //}else {
- try {
- Map<String, String> condtionMap = new HashMap<>();
- condtionMap.put("createcodeoid", cbo.getOid());
- logger.info("oid:" + cbo.getOid());
- List<ClientBusinessObject> codeCbos = boService.queryCBO("codeallcode", condtionMap);
- logger.info("codeCbos size:" + codeCbos.size());
- if (!CollectionUtils.isEmpty(codeCbos)) {
- ClientBusinessObject codeCbo = codeCbos.get(0);
- logger.info("codeCbos code:" + codeCbo.getId());
- codeCbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
- codeCbo.setAttributeValue("lcstatus", CodeDefaultLC.TASK_BACK.getValue());
- updateList.add(codeCbo);
- }
- deleteList.add(cbo);
- }catch (VCIError e) {
- e.printStackTrace();
- }
- // }
- }else if(operation.equals("editstatus")){
- try {
- // if (finalIsProcess) {
- // errorMap.put(code, errorMap.getOrDefault(code, errorMap.getOrDefault(code, "") + ";鏁版嵁" + code + "鍦ㄦ祦绋嬩腑锛屼笉鍏佽鏇存敼鐘舵��!"));
- // } else {
- cbo.setLcStatus(status);
- cbo.setAttributeValue("lcstatus", status);
- updateList.add(cbo);
- // }
- }catch (VCIError e) {
- e.printStackTrace();
- }
- }
- });
- /**
- * 閿欒淇℃伅杈撳嚭
- */
- if(errorMap.size()>0){
- errorMap.keySet().forEach(code->{
- if(codeDataMap.containsKey(code)){
- RowDatas rowDatas= codeDataMap.get(code);
- String dataMsg=errorMap.get(code);
- String oid=rowDatas.getOid();
- XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
- xmlResultDataObjectDetailDO.setErrorid("103");
- xmlResultDataObjectDetailDO.setMsg(dataMsg);
- xmlResultDataObjectDetailDO.setId(oid);
- xmlResultDataObjectDetailDO.setCode(code);
- resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
- }
- });
- }else {
- //瀛樺偍鏁版嵁
- try {
- batchCBO.getUpdateCbos().addAll(updateList);
- batchCBO.getDeleteCbos().addAll(deleteList);
- boService.persistenceBatch(batchCBO);
- engineService.batchSaveSelectChar(firstTemplateVO, updateList);
- errorid="0";
- msg="鏇存柊/鐘舵�佹洿鏀�/鍒犻櫎鎴愬姛锛�";
- }catch (Throwable e){
- errorid="1";
- msg="淇濆瓨澶辫触锛�"+e;
- }finally {
- String finalMsg = msg;
- String finalErrorid = errorid;
- cboList.stream().forEach(cbo->{
- String code =cbo.getId();
- if(codeDataMap.containsKey(code)) {
- RowDatas rowDatas=codeDataMap.get(code);
- String oid=rowDatas.getOid();
- XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
- xmlResultDataObjectDetailDO.setErrorid(finalErrorid);
- xmlResultDataObjectDetailDO.setMsg(finalMsg);
- xmlResultDataObjectDetailDO.setId(oid);
- xmlResultDataObjectDetailDO.setCode(code);
- resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
- }
- });
+ if(operation.equals("update")) {
+ //1. 鍒ゆ柇蹇呰緭椤�
+ checkRequiredAttrOnOrder(templateVO, orderDTO, errorMap);
+ //2.鍏堟敞鍏ワ紝鍐嶇粍鍚堬紝鏈�鍚庢牎楠�
+ switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO, errorMap);
+ //3.澶勭悊缁勫悎瑙勫垯銆傜粍鍚堣鍒欎笉鑳戒娇鐢ㄧ紪鐮佺殑灞炴�э紝鍥犱负缂栫爜鐨勭敓鎴愬彲鑳芥槸闇�瑕佸睘鎬х殑
+ switchComponentAttrOnOrder(templateVO, orderDTO);
+ //4.鏍￠獙瑙勫垯
+ checkVerifyOnOrder(templateVO, orderDTO, errorMap);
+ //5.鍒ゆ柇鍏抽敭灞炴��
+ checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO, errorMap);
+ //6.鏍￠獙鏋氫妇鐨勫唴瀹规槸鍚︽纭�
+ checkEnumOnOrder(templateVO, orderDTO, errorMap);
+ //7.澶勭悊鏃堕棿鏍煎紡锛屽湪鏁版嵁搴撻噷闈笉璁烘槸瀛楃涓茶繕鏄棩鏈熸牸寮忥紝閮戒娇鐢ㄧ浉鍚岀殑鏍煎紡瀛樺偍
+ switchDateAttrOnOrder(templateVO, orderDTO);
+ //榛樿鐨勫唴瀹逛笉鑳藉彉锛屾墍浠ュ彧闇�瑕佹嫹璐濊嚜瀹氫箟鐨勭浉鍏冲睘鎬у嵆鍙�
+ copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true, errorMap);
+ //浼佷笟鐮佸拰闆嗗洟鐮佺殑涓嶄慨鏀�
+ cbo.setDescription(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription());
+ cbo.setName(orderDTO.getName());
+ try {
+ cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
+ cbo.setAttributeValue("name", orderDTO.getName());
+ // if(finalIsProcess){//鍦ㄦ祦绋嬩腑涓嶅厑璁告洿鏀�
+ // errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";鏁版嵁"+code+"鍦ㄦ祦绋嬩腑锛屼笉鍏佽鏇存敼!"));
+ // }else{
+ cbo.setLcStatus(status);
+ cbo.setAttributeValue("lcstatus",status);
+ // }
+ } catch (VciBaseException e) {
+ e.printStackTrace();
+ }
- }
- }
- }
+ List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
+ if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
+ CodeAllCode codeCbo = codeAllCodeList.get(0);
+ log.info("codeCbos code:" + codeCbo.getId());
+ codeCbo.setLcStatus(status);
+ codeAllCodeList.add(codeCbo);
+ }
- /***
- * 浠庣紦瀛橀噷鑾峰彇鍒伴渶瑕佸鍏ョ殑鐩稿叧鏁版嵁
- * @param codeClssifyOid
- * @param redisOid
- * @return
- */
- @Override
- public DataGrid<Map<String, String>> gridDatas(String codeClssifyOid, String redisOid) {
- VciBaseUtil.alertNotNull(redisOid,"瀵煎叆鐩镐技鏁版嵁",redisOid,"鏁版嵁缂撳瓨涓婚敭");
- List<CodeImprotDataVO> codeImprotDataVOs = redisService.getCacheList(redisOid+"-"+codeClssifyOid);
- CodeImprotDataVO codeImprotDataVO=new CodeImprotDataVO();
- if(!CollectionUtils.isEmpty(codeImprotDataVOs)){
- if(StringUtils.isNotBlank(codeClssifyOid)){
- Map<String/**鍒嗙被鍚嶇О**/, CodeImprotDataVO/**鑻辨枃鍚嶇О**/> codeClassifyDatasMap = codeImprotDataVOs.stream().collect(Collectors.toMap(s -> s.getCodeClassifyOid(), t -> t,(o1, o2)->o2));
- if(codeClassifyDatasMap.containsKey(codeClssifyOid)){
- codeImprotDataVO= codeClassifyDatasMap.get(codeClssifyOid);
- }else{
- codeImprotDataVO= codeImprotDataVOs.get(0);
- }
- }
- }
- DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
- List<Map<String, String>> dataList = new ArrayList<>();
- if(codeImprotDataVO!=null){
- dataList= codeImprotDataVO.getDatas();
- }
- dataGrid.setData(dataList);
- if (!CollectionUtils.isEmpty(dataList)) {
- dataGrid.setTotal(dataList.size());
- }
- return dataGrid;
- }
+ BaseModel baseModel=new BaseModel();
+ BeanUtil.convert(cbo,baseModel);
+ //baseModel.setData(VciBaseUtil.objectToMapString(cbo));
+ updateList.add(baseModel);
+ }else if(operation.equals("delete")){//濡傛灉鍦ㄦ祦绋嬩腑涓嶅厑璁稿垹闄わ紝涓嶅湪娴佺▼涓姸鎬佷负鍙戝竷鎴栬�呭仠鐢ㄧ殑鏁版嵁涓嶅厑璁稿垹闄わ紝灏嗗叾鏇存敼涓哄仠鐢紝鍏朵粬鐨勬儏鍐电洿鎺ュ垹闄�
+ // if(finalIsProcess){
+ // errorMap.put(code,errorMap.getOrDefault(code, errorMap.getOrDefault(code,"")+";鏁版嵁"+code+"鍦ㄦ祦绋嬩腑锛屼笉鍏佽鍒犻櫎!"));
+ //}else {
+ try {
+ log.info("oid:" + cbo.getOid());
+ List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
+ log.info("codeCbos size:" + newCodeAllCodeList.size());
+ if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
+ CodeAllCode codeCbo = codeAllCodeList.get(0);
+ log.info("codeCbos code:" + codeCbo.getId());
+ codeCbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
+ codeAllCodeList.add(codeCbo);
+ }
+ deleteList.add(cbo.getOid());
+ }catch (VciBaseException e) {
+ e.printStackTrace();
+ }
+ // }
+ }else if(operation.equals("editstatus")){
+ try {
+ // if (finalIsProcess) {
+ // errorMap.put(code, errorMap.getOrDefault(code, errorMap.getOrDefault(code, "") + ";鏁版嵁" + code + "鍦ㄦ祦绋嬩腑锛屼笉鍏佽鏇存敼鐘舵��!"));
+ // } else {
+ cbo.setLcStatus(status);
+ cbo.setAttributeValue("lcstatus", status);
- /**
- *
- * @param oid
- * @param redisOid
- * @return
- */
- @Override
- public DataGrid<Map<String,String>> gridRowResemble(String oid,String redisOid){
- VciBaseUtil.alertNotNull(redisOid,"瀵煎叆鐩镐技鏁版嵁",redisOid,"鏁版嵁缂撳瓨涓婚敭");
- List<DataResembleVO> codeImprotDataVOs = redisService.getCacheList(redisOid);
- DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
- List<Map<String, String>> dataList = new ArrayList<>();
+ // }
- if(!CollectionUtils.isEmpty(codeImprotDataVOs)){
- Map<String/**鍒嗙被鍚嶇О**/, DataResembleVO/**鏁版嵁瀵硅薄**/> rowResembleDataMap = codeImprotDataVOs.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t,(o1, o2)->o2));
- if(rowResembleDataMap.containsKey(oid)){
- DataResembleVO dataResembleVO= rowResembleDataMap.get(oid);
- dataList= dataResembleVO.getDataList();
- }
- }
+ List<CodeAllCode>newCodeAllCodeList= codeAllCodeService.selectByWrapper(Wrappers.<CodeAllCode>query().lambda().eq(CodeAllCode::getCreateCodeOid, cbo.getOid()));
+ if (!CollectionUtils.isEmpty(newCodeAllCodeList)) {
+ CodeAllCode codeCbo = codeAllCodeList.get(0);
+ log.info("codeCbos code:" + codeCbo.getId());
+ codeCbo.setLcStatus(status);
+ codeAllCodeList.add(codeCbo);
+ }
- dataGrid.setData(dataList);
- if (!CollectionUtils.isEmpty(dataList)) {
- dataGrid.setTotal(dataList.size());
- }
- return dataGrid;
- }
- @Override
- public List<CodeImportTemplateVO> gridclassifys(String redisOid) {
- List<CodeImportTemplateVO> codeImportTemplateVOs=new ArrayList<>();
- VciBaseUtil.alertNotNull(redisOid,"鍒嗙被",redisOid,"鍒嗙被缂撳瓨涓婚敭");
- List<CodeImportTemplateVO> redisServiceCacheObjects=redisService.getCacheList(redisOid);
- if(redisServiceCacheObjects!=null){
- codeImportTemplateVOs= redisServiceCacheObjects;
- }
- return codeImportTemplateVOs;
- }
+ BaseModel baseModel=new BaseModel();
+ BeanUtil.convert(cbo,baseModel);
+ //baseModel.setData(VciBaseUtil.objectToMapString(cbo));
+ updateList.add(baseModel);
+ }catch (VciBaseException e) {
+ e.printStackTrace();
+ }
+ }
+ });
+ /**
+ * 閿欒淇℃伅杈撳嚭
+ */
+ if(errorMap.size()>0){
+ errorMap.keySet().forEach(code->{
+ if(codeDataMap.containsKey(code)){
+ RowDatas rowDatas= codeDataMap.get(code);
+ String dataMsg=errorMap.get(code);
+ String oid=rowDatas.getOid();
+ XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO=new XMLResultDataObjectDetailDO();
+ xmlResultDataObjectDetailDO.setErrorid("103");
+ xmlResultDataObjectDetailDO.setMsg(dataMsg);
+ xmlResultDataObjectDetailDO.setId(oid);
+ xmlResultDataObjectDetailDO.setCode(code);
+ resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
+ }
+ });
+ }else {
+ //瀛樺偍鏁版嵁
+ try {
+ engineService.updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmTypeId(),updateList);
+ codeAllCodeService.saveBatch(codeAllCodeList);
+ if(deleteList.size()>0) {
+ commonsMapper.deleteByTaleAndOid(tableName, VciBaseUtil.array2String(deleteList.toArray(new String[]{})));
+ }
+ errorid="0";
+ msg="鏇存柊/鐘舵�佹洿鏀�/鍒犻櫎鎴愬姛锛�";
+ }catch (Throwable e){
+ errorid="1";
+ msg="淇濆瓨澶辫触锛�"+e;
+ }finally {
+ String finalMsg = msg;
+ String finalErrorid = errorid;
+ cboList.stream().forEach(cbo->{
+ String code =cbo.getId();
+ if(codeDataMap.containsKey(code)) {
+ RowDatas rowDatas=codeDataMap.get(code);
+ String oid=rowDatas.getOid();
+ XMLResultDataObjectDetailDO xmlResultDataObjectDetailDO = new XMLResultDataObjectDetailDO();
+ xmlResultDataObjectDetailDO.setErrorid(finalErrorid);
+ xmlResultDataObjectDetailDO.setMsg(finalMsg);
+ xmlResultDataObjectDetailDO.setId(oid);
+ xmlResultDataObjectDetailDO.setCode(code);
+ resultDataObjectDetailDOs.add(xmlResultDataObjectDetailDO);
+ }
+ });
- @Override
- public BaseResult batchImportData(List<CodeImprotSaveDatVO> codeImprotSaveDatVOList,String classifyAttr, boolean isImprot) {
- List<SheetRowData> rowDataList = new ArrayList<>();
- List<ClientBusinessObject> allNeedSaveCboList=new ArrayList<>();
- codeImprotSaveDatVOList.stream().forEach(codeImprotSaveDatVO -> {
- List<ClientBusinessObject>cboList=new ArrayList<>();
- List<String> colList=codeImprotSaveDatVO.getClos();
- CodeOrderDTO orderDTO= codeImprotSaveDatVO.getOrderDTO();
+ }
+ }
+ }
+ /**
+ * 鏍￠獙灞炴�ф槸鍚︿负蹇呰緭
+ *
+ * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬�
+ * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
+ */
+ private void checkRequiredAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+ Map<String, CodeClassifyTemplateAttrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(
+ s -> VciBaseUtil.getBoolean(s.getRequireFlag()) && StringUtils.isBlank(s.getComponentRule())
+ && StringUtils.isBlank(s.getClassifyInvokeAttr()))
+ .collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if (!CollectionUtils.isEmpty(requiredAttrMap)) {
+ requiredAttrMap.forEach((attrId, attrVO) -> {
+ //鍙湁浼佷笟缂栫爜锛岀姸鎬侊紝澶囨敞锛屾ā鏉夸富閿紝鍒嗙被涓婚敭杩欏嚑涓槸鍥哄畾鐨勶紝鍏朵綑閮芥槸鑷閰嶇疆鐨�
+ if (StringUtils.isBlank(getValueFromOrderDTO(orderDTO, attrId))) {
+ errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"") + ";灞炴�с�恵"+attrVO.getName()+"}銆戝繀椤昏杈撳叆(閫夋嫨)鍐呭" );
+ // throw new VciBaseException("灞炴�с�恵0}銆戝繀椤昏杈撳叆(閫夋嫨)鍐呭", new String[]{attrVO.getName()});
+ }
+ });
+ }
+ }
+ /**
+ * 杞崲缁勫悎瑙勫垯鐨勫��
+ *
+ * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬�
+ * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
+ */
+ private void switchComponentAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
+ Map<String, CodeClassifyTemplateAttrVO> compAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getComponentRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if (!CollectionUtils.isEmpty(compAttrVOMap)) {
+ Map<String, String> dataMap = WebUtil.objectToMapString(orderDTO);
- 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)){
- 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());
+ Map<String, String> dataLowMap = new HashMap<>();
+ if (!CollectionUtils.isEmpty(dataMap)) {
+ dataMap.forEach((key, value) -> {
+ dataLowMap.put(key.toLowerCase(Locale.ROOT), value);
+ });
+ }
+ dataLowMap.putAll(orderDTO.getData());
+ compAttrVOMap.forEach((attrId, attrVO) -> {
+ dataLowMap.put(attrId, formulaService.getValueByFormula(dataLowMap, attrVO.getComponentRule()));
+ });
+ dataLowMap.forEach((key, value) -> {
+ setValueToOrderDTO(orderDTO, key, value);
+ });
+ }
+ }
- // CodeClassifyTemplateVO codeClassifyTemplateVO= engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());
- CodeClassifyTemplateVO codeClassifyTemplateVO= templateServiceI.getObjectHasAttrByOid(orderDTO.getTemplateOid());
- //瑙勫垯鐨勪富閿渶瑕佸幓鑾峰彇
- CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
- //闄ゅ幓榛樿鐨勫睘鎬�.杩樻湁鍙湁琛ㄥ崟鏄剧ず鐨勫瓧娈垫墠瀵煎叆
- List<CodeClassifyTemplateAttrVO> attrVOS = codeClassifyTemplateVO.getAttributes().stream().filter(s ->
- !MdmEngineConstant.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);
- //鏈�鍚庡紕缁勫悎瑙勫垯
- 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);
+ /**
+ * 鏍￠獙姝ｅ垯琛ㄨ揪寮忔槸鍚︽纭�
+ *
+ * @param templateVO 妯℃澘鐨勪俊鎭紝蹇呴』鍖呭惈灞炴�х殑鍐呭
+ * @param orderDTO 缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅
+ */
+ private void checkVerifyOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+ Map<String, CodeClassifyTemplateAttrVO> verifyAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getVerifyRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if (!CollectionUtils.isEmpty(verifyAttrVOMap)) {
+ verifyAttrVOMap.forEach((attrId, attrVO) -> {
+ String value = getValueFromOrderDTO(orderDTO, attrId);
+ if (StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyRule())) {
+ errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";灞炴�"+attrVO.getName()+"]鐨勫�间笉绗﹀悎鏍￠獙瑙勫垯鐨勮姹�");
+ //鏍￠獙姝ｅ垯琛ㄨ揪寮�
+ // throw new VciBaseException("灞炴�{0}]鐨勫�间笉绗﹀悎鏍￠獙瑙勫垯鐨勮姹�", new String[]{attrVO.getName()});
+ }
+ });
+ }
+ }
+ /**
+ * 鏍￠獙鍏抽敭灞炴��
+ *
+ * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+ * @param templateVO 妯℃澘鐨勫唴瀹癸紝蹇呴』鍖呭惈妯℃澘灞炴��
+ * @param orderDTO 缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅
+ */
+ private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+ //鍏堣幏鍙栧叧閿睘鎬х殑瑙勫垯锛屼篃鍒╃敤缁ф壙鐨勬柟寮�
+ CodeKeyAttrRepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
+ //娉ㄦ剰鐨勬槸keyRuleVO鍙兘涓虹┖锛岃〃绀轰笉浣跨敤瑙勫垯鎺у埗
+ //鑾峰彇鎵�鏈夌殑鍏抽敭灞炴��
+ Map<String, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyAttrFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ Map<String, String> conditionMap = new HashMap<>();
+ boolean trimAll = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
+ //鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
+ boolean trim = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
+ boolean ignoreCase = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
+ boolean ignoreWidth = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
+ ketAttrMap.forEach((attrId, attrVO) -> {
+ String value = getValueFromOrderDTO(orderDTO, attrId);
+ if (value == null) {
+ value = "";
+ }
+ engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
+ });
+
+ //娌℃湁闄愬埗鍒嗙被锛屼絾鏄竴涓ā鏉垮彧鍙兘鍦ㄤ竴涓笟鍔＄被鍨嬮噷闈紝鎵�浠ョ洿鎺ユ煡璇㈣繖涓笟鍔＄被鍨嬪嵆鍙�
+
+ if (!CollectionUtils.isEmpty(conditionMap)) {
+ final String[] sql = {"select count(*) from " + VciBaseUtil.getTableName(classifyFullInfo.getTopClassifyVO().getBtmTypeId()) + " where 1 = 1 "};
+ conditionMap.forEach((key, value) -> {
+ sql[0] += " and " + key + " = " + value;
+ });
+ if (StringUtils.isNotBlank(orderDTO.getOid())) {
+ //淇敼鐨勬椂鍊欙紝闇�瑕佹帓闄よ嚜宸�
+ sql[0] += " and oid != '" + orderDTO.getOid() + "'";
+ } else if (StringUtils.isNotBlank(orderDTO.getCopyFromVersion())) {
+ sql[0] += " and oid != '" + orderDTO.getCopyFromVersion() + "'";
+ }
+ sql[0] += " and lastR = '1' and lastV = '1' ";
+ if (commonsMapper.queryCountBySql(sql[0]) > 0) {
+ String ruleInfoMsg = keyRuleVO == null ? "" : "鏌ヨ瑙勫垯锛氬幓闄ょ┖鏍�--{0},蹇界暐澶у皬鍐�--{1},蹇界暐鍏ㄥ崐瑙�--{2},蹇界暐鍏ㄩ儴绌烘牸--{3}";
+ String[] objs = new String[]{trim ? "鏄�" : "鍚�", ignoreCase ? "鏄�" : "鍚�", ignoreWidth ? "鏄�" : "鍚�", trimAll ? "鏄�" : "鍚�"};
+ String defaultValue=";鏍规嵁鎮ㄥ～鍐欑殑鍏抽敭灞炴�х殑鍐呭锛岀粨鍚堝叧閿睘鎬ф煡璇㈣鍒欙紝鍙戠幇杩欎釜鏁版嵁宸茬粡鍦ㄧ郴缁熶腑瀛樺湪浜嗐�傝淇!銆�";
+ String errormsg=defaultValue+ MessageFormat.format(ruleInfoMsg, objs);
+ errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+errormsg);
+ // throw new VciBaseException("鏍规嵁鎮ㄥ～鍐欑殑鍏抽敭灞炴�х殑鍐呭锛岀粨鍚堝叧閿睘鎬ф煡璇㈣鍒欙紝鍙戠幇杩欎釜鏁版嵁宸茬粡鍦ㄧ郴缁熶腑瀛樺湪浜嗐�傝淇!銆�" + ruleInfoMsg, objs);
+ }
+ }
+ }
+ /**
+ * 鏍￠獙鏋氫妇鐨勫唴瀹�
+ *
+ * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬�
+ * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
+ */
+ private void checkEnumOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+ //濡傛灉鏋氫妇鍙互淇敼锛屽垯涓嶉渶瑕佹牎楠屾槸鍚︾鍚堟灇涓剧殑閫夐」
+ Map<String, CodeClassifyTemplateAttrVO> enumAttrVOMap = templateVO.getAttributes().stream().filter(s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumId())) && !VciBaseUtil.getBoolean(s.getEnumEditFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if (!CollectionUtils.isEmpty(enumAttrVOMap)) {
+ enumAttrVOMap.forEach((attrId, attrVO) -> {
+ String value = getValueFromOrderDTO(orderDTO, attrId);
+ if (StringUtils.isNotBlank(value)) {
+ //鏈夊�兼墠鑳芥牎楠�
+ List<KeyValue> comboboxKVs = this.engineService.listComboboxItems(attrVO);
+ if (!comboboxKVs.stream().anyMatch(s -> value.equalsIgnoreCase(s.getKey()))) {
+ errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";灞炴�с��"+attrVO.getName()+"銆戠殑鍊间笉绗﹀悎鏋氫妇鐨勮姹�");
+ //throw new VciBaseException("灞炴�с�恵0}銆戠殑鍊间笉绗﹀悎鏋氫妇鐨勮姹�", new String[]{attrVO.getName()});
+ }
+ }
+ });
+ }
+ }
+ /**
+ * 杞崲鏃堕棿鐨勬牸寮�
+ *
+ * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬�
+ * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
+ */
+ private void switchDateAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
+ Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getCodeDateFormat())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
+ dateAttrVOMap.forEach((attrId, attrVO) -> {
+ String value = getValueFromOrderDTO(orderDTO, attrId);
+ if (StringUtils.isNotBlank(value)) {
+ DateConverter dateConverter = new DateConverter();
+ dateConverter.setAsText(value);
+ value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
+ setValueToOrderDTO(orderDTO, attrId, value);
+ }
+ });
+ }
+ }
+
+ /**
+ * 鎷疯礉鏁版嵁鍒癱bo瀵硅薄涓�
+ *
+ * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+ * @param cbo 涓氬姟鏁版嵁
+ * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
+ * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+ * @param edit 鏄惁涓轰慨鏀�
+ */
+ private void copyValueToCBO(CodeClassifyFullInfoBO classifyFullInfo, ClientBusinessObject cbo,
+ CodeOrderDTO orderDTO, CodeClassifyTemplateVO templateVO,
+ boolean edit,Map<String,String> errorMap) {
+ String fullPath = "";
+ if (!CollectionUtils.isEmpty(classifyFullInfo.getParentClassifyVOs())) {
+ fullPath = classifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel())))
+ .map(CodeClassifyVO::getOid).collect(Collectors.joining("##"));
+ } else {
+ fullPath = classifyFullInfo.getCurrentClassifyVO().getOid();
+ }
+ orderDTO.getData().forEach((key, value) -> {
+ if (!edit || (!engineService.checkUnAttrUnEdit(key) &&
+ !VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(key))) {
+ try {
+ cbo.setAttributeValue(key, value);
+ } catch (VciBaseException e) {
+ log.error("璁剧疆灞炴�х殑鍊奸敊璇�", e);
+ }
+ }
+ });
+ try {
+ cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD, classifyFullInfo.getCurrentClassifyVO().getOid());
+ cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD, templateVO.getOid());
+ cbo.setAttributeValue(CODE_FULL_PATH_FILED, fullPath);
+ if (!edit && StringUtils.isBlank(orderDTO.getLcStatus())) {
+ //鎵剧敓鍛藉懆鏈熺殑璧峰鐘舵�侊紝
+ if (StringUtils.isNotBlank(cbo.getLctid())) {
+ //OsLifeCycleVO lifeCycleVO = lifeCycleService.getLifeCycleById(cbo.getLctid());
+// if (lifeCycleVO != null) {
+// cbo.setLcStatus(lifeCycleVO.getStartStatus());
+// } else {
+ cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+// }
+ } else {
+ cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+ }
+
+ }
+ int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
+ if (secret == 0 || !secretService.checkDataSecret(secret).getData()) {
+ Integer userSecret = VciBaseUtil.getCurrentUserSecret();
+ cbo.setAttributeValue(SECRET_FIELD, String.valueOf((userSecret == null || userSecret == 0) ? UserSecretEnum.NONE.getValue() : userSecret));
+ }
+ } catch (Throwable e) {
+ log.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�", e);
+ }
+ }
+ /**
+ * 璁剧疆鏂扮殑鍊煎埌鐢宠瀵硅薄涓�
+ *
+ * @param orderDTO 缂栫爜鐢宠瀵硅薄
+ * @param attrId 灞炴�х殑缂栧彿
+ * @param value 鍊�
+ */
+ private void setValueToOrderDTO(CodeOrderDTO orderDTO, String attrId, String value) {
+ attrId = attrId.toLowerCase(Locale.ROOT);
+ if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
+ WebUtil.setValueToField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO, value);
+ } else {
+ orderDTO.getData().put(attrId, value);
+ }
+ }
+ /**
+ * 浠庣紪鐮佺敵璇蜂俊鎭璞′笂鑾峰彇鏌愪釜灞炴�х殑鍊�
+ *
+ * @param orderDTO 缂栫爜鐢宠瀵硅薄
+ * @param attrId 灞炴�х殑缂栧彿
+ * @return 鍊�
+ */
+ private String getValueFromOrderDTO(CodeOrderDTO orderDTO, String attrId) {
+ attrId = attrId.toLowerCase(Locale.ROOT);
+ String value = null;
+ if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
+ value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
+ } else {
+ //璇存槑鏄嚜琛岄厤缃殑
+ //鍓嶇蹇呴』瑕佷紶閫掑皬鍐欑殑灞炴��
+ value = orderDTO.getData().getOrDefault(attrId, "");
+ }
+ return value;
+ }
+ /**
+ * 澶勭悊鍒嗙被娉ㄥ叆鐨勪俊鎭�
+ *
+ * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝蹇呴』瑕佸悗妯℃澘鐨勫睘鎬�
+ * @param classifyFullInfoBO 鍒嗙被鐨勫叏璺緞
+ * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
+ */
+ private void switchClassifyLevelOnOrder(CodeClassifyTemplateVO templateVO, CodeClassifyFullInfoBO classifyFullInfoBO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
+ Map<String, CodeClassifyTemplateAttrVO> classifyAttrVOMap = templateVO.getAttributes().stream().filter(
+ s -> StringUtils.isNotBlank(s.getClassifyInvokeAttr()) && StringUtils.isNotBlank(s.getClassifyInvokeLevel())
+ ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if (classifyFullInfoBO.getTopClassifyVO() == null) {
+ //闇�瑕侀噸鏂版煡璇竴涓嬶紝鍥犱负杩欎釜鏄寚瀹氱殑鍒嗙被杩涙潵鐨�
+
+ }
+ if (!CollectionUtils.isEmpty(classifyAttrVOMap)) {
+ classifyAttrVOMap.forEach((attrId, attrVO) -> {
+ //鍒嗙被娉ㄥ叆鐨勭紪鍙锋垨鑰呭悕绉帮紝
+ //灞傜骇鍖呭惈鎸囧畾灞傚拰鏈�灏忓眰
+ CodeClassifyVO classifyVO = null;
+ if (!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyInvokeLevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyInvokeLevel())) {
+ //鎸囧畾浜嗗眰绾х殑
+ //娉ㄦ剰锛屽洜涓烘煡璇笂绾у垎绫诲嚭鏉ョ殑灞傜骇鏄�掑簭鐨勶紝鍗抽《灞傝妭鐐规槸鏈�澶х殑鍊�
+ List<CodeClassifyVO> classifyVOS = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
+ int level = VciBaseUtil.getInt(attrVO.getClassifyInvokeLevel());
+ if (classifyVOS.size() >= level && level > 0) {
+ classifyVO = classifyVOS.get(level - 1);
+ }
+ } else {
+ //褰撳墠鐨勫垎绫�
+ classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
+ }
+ if (classifyVO == null) {
+ //璇存槑灞傜骇鏈夎
+ errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";鍒嗙被鏍戜笂娌℃湁灞傜骇[" + attrVO.getClassifyInvokeLevel() + "]");
+ //orderDTO.getData().put(attrId, "鍒嗙被鏍戜笂娌℃湁灞傜骇[" + attrVO.getClassifyinvokelevel() + "]");
+ // classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
+ } else {
+ Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
+ String value = classifyDataMap.getOrDefault(attrVO.getClassifyInvokeAttr(), "");
+ orderDTO.getData().put(attrId, value);
+ }
+ });
+ }
+ }
+ /***
+ *
+ * @param codeClassifyVO
+ * @param templateVO
+ * @param codeDataMap
+ * @param codeSystemObjectMap
+ * @param codeOrderDTOList
+ * @param errorMap
+ * @return
+ */
+ private void getCodeOrderDTOs(CodeClassifyVO codeClassifyVO,CodeClassifyTemplateVO templateVO,Map<String ,RowDatas>codeDataMap,Map<String, ClientBusinessObject> codeSystemObjectMap,List<CodeOrderDTO> codeOrderDTOList,Map<String,String> errorMap){
+ codeDataMap.keySet().forEach(code->{
+ RowDatas rowDatas=codeDataMap.get(code);
+ Map<String, String> data= rowDatas.getFiledValue();
+ CodeOrderDTO orderDTO = new CodeOrderDTO();
+ if(codeSystemObjectMap.containsKey(code)){
+ ClientBusinessObject sysDataObject= codeSystemObjectMap.get(code);
+ orderDTO.setCodeClassifyOid(codeClassifyVO.getOid());//鍒嗙被涓婚敭
+ orderDTO.setOid(sysDataObject.getOid());//鏁版嵁oid
+ orderDTO.setLcStatus(rowDatas.getStatus());//鐘舵��
+ orderDTO.setId(code);
+ orderDTO.setTs(sysDataObject.getTs());
+ orderDTO.setBtmname(codeClassifyVO.getBtmname());//涓氬姟绫诲瀷
+ orderDTO.setDescription("闆嗘垚璋冪敤:鏇存柊");//鏁版嵁鎻忚堪
+ if(data.containsKey("name")){
+ String name=data.get("name");
+ orderDTO.setName(name);//鍚嶇О灞炴�у��
+ }
+ orderDTO.setData(data);//璁剧疆鏁版嵁
+ orderDTO.setSecDTOList(null);//鍒嗙被鐮佹
+ orderDTO.setEditInProcess(false);//鏄惁鍦ㄦ祦绋嬩腑
+ orderDTO.setTemplateOid(templateVO.getOid());
+ }else{
+ errorMap.put("code","缂栫爜涓猴細銆�"+code+"銆戠殑鏁版嵁鍦ㄧ郴缁熶腑涓嶅瓨鍦�");
+ }
+ codeOrderDTOList.add(orderDTO);
+ });
+ }
+
+ /**
+ * 鑾峰彇鍒嗙被鐨勫叏璺緞
+ * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+ * @return 鍏ㄨ矾寰�
+ */
+ private String getFullPath(CodeClassifyFullInfoBO classifyFullInfo){
+ String fullPath = "";
+ if(!CollectionUtils.isEmpty(classifyFullInfo.getParentClassifyVOs())){
+ fullPath = classifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel())))
+ .map(CodeClassifyVO::getOid).collect(Collectors.joining("##"));
+ }else{
+ fullPath = classifyFullInfo.getCurrentClassifyVO().getOid();
+ }
+ 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 fieldIndexMap 瀛楁鐨勪綅缃�
+ * @param rowDataList excel閲岀殑琛屾暟鎹�
+ * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+ * @param cboList 鏁版嵁鐨勫垪琛�
+ * @param fullPath 鍏ㄨ矾寰�
+ * @param operation 鎿嶄綔绫诲瀷
+ * @param errorMap 閿欒淇℃伅璁板綍
+ */
+ private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,List<String> titleRowData,Map<Integer,String> fieldIndexMap,List<RowDatas> rowDataList,
+ CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,
+ String fullPath,boolean isProcess,String operation,Map<String,String> errorMap,Map<String,String> codeOidToSystemOidMap){
+ rowDataList.stream().forEach(rowData -> {
+ String oid=rowData.getOid();
+ String rowNumber=rowData.getRowIndex();
+ ClientBusinessObject cbo = new ClientBusinessObject();
+ DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmTypeId());
+ rowData.getData().forEach((index,value)->{
+ String field = fieldIndexMap.get(index);
+ if(StringUtils.isBlank(field)){
+ errorMap.put(rowNumber,"灞炴�э細銆�" +titleRowData.get(index)+ "銆戝湪绯荤粺涓笉瀛樺湪");
+ }
+ try {
+ cbo.setAttributeValueWithNoCheck(field,value);
+ if(WebUtil.isDefaultField(field)){
+ WebUtil.setValueToField(field, cbo, value);
+ }
+ } catch (VciBaseException e) {
+ log.error("璁剧疆灞炴�х殑鍊奸敊璇�",e);
+ errorMap.put(rowNumber,"灞炴�э細銆�" +titleRowData.get(index)+ "銆戝湪绯荤粺涓笉瀛樺湪");
+ }
+ });
+ try {
+ cbo.setAttributeValue(IMPORT_ROW_INDEX,rowData.getRowIndex());
+ cbo.setAttributeValue(CODE_TEMPLATE_OID_FIELD,templateVO.getOid());
+ if(operation.equals("create")){
+ log.info("鍒嗙被瀵硅薄锛�"+classifyFullInfo.getCurrentClassifyVO());
+ log.info("codeClassoid:"+classifyFullInfo.getCurrentClassifyVO().getOid());
+ cbo.setAttributeValue(CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
+ cbo.setAttributeValue(CODE_FULL_PATH_FILED,fullPath);
+ int secret = VciBaseUtil.getInt(cbo.getAttributeValue(SECRET_FIELD));
+ if(secret == 0 || !secretService.checkDataSecret(secret).getData() ){
+ Integer userSecret = VciBaseUtil.getCurrentUserSecret();
+ String secretValue= String.valueOf((userSecret==null || userSecret ==0)? UserSecretEnum.NONE.getValue():userSecret);
+ cbo.setAttributeValue(SECRET_FIELD,secretValue);
+ }
+ if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//鍋滅敤
+ cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
+ }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//缂栬緫
+ cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+ }else if(rowData.getStatus().equals(CodeDefaultLC.AUDITING.getValue())) {//瀹℃壒涓�
+ cbo.setLcStatus(CodeDefaultLC.AUDITING.getValue());
+ }else if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//鍥炴敹
+ cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
+ }else{
+ cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());//鍙戝竷
+ }
+ /** if(!isProcess){
+ cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
+ }else {
+ if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//鍋滅敤
+ cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
+ }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//缂栬緫
+ cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+ }else {//鍙戝竷
+ cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
+ }
+ }***/
+ cbo.setCreator(rowData.getCreator());
+ cbo.setLastModifier(rowData.getEditor()==null?"":rowData.getEditor());
+ }else if(operation.equals("update")){
+ //姝ゆ椂杩樻病鏈夎浆鎹㈣矾寰�
+ //cbo.setAttributeValue(CODE_FULL_PATH_FILED, childOidPathMap.getOrDefault(rowData.getData().getOrDefault(CODE_CLASSIFY_OID_FIELD,""),fullPath));
+ if(rowData.getStatus().equals(CodeDefaultLC.DISABLE.getValue())){//鍋滅敤
+ cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());
+ }else if(rowData.getStatus().equals(CodeDefaultLC.RELEASED.getValue())){//鍙戝竷
+ cbo.setLcStatus(CodeDefaultLC.RELEASED.getValue());
+ }else if(rowData.getStatus().equals(CodeDefaultLC.EDITING.getValue())){//缂栬緫
+ cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+ }else if(rowData.getStatus().equals(CodeDefaultLC.AUDITING.getValue())) {//瀹℃壒涓�
+ cbo.setLcStatus(CodeDefaultLC.AUDITING.getValue());
+ }else if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//鍥炴敹
+ cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
+ }
+ cbo.setLastModifier(rowData.getEditor() == null ? "" : rowData.getEditor());//淇敼鑰�
+ }else if(operation.equals("delete")){
+ if(rowData.getStatus().equals(CodeDefaultLC.TASK_BACK.getValue())){//鍥炴敹
+ cbo.setLcStatus(CodeDefaultLC.TASK_BACK.getValue());
+ }else{
+ cbo.setLcStatus(CodeDefaultLC.DISABLE.getValue());//鍋滅敤
+ }
+ }
- SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
- List<ClientBusinessObject>needSaveCboList = cboList.stream().filter(cbo -> {
- String rowIndex = cbo.getAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX);
- return !errorMap.containsKey(rowIndex);
- }).collect(Collectors.toList());
+ }catch (Throwable e){
+ log.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�",e);
+ if(e instanceof VciBaseException){
+ errorMap.put(rowNumber,"璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�"+((VciBaseException) e).getMessage());
+ }else{
+ errorMap.put(rowNumber,"璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�"+e.getMessage());
+ }
- if (!CollectionUtils.isEmpty(needSaveCboList)) {
- //9.鎴戜滑澶勭悊涓氬姟鏁版嵁
- if (isImprot) {
- productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, ruleVO, null, needSaveCboList);
- }else {
- productCodeService.productCodeAndSaveData(classifyFullInfo, codeClassifyTemplateVO, ruleVO, orderDTO.getSecDTOList(), needSaveCboList);
- }
- allNeedSaveCboList.addAll(needSaveCboList);
- }
- //濡傛灉鏄紪鐮佺敓鎴愬け璐ワ紝鍒欑洿鎺ュ氨澶辫触浜嗭紝鍏朵粬鐨勫垽鏂嚭鏉ユ湁閿欒鐨勬垜浠兘缁熶竴杩斿洖鍒癳xcel閲岄潰
- engineService.batchSaveSelectChar(codeClassifyTemplateVO, allNeedSaveCboList);
- });
- return BaseResult.success(isImprot?"鎵归噺鍘嗗彶瀵煎叆鎴愬姛":"鎵归噺鐢宠鎴愬姛");
- }
- /***
- *
- * @param codeClassifyVO
- * @param templateVO
- * @param codeDataMap
- * @param codeSystemObjectMap
- * @param codeOrderDTOList
- * @param errorMap
- * @return
- */
- private void getCodeOrderDTOs(CodeClassifyVO codeClassifyVO,CodeClassifyTemplateVO templateVO,Map<String ,RowDatas>codeDataMap,Map<String, ClientBusinessObject> codeSystemObjectMap,List<CodeOrderDTO> codeOrderDTOList,Map<String,String> errorMap){
- codeDataMap.keySet().forEach(code->{
- RowDatas rowDatas=codeDataMap.get(code);
- Map<String, String> data= rowDatas.getFiledValue();
- CodeOrderDTO orderDTO = new CodeOrderDTO();
- if(codeSystemObjectMap.containsKey(code)){
- ClientBusinessObject sysDataObject= codeSystemObjectMap.get(code);
- orderDTO.setCodeClassifyOid(codeClassifyVO.getOid());//鍒嗙被涓婚敭
- orderDTO.setOid(sysDataObject.getOid());//鏁版嵁oid
- orderDTO.setLcStatus(rowDatas.getStatus());//鐘舵��
- orderDTO.setId(code);
- orderDTO.setTs(VciDateUtil.getDateFromStringForVci(sysDataObject.getTs()));
- orderDTO.setBtmname(codeClassifyVO.getBtmname());//涓氬姟绫诲瀷
- orderDTO.setDescription("闆嗘垚璋冪敤:鏇存柊");//鏁版嵁鎻忚堪
- if(data.containsKey("name")){
- String name=data.get("name");
- orderDTO.setName(name);//鍚嶇О灞炴�у��
- }
- orderDTO.setData(data);//璁剧疆鏁版嵁
- orderDTO.setSecDTOList(null);//鍒嗙被鐮佹
- orderDTO.setEditInProcess(false);//鏄惁鍦ㄦ祦绋嬩腑
- orderDTO.setTemplateOid(templateVO.getOid());
- }else{
- errorMap.put("code","缂栫爜涓猴細銆�"+code+"銆戠殑鏁版嵁鍦ㄧ郴缁熶腑涓嶅瓨鍦�");
- }
- codeOrderDTOList.add(orderDTO);
- });
- }
+ }finally {
+ codeOidToSystemOidMap.put(cbo.getOid(),oid);
+ }
+ cbo.setDescription("");
+ cboList.add(cbo);
+ });
- /**
- * 鎷疯礉鏁版嵁鍒癱bo瀵硅薄涓�
- *
- * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
- * @param cbo 涓氬姟鏁版嵁
- * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
- * @param templateVO 妯℃澘鐨勬樉绀哄璞�
- * @param edit 鏄惁涓轰慨鏀�
- */
- private void copyValueToCBO(CodeClassifyFullInfoBO classifyFullInfo, ClientBusinessObject cbo,
- CodeOrderDTO orderDTO, CodeClassifyTemplateVO templateVO,
- boolean edit,Map<String,String> errorMap) {
- String fullPath = "";
- if (!CollectionUtils.isEmpty(classifyFullInfo.getParentClassifyVOs())) {
- fullPath = classifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel())))
- .map(CodeClassifyVO::getOid).collect(Collectors.joining("##"));
- } else {
- fullPath = classifyFullInfo.getCurrentClassifyVO().getOid();
- }
- orderDTO.getData().forEach((key, value) -> {
- if (!edit || (!boService.checkUnAttrUnEdit(key) &&
- !VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(key))) {
- try {
- cbo.setAttributeValue(key, value);
- } catch (VCIError e) {
- logger.error("璁剧疆灞炴�х殑鍊奸敊璇�", e);
- }
- }
- });
- try {
- cbo.setAttributeValue(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD, classifyFullInfo.getCurrentClassifyVO().getOid());
- cbo.setAttributeValue(MdmEngineConstant.CODE_TEMPLATE_OID_FIELD, templateVO.getOid());
- cbo.setAttributeValue(MdmEngineConstant.CODE_FULL_PATH_FILED, fullPath);
- if (!edit && StringUtils.isBlank(orderDTO.getLcStatus())) {
- //鎵剧敓鍛藉懆鏈熺殑璧峰鐘舵�侊紝
- if (StringUtils.isNotBlank(cbo.getLctId())) {
- OsLifeCycleVO lifeCycleVO = lifeCycleService.getLifeCycleById(cbo.getLctId());
- if (lifeCycleVO != null) {
- cbo.setLcStatus(lifeCycleVO.getStartStatus());
- } else {
- cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
- }
- } else {
- cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
- }
+ }
+ /**
+ * 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).getData() ){
+ 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());
- }
- int secret = VciBaseUtil.getInt(cbo.getAttributeValue(MdmEngineConstant.SECRET_FIELD));
- if (secret == 0 || !secretService.checkDataSecret(secret)) {
- Integer userSecret = VciBaseUtil.getCurrentUserSecret();
- cbo.setAttributeValue(MdmEngineConstant.SECRET_FIELD, String.valueOf((userSecret == null || userSecret == 0) ? UserSecretEnum.NONE.getValue() : userSecret));
- }
- } catch (Throwable e) {
- logger.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�", e);
- }
- }
+ }catch (Throwable e){
+ log.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�",e);
+ }
+ cboList.add(cbo);
+ });
- /**
- * 杞崲鏃堕棿鐨勬牸寮�
- *
- * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬�
- * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
- */
- private void switchDateAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
- Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getCodedateformat())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
- dateAttrVOMap.forEach((attrId, attrVO) -> {
- String value = getValueFromOrderDTO(orderDTO, attrId);
- if (StringUtils.isNotBlank(value)) {
- DateConverter dateConverter = new DateConverter();
- dateConverter.setAsText(value);
- value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
- setValueToOrderDTO(orderDTO, attrId, value);
- }
- });
- }
- }
- /**
- * 璁剧疆鏂扮殑鍊煎埌鐢宠瀵硅薄涓�
- *
- * @param orderDTO 缂栫爜鐢宠瀵硅薄
- * @param attrId 灞炴�х殑缂栧彿
- * @param value 鍊�
- */
- private void setValueToOrderDTO(CodeOrderDTO orderDTO, String attrId, String value) {
- attrId = attrId.toLowerCase(Locale.ROOT);
- if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
- WebUtil.setValueToField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO, value);
- } else {
- orderDTO.getData().put(attrId, value);
- }
- }
- /**
- * 鏍￠獙鏋氫妇鐨勫唴瀹�
- *
- * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬�
- * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
- */
- private void checkEnumOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
- //濡傛灉鏋氫妇鍙互淇敼锛屽垯涓嶉渶瑕佹牎楠屾槸鍚︾鍚堟灇涓剧殑閫夐」
- Map<String, CodeClassifyTemplateAttrVO> enumAttrVOMap = templateVO.getAttributes().stream().filter(s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumid())) && !VciBaseUtil.getBoolean(s.getEnumeditflag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (!CollectionUtils.isEmpty(enumAttrVOMap)) {
- enumAttrVOMap.forEach((attrId, attrVO) -> {
- String value = getValueFromOrderDTO(orderDTO, attrId);
- if (StringUtils.isNotBlank(value)) {
- //鏈夊�兼墠鑳芥牎楠�
- List<KeyValue> comboboxKVs = this.engineService.listComboboxItems(attrVO);
- if (!comboboxKVs.stream().anyMatch(s -> value.equalsIgnoreCase(s.getKey()))) {
- errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";灞炴�с��"+attrVO.getName()+"銆戠殑鍊间笉绗﹀悎鏋氫妇鐨勮姹�");
- //throw new VciBaseException("灞炴�с�恵0}銆戠殑鍊间笉绗﹀悎鏋氫妇鐨勮姹�", new String[]{attrVO.getName()});
- }
- }
- });
- }
- }
+ }
+ /**
+ * excel杞崲涓篶bo鐨勫璞�
+ * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+ * @param fieldIndexMap 瀛楁鐨勪綅缃�
+ * @param rowDataList excel閲岀殑琛屾暟鎹�
+ * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+ * @param cboList 鏁版嵁鐨勫垪琛�
+ * @param fullPath 鍏ㄨ矾寰�
+ * @param newCode 鏄惁涓烘壒閲忕敵璇�
+ */
+ private void excelToCbo(CodeClassifyFullInfoBO classifyFullInfo,Map<Integer,String> fieldIndexMap,List<SheetRowData> rowDataList,
+ CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,
+ String fullPath,boolean newCode){
+ rowDataList.stream().forEach(rowData -> {
+ ClientBusinessObject cbo=new ClientBusinessObject();
+ DefaultAttrAssimtUtil.addDefaultAttrAssimt(cbo, classifyFullInfo.getTopClassifyVO().getBtmTypeId());
+ rowData.getData().forEach((index,value)->{
+ String field = fieldIndexMap.get(index);
+ if (StringUtils.isBlank(field)) {
+ throw new VciBaseException("绗�" + (index + 1) + "鍒楃殑鏍囬鍦ㄧ郴缁熶腑涓嶅瓨鍦�");
+ }
+ 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,templateVO.getOid());
+ cbo.setAttributeValue(IMPORT_ROW_INDEX,rowData.getRowIndex());
+ 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).getData() ){
+ 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());
+ }
- /**
- * 鏍￠獙鍏抽敭灞炴��
- *
- * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
- * @param templateVO 妯℃澘鐨勫唴瀹癸紝蹇呴』鍖呭惈妯℃澘灞炴��
- * @param orderDTO 缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅
- */
- private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
- //鍏堣幏鍙栧叧閿睘鎬х殑瑙勫垯锛屼篃鍒╃敤缁ф壙鐨勬柟寮�
- CodeKeyAttrRepeatRuleVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
- //娉ㄦ剰鐨勬槸keyRuleVO鍙兘涓虹┖锛岃〃绀轰笉浣跨敤瑙勫垯鎺у埗
- //鑾峰彇鎵�鏈夌殑鍏抽敭灞炴��
- Map<String, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyattrflag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- Map<String, String> conditionMap = new HashMap<>();
- boolean trimAll = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
- //鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
- boolean trim = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
- boolean ignoreCase = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
- boolean ignoreWidth = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
- ketAttrMap.forEach((attrId, attrVO) -> {
- String value = getValueFromOrderDTO(orderDTO, attrId);
- if (value == null) {
- value = "";
- }
- engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
- });
+ }catch (Throwable e){
+ log.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�",e);
+ }
+ cboList.add(cbo);
+ });
- //娌℃湁闄愬埗鍒嗙被锛屼絾鏄竴涓ā鏉垮彧鍙兘鍦ㄤ竴涓笟鍔＄被鍨嬮噷闈紝鎵�浠ョ洿鎺ユ煡璇㈣繖涓笟鍔＄被鍨嬪嵆鍙�
+ }
- if (!CollectionUtils.isEmpty(conditionMap)) {
- final String[] sql = {"select count(*) from " + VciBaseUtil.getTableName(classifyFullInfo.getTopClassifyVO().getBtmtypeid()) + " where 1 = 1 "};
- conditionMap.forEach((key, value) -> {
- sql[0] += " and " + key + " = " + value;
- });
- if (StringUtils.isNotBlank(orderDTO.getOid())) {
- //淇敼鐨勬椂鍊欙紝闇�瑕佹帓闄よ嚜宸�
- sql[0] += " and oid != '" + orderDTO.getOid() + "'";
- } else if (StringUtils.isNotBlank(orderDTO.getCopyFromVersion())) {
- sql[0] += " and oid != '" + orderDTO.getCopyFromVersion() + "'";
- }
- sql[0] += " and islastR = '1' and islastV = '1' ";
- if (boService.queryCountBySql(sql[0], new HashMap<>()) > 0) {
- String ruleInfoMsg = keyRuleVO == null ? "" : "鏌ヨ瑙勫垯锛氬幓闄ょ┖鏍�--{0},蹇界暐澶у皬鍐�--{1},蹇界暐鍏ㄥ崐瑙�--{2},蹇界暐鍏ㄩ儴绌烘牸--{3}";
- String[] objs = new String[]{trim ? "鏄�" : "鍚�", ignoreCase ? "鏄�" : "鍚�", ignoreWidth ? "鏄�" : "鍚�", trimAll ? "鏄�" : "鍚�"};
- String defaultValue=";鏍规嵁鎮ㄥ～鍐欑殑鍏抽敭灞炴�х殑鍐呭锛岀粨鍚堝叧閿睘鎬ф煡璇㈣鍒欙紝鍙戠幇杩欎釜鏁版嵁宸茬粡鍦ㄧ郴缁熶腑瀛樺湪浜嗐�傝淇!銆�";
- String errormsg=defaultValue+MessageFormat.format(ruleInfoMsg, objs);
- errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+errormsg);
- // throw new VciBaseException("鏍规嵁鎮ㄥ～鍐欑殑鍏抽敭灞炴�х殑鍐呭锛岀粨鍚堝叧閿睘鎬ф煡璇㈣鍒欙紝鍙戠幇杩欎釜鏁版嵁宸茬粡鍦ㄧ郴缁熶腑瀛樺湪浜嗐�傝淇!銆�" + ruleInfoMsg, objs);
- }
- }
- }
- /**
- * 鏍￠獙姝ｅ垯琛ㄨ揪寮忔槸鍚︽纭�
- *
- * @param templateVO 妯℃澘鐨勪俊鎭紝蹇呴』鍖呭惈灞炴�х殑鍐呭
- * @param orderDTO 缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅
- */
- private void checkVerifyOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
- Map<String, CodeClassifyTemplateAttrVO> verifyAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getVerifyrule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (!CollectionUtils.isEmpty(verifyAttrVOMap)) {
- verifyAttrVOMap.forEach((attrId, attrVO) -> {
- String value = getValueFromOrderDTO(orderDTO, attrId);
- if (StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyrule())) {
- errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";灞炴�"+attrVO.getName()+"]鐨勫�间笉绗﹀悎鏍￠獙瑙勫垯鐨勮姹�");
- //鏍￠獙姝ｅ垯琛ㄨ揪寮�
- // throw new VciBaseException("灞炴�{0}]鐨勫�间笉绗﹀悎鏍￠獙瑙勫垯鐨勮姹�", new String[]{attrVO.getName()});
- }
- });
- }
- }
- /**
- * 杞崲缁勫悎瑙勫垯鐨勫��
- *
- * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬�
- * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
- */
- private void switchComponentAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
- Map<String, CodeClassifyTemplateAttrVO> compAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getComponentrule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (!CollectionUtils.isEmpty(compAttrVOMap)) {
- Map<String, String> dataMap = WebUtil.objectToMapString(orderDTO);
+ /**
+ * 妫�鏌ユ牎楠岃鍒欐病鏈夐�氳繃鐨勫唴瀹�
+ * @param attrVOS 闇�瑕佹牎楠岀殑灞炴��
+ * @param dataList 鏁版嵁鐨勫垪琛�
+ * @param errorMap 閿欒鐨勪俊鎭槧灏�
+ * @return 鏍￠獙涓嶉�氳繃鐨勮鏁�
+ */
+ private void batchCheckVerifyOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS, List<ClientBusinessObject> dataList,Map<String,String> errorMap) {
+ Map<String, CodeClassifyTemplateAttrVO> verifyAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getVerifyRule()) && StringUtils.isBlank(s.getComponentRule())
+ &&StringUtils.isBlank(s.getClassifyInvokeAttr())
+ ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if(!CollectionUtils.isEmpty(verifyAttrVOMap)){
+ Map<String/**琛屽彿**/,List<String>/**鏍￠獙涓嶉�氳繃鐨勫睘鎬�**/> unPassCheckMap = new HashMap<>();
+ verifyAttrVOMap.forEach((attrId,attrVO)->{
+ dataList.stream().forEach(cbo -> {
+ String value = cbo.getAttributeValue(attrId);
+ if(StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyRule())){
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ List<String> unPassAttrs = unPassCheckMap.getOrDefault(rowIndex, new ArrayList<>());
+ unPassAttrs.add(attrVO.getName());
+ unPassCheckMap.put(rowIndex,unPassAttrs);
+ }
+ });
+ });
+ if(!CollectionUtils.isEmpty(unPassCheckMap)){
+ unPassCheckMap.forEach((rowIndex,unPassAttrs)->{
+ errorMap.put(rowIndex,";灞炴�" + unPassAttrs.stream().collect(Collectors.joining(",")) + "]鍐呭涓嶇鍚堟牎楠岃鍒欑殑瑕佹眰");
+ });
+ }
+ }
+ }
+ /**
+ * 鎵归噺杞崲鏃堕棿閮戒负鎸囧畾鐨勬牸寮�
+ * @param attrVOS 妯℃澘灞炴��
+ * @param cboList 鏁版嵁鐨勫垪琛�
+ * @param errorMap 閿欒鐨勪俊鎭�
+ */
+ private void batchSwitchDateAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> cboList,Map<String,String> errorMap){
+ Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap =attrVOS.stream().filter(s ->
+ StringUtils.isNotBlank(s.getCodeDateFormat()) && VciBaseUtil.getBoolean(s.getCodeDateFormat()) && StringUtils.isBlank(s.getComponentRule())
+ && StringUtils.isBlank(s.getClassifyInvokeAttr())
+ ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
+ dateAttrVOMap.forEach((attrId, attrVO) -> {
+ cboList.stream().forEach(cbo -> {
+ String value = cbo.getAttributeValue(attrId);
+ if (value == null) {
+ value = "";
+ }
+ if (StringUtils.isNotBlank(value)) {
+ boolean formated = false;
+ if(StringUtils.isNotBlank(attrVO.getCodeDateFormat())){
+ try {
+ Date date = VciDateUtil.str2Date(value, attrVO.getCodeDateFormat());
+ if(date!=null){
+ cbo.setAttributeValue(attrId,value);
+ formated = true;
+ }
+ } catch (Exception e) {
+ //璇存槑涓嶆槸杩欎釜鏍煎紡
+ }
+ }
+ if(!formated) {
+ try {
+ DateConverter dateConverter = new DateConverter();
+ dateConverter.setAsText(value);
+ value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
+ cbo.setAttributeValue(attrId,value);
+ }catch (Throwable e){
+ //杞崲涓嶄簡
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";灞炴�" + attrVO.getName() + "]鏃堕棿鏍煎紡涓嶆纭�" );
+ }
+ }
+ }
+ });
+ });
+ }
+ }
- Map<String, String> dataLowMap = new HashMap<>();
- if (!CollectionUtils.isEmpty(dataMap)) {
- dataMap.forEach((key, value) -> {
- dataLowMap.put(key.toLowerCase(Locale.ROOT), value);
- });
- }
- dataLowMap.putAll(orderDTO.getData());
- compAttrVOMap.forEach((attrId, attrVO) -> {
- dataLowMap.put(attrId, formulaService.getValueByFormula(dataLowMap, attrVO.getComponentrule()));
- });
- dataLowMap.forEach((key, value) -> {
- setValueToOrderDTO(orderDTO, key, value);
- });
- }
- }
- /**
- * 澶勭悊鍒嗙被娉ㄥ叆鐨勪俊鎭�
- *
- * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝蹇呴』瑕佸悗妯℃澘鐨勫睘鎬�
- * @param classifyFullInfoBO 鍒嗙被鐨勫叏璺緞
- * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
- */
- private void switchClassifyLevelOnOrder(CodeClassifyTemplateVO templateVO, CodeClassifyFullInfoBO classifyFullInfoBO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
- Map<String, CodeClassifyTemplateAttrVO> classifyAttrVOMap = templateVO.getAttributes().stream().filter(
- s -> StringUtils.isNotBlank(s.getClassifyinvokeattr()) && StringUtils.isNotBlank(s.getClassifyinvokelevel())
- ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (classifyFullInfoBO.getTopClassifyVO() == null) {
- //闇�瑕侀噸鏂版煡璇竴涓嬶紝鍥犱负杩欎釜鏄寚瀹氱殑鍒嗙被杩涙潵鐨�
+ /**
+ * 绯荤粺妯℃澘涓粯璁ゅ�艰缃�
+ * @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);
+ }
+ });
+ });
+ }
+ }
- }
- if (!CollectionUtils.isEmpty(classifyAttrVOMap)) {
- classifyAttrVOMap.forEach((attrId, attrVO) -> {
- //鍒嗙被娉ㄥ叆鐨勭紪鍙锋垨鑰呭悕绉帮紝
- //灞傜骇鍖呭惈鎸囧畾灞傚拰鏈�灏忓眰
- CodeClassifyVO classifyVO = null;
- if (!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyinvokelevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyinvokelevel())) {
- //鎸囧畾浜嗗眰绾х殑
- //娉ㄦ剰锛屽洜涓烘煡璇笂绾у垎绫诲嚭鏉ョ殑灞傜骇鏄�掑簭鐨勶紝鍗抽《灞傝妭鐐规槸鏈�澶х殑鍊�
- List<CodeClassifyVO> classifyVOS = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
- int level = VciBaseUtil.getInt(attrVO.getClassifyinvokelevel());
- if (classifyVOS.size() >= level && level > 0) {
- classifyVO = classifyVOS.get(level - 1);
- }
- } else {
- //褰撳墠鐨勫垎绫�
- classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
- }
- if (classifyVO == null) {
- //璇存槑灞傜骇鏈夎
- errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"")+";鍒嗙被鏍戜笂娌℃湁灞傜骇[" + attrVO.getClassifyinvokelevel() + "]");
- //orderDTO.getData().put(attrId, "鍒嗙被鏍戜笂娌℃湁灞傜骇[" + attrVO.getClassifyinvokelevel() + "]");
- // classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
- } else {
- Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
- String value = classifyDataMap.getOrDefault(attrVO.getClassifyinvokeattr(), "");
- orderDTO.getData().put(attrId, value);
- }
- });
- }
- }
+ /**
+ * 杞Щboolean鍨嬬殑灞炴��
+ * @param attrVOS 灞炴�х殑瀵硅薄
+ * @param dataList 鏁版嵁
+ */
+ private void reSwitchBooleanAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList){
+ Map<String, CodeClassifyTemplateAttrVO> booleanAttrMap = attrVOS.stream().filter(
+ s -> VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(s.getAttributeDataType())
+ ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if (!CollectionUtils.isEmpty(booleanAttrMap)) {
+ booleanAttrMap.forEach((attrId, attrVO) -> {
+ dataList.stream().forEach(cbo -> {
+ String text = cbo.getAttributeValue(attrId);
+ try {
+ if (BooleanEnum.TRUE.getValue().equalsIgnoreCase(text) || "鏄�".equalsIgnoreCase(text)) {
+ cbo.setAttributeValue(attrId, BooleanEnum.TRUE.getValue());
+ } else {
+ cbo.setAttributeValue(attrId, BooleanEnum.FASLE.getValue());
+ }
+ }catch (Throwable e){
+
+ }
+ });
+ });
+ }
+ }
+
+ /**
+ * 澶勭悊缁勫悎瑙勫垯
+ * @param attrVOS 妯℃澘灞炴��
+ * @param dataList excel鐨勬暟鎹唴瀹�
+ */
+ private void batchSwitchComponentAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList) {
+ Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(s -> StringUtils.isNotBlank(s.getComponentRule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if(!CollectionUtils.isEmpty(dateAttrVOMap)) {
+ dateAttrVOMap.forEach((attrId, attrVO) -> {
+ dataList.stream().forEach(cbo -> {
+ //浠巈xcel涓婃妸灞炴�ц浆鎹负map
+ Map<String,String> thisRowDataMap = new HashMap<>();
+ copyValueToMapFromCbos(cbo,thisRowDataMap);
+ //缁勫悎鍐呭
+ String value = formulaService.getValueByFormula(thisRowDataMap,attrVO.getComponentRule());
+ if(value == null){
+ value = "";
+ }
+ try {
+ cbo.setAttributeValue(attrId, value);
+ }catch (Throwable e){
+ log.error("璁剧疆灞炴�х殑閿欒",e);
+ }
+ });
+ });
+ }
+ }
+
+ /**
+ * 杞崲鍙傜収鐨勫��
+ * @param attrVOS 灞炴�х殑鏄剧ず瀵硅薄
+ * @param dataList 鏁版嵁鍒楄〃
+ * @param errorMap 閿欒鐨勪俊鎭�
+ */
+ private void batchSwitchReferAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,Map<String,String> errorMap){
+ Map<String, CodeClassifyTemplateAttrVO> referAttrVOMap = attrVOS.stream().filter(
+ s -> (StringUtils.isNotBlank(s.getReferBtmId()) || StringUtils.isNotBlank(s.getReferConfig()))
+ ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if(!CollectionUtils.isEmpty(referAttrVOMap)){
+ Map<String/**琛ㄦ牸鍜屽�肩殑灞炴��**/,Map<String/**鏄剧ず灞炴�х殑鍊�**/,List<String>/**琛ㄦ牸閲岀殑鍊�**/>> linkValueMap = new HashMap<>();
+ referAttrVOMap.forEach((attrId,attrVO)->{
+ dataList.stream().forEach(cbo -> {
+ String text = cbo.getAttributeValue(attrId);
+ if(StringUtils.isNotBlank(text)){
+ UIFormReferVO referVO = getReferVO(attrVO);
+ String valueField = getValueField(referVO);
+ String showText = getTextField(referVO);
+ String tableAndAttr = VciBaseUtil.getTableName(referVO.getReferType()) + "#" + valueField;
+ Map<String, List<String>> showTextMap = linkValueMap.getOrDefault(tableAndAttr, new HashMap<>());
+ List<String> textList = showTextMap.getOrDefault(showText, new ArrayList<>());
+ if(!textList.contains(text)) {
+ textList.add(text);
+ }
+ showTextMap.put(showText,textList);
+ linkValueMap.put(tableAndAttr,showTextMap);
+ }
+ });
+ });
+ if(!CollectionUtils.isEmpty(linkValueMap)){
+ //闇�瑕侀�愪釜琛ㄧ殑鍊煎瓧娈碉紝閫愪釜鏌ヨ
+ Map<String/**琛ㄦ牸鍜屽�煎睘鎬�**/,Map<String/**鏄剧ず灞炴��**/, Map<String/**鍊�**/,String/**鏄剧ず鐨勫��**/>>> linkCboMap = new HashMap<>();
+ linkValueMap.forEach((tableAndAttr,showValueMap)->{
+ String[] split = tableAndAttr.split("#");
+ String table = split[0];
+ String valueField = split[1].toLowerCase(Locale.ROOT);
+ Map<String,Map<String,String>> dataMap = new HashMap<>();
+ showValueMap.forEach((showText,valueList)->{
+ Map<String,String> valueOidTextMap = new HashMap<>();
+ List<List<String>> valueCollections = VciBaseUtil.switchListForOracleIn(valueList);
+ String sql = "select " + valueField + "," + showText.toLowerCase(Locale.ROOT) +" from " + table + " where " + showText + " in (%s)";
+ valueCollections.stream().forEach(values->{
+ List<Map<String,String>> dataMapList = commonsMapper.queryByOnlySqlForMap(String.format(sql, VciBaseUtil.toInSql(values.toArray(new String[0]))));
+ List<ClientBusinessObject> cbos= ChangeMapTOClientBusinessObjects(dataMapList);
+ if(!CollectionUtils.isEmpty(cbos)){
+ valueOidTextMap.putAll(cbos.stream().collect(Collectors.toMap(s->s.getAttributeValue(valueField),t->t.getAttributeValue(showText))));
+ }
+ });
+ dataMap.put(showText,valueOidTextMap);
+ });
+ linkCboMap.put(tableAndAttr,dataMap);
+ });
+ referAttrVOMap.forEach((attrId,attrVO)->{
+ dataList.stream().forEach(cbo -> {
+ String text = cbo.getAttributeValue(attrId);
+ if (StringUtils.isNotBlank(text)) {
+ UIFormReferVO referVO = getReferVO(attrVO);
+ String valueField = getValueField(referVO);
+ String showText = getTextField(referVO);
+ String tableAndAttr = VciBaseUtil.getTableName(referVO.getReferType()) + "#" + valueField;
+ if(!linkCboMap.containsKey(tableAndAttr)){
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍙傛暟灞炴�" + attrVO.getName() + "]鐨勫�煎湪绯荤粺涓笉瀛樺湪" );
+
+ }else{
+ Map<String, Map<String, String>> dataMap = linkCboMap.get(tableAndAttr);
+ if(!dataMap.containsKey(showText)){
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍙傛暟灞炴�" + attrVO.getName() + "]鐨勫�煎湪绯荤粺涓笉瀛樺湪" );
+ }else{
+ Map<String, String> data = dataMap.get(showText);
+ final boolean[] fined = {false};
+ data.forEach((key,value)->{
+ if(value.equalsIgnoreCase(text)){
+ fined[0] = true;
+ try {
+ cbo.setAttributeValue(attrId, key);
+ }catch (Throwable e){
+
+ }
+ }
+ });
+ if(!fined[0]){
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鍙傛暟灞炴�" + attrVO.getName() + "]鐨勫�煎湪绯荤粺涓笉瀛樺湪" );
+ }
+ }
+ }
+ }
+ });
+ });
+ }
+ }
+
+ }
+ /**
+ * 鎵归噺妫�鏌ヤ紒涓氱紪鐮佹槸鍚﹀瓨鍦�
+ * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+ * @param cboList 鏁版嵁鐨勫垪琛�
+ * @param errorMap 閿欒鐨勪俊鎭�
+ */
+ private void batchCheckIdExistOnOrder(CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,Map<String ,String> errorMap) throws Throwable{
+ List<String> existIds = new ArrayList<>();
+ String tableName ="";
+ try {
+ R<BtmTypeVO> r = btmTypeClient.getAllAttributeByBtmId(templateVO.getBtmTypeId());
+ if(r.getCode()!=200) {
+ throw new Throwable(r.getMsg());
+ }
+ BtmTypeVO btmTypeVO = r.getData();
+ if (btmTypeVO == null) {
+ throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷瀵硅薄锛�");
+ }
+ tableName = btmTypeVO.getTableName();
+ if (StringUtils.isBlank(tableName)) {
+ throw new Throwable("鏍规嵁涓氬姟绫诲瀷鏈煡璇㈠埌涓氬姟绫诲瀷鐩稿叧鑱旂殑琛�");
+ }
+ }catch (Throwable e){
+ throw e;
+ }
+ String finalTableName = tableName;
+ 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])) + ")");
+
+ StringBuffer sb=new StringBuffer();
+ sb.append(" select id from ");
+ sb.append(finalTableName);
+ sb.append(" where 1=1 ");
+ sb.append(" and 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 灞炴�х殑淇℃伅
+ * @return 鍙傜収鐨勫唴瀹�
+ */
+ private UIFormReferVO getReferVO(CodeClassifyTemplateAttrVO attrVO){
+ UIFormReferVO referVO = null;
+ if(StringUtils.isNotBlank(attrVO.getReferConfig())){
+ referVO = JSONObject.parseObject(attrVO.getReferConfig(),UIFormReferVO.class);
+ }else{
+ referVO = new UIFormReferVO();
+ referVO.setReferType(attrVO.getReferBtmId());
+ referVO.setValueField(VciQueryWrapperForDO.OID_FIELD);
+ referVO.setTextField("name");
+ }
+ return referVO;
+ }
+
+ /**
+ * 鑾峰彇鍙傜収涓殑鍊肩殑瀛楁
+ * @param referVO 鍙傜収鐨勫璞�
+ * @return 榛樿涓篛id锛屾湁澶氫釜鐨勬椂鍊欙紝鑾峰彇绗竴涓�
+ */
+ private String getValueField(UIFormReferVO referVO){
+ String showText = referVO.getValueField();
+ if(StringUtils.isBlank(showText)){
+ return "oid";
+ }
+ if(showText.contains(",")){
+ //闃叉涓囦竴鏈夊涓紝鐪嬬湅鏈夋病鏈塷id
+ List<String> strings = VciBaseUtil.str2List(showText);
+ if(strings.contains("oid")){
+ showText = "oid";
+ }else{
+ showText = strings.get(0);
+ }
+ }
+ return showText;
+ }
+
+ /**
+ * 鑾峰彇鍙傜収涓殑鏄剧ず鍐呭鐨勫瓧娈�
+ * @param referVO 鍙傜収鐨勫璞�
+ * @return 榛樿涓簄ame锛屾湁澶氫釜鐨勬椂鍊欙紝鑾峰彇绗竴涓�
+ */
+ private String getTextField(UIFormReferVO referVO){
+ String showText = referVO.getTextField();
+ if(StringUtils.isBlank(showText)){
+ return "name";
+ }
+ if(showText.contains(",")){
+ //闃叉涓囦竴鏈夊涓紝鐪嬬湅鏈夋病鏈塶ame
+ List<String> strings = VciBaseUtil.str2List(showText);
+ if(strings.contains("name")){
+ showText = "name";
+ }else{
+ showText = strings.get(0);
+ }
+ }
+ return showText;
+ }
+ /**
+ * 澶勭悊鏋氫妇鐨勬樉绀哄璞�
+ * @param attrVOS 妯℃澘灞炴��
+ * @param dataList excel鐨勬暟鎹唴瀹�
+ * @param errorMap 閿欒淇℃伅鐨勬槧灏�
+ */
+ private void batchSwitchEnumAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,
+ Map<String,String> errorMap ) {
+ Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(
+ s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumId()))
+ ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
+ dateAttrVOMap.forEach((attrId, attrVO) -> {
+ dataList.stream().forEach(cbo -> {
+ String text = cbo.getAttributeValue(attrId);
+ if(StringUtils.isNotBlank(text)){
+ List<KeyValue> valueList = engineService.listComboboxItems(attrVO);
+ boolean fined = false;
+ for (int i = 0; i < valueList.size(); i++) {
+ KeyValue keyValue = valueList.get(i);
+ //if(keyValue.getValue().equalsIgnoreCase(text)){
+ if(keyValue.getValue().equalsIgnoreCase(text)||keyValue.getKey().equalsIgnoreCase(text)){
+ try {
+ cbo.setAttributeValue(attrId, keyValue.getKey());
+ }catch (Throwable e){
+ log.error("璁剧疆灞炴�у嚭閿�");
+ }
+ fined = true;
+ break;
+ }
+ }
+ if(!fined){
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";灞炴�" + attrVO.getName() + "]鐨勫�间笉绗﹀悎涓嬫媺鐨勮姹�");
+ }
+ }
+ });
+ });
+ }
+ }
+
+ /**
+ * 鎵归噺鏍￠獙鏁版嵁鐨勪俊鎭�
+ * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+ * @param cboList 鏁版嵁鐨勫唴瀹�
+ */
+ private void batchCheckRequiredAttrOnOrder(CodeClassifyTemplateVO templateVO,List<ClientBusinessObject> cboList,Map<String,String> errorMap){
+ Map<String, CodeClassifyTemplateAttrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(s ->
+ VciBaseUtil.getBoolean(s.getRequireFlag()) && StringUtils.isBlank(s.getComponentRule()) && StringUtils.isBlank(s.getClassifyInvokeLevel())//涓嶈兘鏄粍鍚堢殑鍜屽垎绫绘敞鍏ョ殑
+ ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ //涓嶮dmEngineServiceImpl閲岄潰鐨刢heckRequiredAttrOnOrder 閫昏緫搴旇鐩镐技
+ if(!CollectionUtils.isEmpty(requiredAttrMap)) {
+ Set<String> nullRowIndex = cboList.stream().filter(cbo -> requiredAttrMap.keySet().stream().anyMatch(attrId -> StringUtils.isBlank(cbo.getAttributeValue(attrId)))).map(cbo -> cbo.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toSet());
+ if(!CollectionUtils.isEmpty(nullRowIndex)){
+ String checkAttr = requiredAttrMap.values().stream().map(CodeClassifyTemplateAttrVO::getName).collect(Collectors.joining(","));
+ nullRowIndex.stream().forEach(rowIndex->{
+ errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";鏍￠獙瑙勫垯涓嶉�氳繃锛屾湁鏍￠獙鐨勫睘鎬т负" + checkAttr);
+ });
+ }
+ }
+ }
+ /**
+ * 澶勭悊鍒嗙被娉ㄥ叆
+ * @param attrVOS 妯℃澘灞炴��
+ * @param dataList excel鐨勬暟鎹唴瀹�
+ * @param classifyFullInfo 鍒嗙被鐨勫叏璺緞
+ */
+ private void batchSwitchClassifyAttrOnOrder(Collection<CodeClassifyTemplateAttrVO> attrVOS,List<ClientBusinessObject> dataList,
+ CodeClassifyFullInfoBO classifyFullInfo,boolean isImPort) {
+ Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = attrVOS.stream().filter(
+ s -> StringUtils.isNotBlank(s.getClassifyInvokeAttr()) && StringUtils.isNotBlank(s.getClassifyInvokeAttr())
+ ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+ Map<String,CodeClassifyFullInfoBO> classifyFullInfoMap=new HashMap<>();
+ classifyFullInfoMap.put(classifyFullInfo.getCurrentClassifyVO().getOid(),classifyFullInfo);
+ if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
+ dataList.stream().forEach(cbo -> {
+ dateAttrVOMap.forEach((attrId, attrVO) -> {
+ //鍒嗙被娉ㄥ叆鐨勭紪鍙锋垨鑰呭悕绉帮紝
+ //灞傜骇鍖呭惈鎸囧畾灞傚拰鏈�灏忓眰
+ CodeClassifyVO classifyVO = null;
+ if(!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyInvokeLevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyInvokeLevel())) {
+ //鎸囧畾浜嗗眰绾х殑
+ //娉ㄦ剰锛屽洜涓烘煡璇笂绾у垎绫诲嚭鏉ョ殑灞傜骇鏄�掑簭鐨勶紝鍗抽《灞傝妭鐐规槸鏈�澶х殑鍊�
+ if(isImPort){
+ if(!classifyFullInfoMap.containsKey(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD))) {
+ CodeClassifyFullInfoBO currentClassifyFullInfo = classifyService.getClassifyFullInfo(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD));
+ classifyFullInfoMap.put(currentClassifyFullInfo.getCurrentClassifyVO().getOid(), currentClassifyFullInfo);
+ }
+ }
+ CodeClassifyFullInfoBO newClassifyFullInfo= classifyFullInfoMap.get(cbo.getAttributeValue(CODE_CLASSIFY_OID_FIELD));
+ List<CodeClassifyVO> classifyVOS = newClassifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
+ int level = VciBaseUtil.getInt(attrVO.getClassifyInvokeLevel());
+ if (classifyVOS.size()>=level && level > 0 ) {
+ classifyVO = classifyVOS.get(level-1);
+ }
+ }else{
+ //褰撳墠鐨勫垎绫�
+ classifyVO = classifyFullInfo.getCurrentClassifyVO();
+ }
+ try {
+ if (classifyVO == null) {
+ //璇存槑灞傜骇鏈夎
+ cbo.setAttributeValue(attrId, "鍒嗙被鏍戜笂娌℃湁灞傜骇[" + attrVO.getClassifyInvokeLevel() + "]");
+ } else {
+ Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
+ String value = classifyDataMap.getOrDefault(attrVO.getClassifyInvokeAttr(), "");
+ cbo.setAttributeValue(attrId, value);
+ }
+ } catch (Throwable e) {
+ log.error("璁剧疆灞炴�ч敊璇�", e);
+ }
+ });
+ });
+ }
+ }
+ /**
+ * 鏍￠獙鍏抽敭灞炴��
+ * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+ * @param templateVO 妯℃澘鐨勫唴瀹癸紝蹇呴』鍖呭惈妯℃澘灞炴��
+ * @param cboList 鎵归噺鐨勬暟鎹�
+ */
+ private CodeImportResultVO batchCheckKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO,
+ List<ClientBusinessObject> cboList) {
+ //涓嶮dmEngineServiceImpl閲岀殑checkKeyAttrOnOrder鐩镐技
+ //鍏堣幏鍙栧叧閿睘鎬х殑瑙勫垯锛屼篃鍒╃敤缁ф壙鐨勬柟寮�
+ CodeKeyAttrRepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
+ //娉ㄦ剰鐨勬槸keyRuleVO鍙兘涓虹┖锛岃〃绀轰笉浣跨敤瑙勫垯鎺у埗
+ //鑾峰彇鎵�鏈夌殑鍏抽敭灞炴��
+ Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyAttrFlag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+
+ boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
+ //鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
+ boolean trim =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
+ boolean ignoreCase = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
+ boolean ignoreWidth = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
+
+ //1. 鎴戜滑闇�瑕佸厛鍒ゆ柇excel瀵煎叆鐨勫唴瀹规槸鍚︽纭�
+ CodeImportResultVO resultVO = new CodeImportResultVO();
+ resultVO.setKeyAttrRuleInfo(String.format(keyRuleVO ==null?"":"鏌ヨ瑙勫垯锛氬幓闄ょ┖鏍�--{0},蹇界暐澶у皬鍐�--{1},蹇界暐鍏ㄥ崐瑙�--{2},蹇界暐鍏ㄩ儴绌烘牸--{3}",
+ new String[]{trim?"鏄�":"鍚�",ignoreCase?"鏄�":"鍚�",ignoreWidth?"鏄�":"鍚�",trimAll?"鏄�":"鍚�"}));
+ resultVO.setSelfRepeatRowIndexList(getSelfRepeatRowIndex(ketAttrMap,cboList,keyRuleVO));
+ if(!CollectionUtils.isEmpty(resultVO.getSelfRepeatRowIndexList())){
+ //鎴戜滑绉婚櫎鏈韩閲嶅鐨勬暟鎹�
+ cboList = cboList.stream().filter(s->!resultVO.getSelfRepeatRowIndexList().contains(s.getAttributeValue(IMPORT_ROW_INDEX))).collect(Collectors.toList());
+ }
+ //2.鍒ゆ柇鍏抽敭灞炴�у湪绯荤粺閲屾槸鍚﹂噸澶�
+ //鍥犱负鏁版嵁閲忓緢澶э紝鎵�浠ュ緱鎯冲姙娉曞苟琛�
+ //SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
+ Map<String,List<BaseModel>> indexTODataMap=new HashMap<>();
+ List<ClientBusinessObject> repeatDataMap = cboList.parallelStream().filter(cbo -> {
+ //姣忚閮藉緱鏌ヨ.濡傛灉鍏朵腑鍑虹幇浜嗛敊璇紝鎴戜滑灏辩洿鎺ユ姏鍑哄紓甯革紝鍏朵綑鐨勬樉绀�
+ //VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+ Map<String, String> conditionMap = new HashMap<>();
+ ketAttrMap.forEach((attrId, attrVO) -> {
+ String value =cbo.getAttributeValue(attrId.toLowerCase(Locale.ROOT));
+ if (value == null) {
+ value = "";
+ }
+ value= value.replace(REQUIRED_CHAR,SPECIAL_CHAR);
+ engineService.wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
+ });
+ if (!CollectionUtils.isEmpty(ketAttrMap)) {
+ CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(classifyFullInfo.getTopClassifyVO().getBtmTypeId(), templateVO, conditionMap, null);
+ boolean isKeyCheck= commonsMapper.queryCountBySql(sqlBO.getSqlCount()) > 0;
+ if(isKeyCheck){
+ List<Map<String,String>> newDataList= commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlUnPage());
+ //List<ClientBusinessObject> newCboList= ChangeMapTOClientBusinessObjects(newDataList);
+ List<BaseModel> newCboList=new ArrayList<>();
+ newDataList.stream().forEach(stringStringMap -> {
+ BaseModel baseModel=new BaseModel();
+ DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(stringStringMap,baseModel);
+ newCboList.add(baseModel);
+ });
+ if(!CollectionUtils.isEmpty(newCboList)) {
+ indexTODataMap.put(cbo.getAttributeValue(IMPORT_ROW_INDEX), newCboList);
+ }
+ }
+ return isKeyCheck;
+ }else{
+ return false;
+ }
+ }).collect(Collectors.toList());
+ if(!CollectionUtils.isEmpty(repeatDataMap)){
+ resultVO.setKeyAttrRepeatRowIndexList(repeatDataMap.stream().map(s->s.getAttributeValue(IMPORT_ROW_INDEX)).collect(Collectors.toSet()));
+ }
+ resultVO.setIndexTODataMap(indexTODataMap);
+ //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 templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬�
- * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
- */
- private void checkRequiredAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO,Map<String,String> errorMap) {
- Map<String, CodeClassifyTemplateAttrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(
- s -> VciBaseUtil.getBoolean(s.getRequireflag()) && StringUtils.isBlank(s.getComponentrule())
- && StringUtils.isBlank(s.getClassifyinvokeattr()))
- .collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (!CollectionUtils.isEmpty(requiredAttrMap)) {
- requiredAttrMap.forEach((attrId, attrVO) -> {
- //鍙湁浼佷笟缂栫爜锛岀姸鎬侊紝澶囨敞锛屾ā鏉夸富閿紝鍒嗙被涓婚敭杩欏嚑涓槸鍥哄畾鐨勶紝鍏朵綑閮芥槸鑷閰嶇疆鐨�
- if (StringUtils.isBlank(getValueFromOrderDTO(orderDTO, attrId))) {
- errorMap.put(orderDTO.getId(),errorMap.getOrDefault(orderDTO.getId(),"") + ";灞炴�с�恵"+attrVO.getName()+"}銆戝繀椤昏杈撳叆(閫夋嫨)鍐呭" );
- // throw new VciBaseException("灞炴�с�恵0}銆戝繀椤昏杈撳叆(閫夋嫨)鍐呭", new String[]{attrVO.getName()});
- }
- });
- }
- }
+ /**
+ * 鑾峰彇瀵煎叆鐨勫唴瀹逛腑鍏抽敭灞炴�ч噸澶嶇殑琛屽彿
+ * @param ketAttrMap 鍏抽敭灞炴�х殑鏄犲皠
+ * @param dataList 瀵煎叆鐨勬暟鎹�
+ * @param keyRuleVO 鍏抽敭灞炴�ф帶鍒惰鍒�
+ * @return 閲嶅鐨勮鍙�
+ */
+ private Set<String> getSelfRepeatRowIndex(Map<String/**灞炴�х殑缂栧彿**/, CodeClassifyTemplateAttrVO> ketAttrMap,
+ List<ClientBusinessObject> dataList,CodeKeyAttrRepeatVO keyRuleVO){
+ Set<String> selfRepeatRowIndexList = new CopyOnWriteArraySet<>();
+ boolean trimAll =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
+ //鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
+ boolean trim =keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
+ boolean ignoreCase = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
+ boolean ignoreWidth = keyRuleVO ==null?false: VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
+ //蹇呴』灏嗗睘鎬ф寜鐓ч『搴忔帓搴忓ソ
+ List<CodeClassifyTemplateAttrVO> attrVOList = ketAttrMap.values().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
+ Map<String/**琛屽彿**/,String/**鍏抽敭灞炴�х殑缁勫悎鍐呭**/> rowIndexKeyStringMap = new HashMap<>();
+ dataList.parallelStream().forEach(cbo-> {
+ String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < attrVOList.size(); i++) {
+ CodeClassifyTemplateAttrVO attrVO = attrVOList.get(i);
+ String attrId = attrVO.getId().toLowerCase(Locale.ROOT);
+ String value = cbo.getAttributeValue( attrId);
+ if (value == null) {
+ value = "";
+ }
+ if(trim){
+ value = value.trim();
+ }
+ if(trimAll){
+ value = value.replace(" ","");
+ }
+ if(ignoreCase){
+ value = value.toLowerCase(Locale.ROOT);
+ }
+ if(ignoreWidth){
+ value = VciBaseUtil.toDBC(value);
+ }
+ sb.append(value).append("${ks}");
+ }
+ String keyString = sb.toString();
+ if(rowIndexKeyStringMap.containsValue(keyString) && StringUtils.isNotBlank(keyString)){
+ selfRepeatRowIndexList.add(rowIndex);
+ }else {
+ rowIndexKeyStringMap.put(rowIndex, sb.toString());
+ }
+ });
+ //鍥犱负鍙槸鍏抽敭灞炴�ч噸澶嶏紝鎵�浠ユ垜浠笉鑳介噸澶嶇殑澶氭潯閫変竴鏉℃潵鎶ラ敊
+ return selfRepeatRowIndexList;
+ }
+ /**
+ * excel鐨勬爣棰樹笂鑾峰彇瀛楁鎵�鍦ㄧ殑浣嶇疆
+ * @param titleRowData 鏍囬鐨勫唴瀹�
+ * @param attrNameIdMap 妯℃澘涓睘鎬у悕绉板拰鑻辨枃鐨勬槧灏�
+ * @param fieldIndexMap 浣嶇疆鍜岃嫳鏂囧瓧娈电殑鏄犲皠
+ */
+ private void getFieldIndexMap(List<String> titleRowData,Map<String/**鍚嶇О**/,String/**瀛楁鍚�**/> attrNameIdMap,Map<Integer/**浣嶇疆**/,String/**鑻辨枃鍚嶅瓧**/> fieldIndexMap){
+ for (int i = 0; i < titleRowData.size(); i++) {
+ String title = titleRowData.get(i);
+ String id = attrNameIdMap.getOrDefault(title.replace(KEY_ATTR_CHAR,"").replace(REQUIRED_CHAR
+ ,""),"");
+ if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "鍒嗙被璺緞".equalsIgnoreCase(title)){
+ id = CODE_CLASSIFY_OID_FIELD;
+ }
+ if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "鐮佹瀹藉害".equalsIgnoreCase(title)){
+ id = CODE_SEC_LENGTH_FIELD;
+ }
+ if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "浼佷笟缂栫爜".equalsIgnoreCase(title)){
+ id = CODE_FIELD;
+ }
+ if(com.alibaba.cloud.commons.lang.StringUtils.isNotBlank(id)){
+ fieldIndexMap.put(i,id);
+ }
+ }
+ }
+ private List<ClientBusinessObject> ChangeMapTOClientBusinessObjects(List<Map<String,String>> oldDataMap){
+ List<ClientBusinessObject> clientBusinessObjectList=new CopyOnWriteArrayList<>();
+ oldDataMap.parallelStream().forEach(dataMap->{
+ ClientBusinessObject clientBusinessObject=new ClientBusinessObject();
+ DefaultAttrAssimtUtil.copplyDefaultAttrAssimt(dataMap,clientBusinessObject);
+ dataMap.forEach((key,value)->{
+ clientBusinessObject.setAttributeValue(key,value);
+ });
+ });
+ return clientBusinessObjectList;
+ }
+ /***
+ * 鏍规嵁涓嶅悓妯℃澘缁勭粐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#";
+ }
- /**
- * 浠庣紪鐮佺敵璇蜂俊鎭璞′笂鑾峰彇鏌愪釜灞炴�х殑鍊�
- *
- * @param orderDTO 缂栫爜鐢宠瀵硅薄
- * @param attrId 灞炴�х殑缂栧彿
- * @return 鍊�
- */
- private String getValueFromOrderDTO(CodeOrderDTO orderDTO, String attrId) {
- attrId = attrId.toLowerCase(Locale.ROOT);
- String value = null;
- if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
- value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
- } else {
- //璇存槑鏄嚜琛岄厤缃殑
- //鍓嶇蹇呴』瑕佷紶閫掑皬鍐欑殑灞炴��
- value = orderDTO.getData().getOrDefault(attrId, "");
- }
- return value;
- }
+ 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);
- /**
- * 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 = boService.createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid());
- rowData.forEach((field,value)->{
- try {
- cbo.setAttributeValueWithNoCheck(field,value);
- if(WebUtil.isDefaultField(field)){
- WebUtil.setValueToField(field, cbo, value);
- }
- } catch (VCIError e) {
- logger.error("璁剧疆灞炴�х殑鍊奸敊璇�",e);
- }
- });
- try {
- if(newCode){
- cbo.setAttributeValue(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid());
- cbo.setAttributeValue(MdmEngineConstant.CODE_FULL_PATH_FILED,fullPath);
- //cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
- int secret = VciBaseUtil.getInt(cbo.getAttributeValue(MdmEngineConstant.SECRET_FIELD));
- if(secret == 0 || !secretService.checkDataSecret(secret) ){
- Integer userSecret = VciBaseUtil.getCurrentUserSecret();
- cbo.setAttributeValue(MdmEngineConstant.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());
- cbo.setAttributeValue(MdmEngineConstant.CODE_TEMPLATE_OID_FIELD,codeImprotDataVO.getTemplateOid());
- cbo.setAttributeValue(MdmEngineConstant.IMPORT_ROW_INDEX,rowData.get(MdmEngineConstant.IMPORT_ROW_INDEX));
- }catch (Throwable e){
- logger.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�",e);
- }
- cboList.add(cbo);
- });
+ }
+ }
+ // 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
+ * @param rowIndexCbo
+ * @param dataSet
+ * @param fieldIndexMap
+ * @param errorMap
+ * @param isok
+ */
+ private void createRedisDatas(String uuid,CodeClassifyTemplateVO templateVO,Map<String,ClientBusinessObject> rowIndexCbo, SheetDataSet dataSet, Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap,Map<String,String> errorMap,boolean isok){
+ List<SheetRowData> needsheetRowDataList =new ArrayList<>();
+ if(errorMap.size()>0) {
+ //瑕佹妸浠ヤ笂鐨勯敊璇殑閮芥姏鍑哄悗锛屽啀缁х画澶勭悊鏃堕棿鍜岀粍鍚堣鍒�
+ needsheetRowDataList = dataSet.getRowData().stream().filter(cbo -> {
+ String rowIndex=cbo.getRowIndex();
+ return isok? !errorMap.containsKey(rowIndex):errorMap.containsKey(rowIndex);
+ }).collect(Collectors.toList());
- }
+ }else{
+ needsheetRowDataList= dataSet.getRowData();
+ }
+ Map<String/**涓枃鍚嶇О**/, SheetRowData/**鑻辨枃鍚嶇О**/> rowIdexDataMap = needsheetRowDataList.stream().collect(Collectors.toMap(s -> s.getRowIndex(), t -> t,(o1, o2)->o2));
+ Map<String,CodeImprotDataVO> clsfDataMap=new HashMap<>();
+ rowIndexCbo .forEach((rowIndex, cbo) -> {
+ CodeImprotDataVO codeImprotDataVO = new CodeImprotDataVO();
+ codeImprotDataVO.setTemplateOid(templateVO.getOid());
+ List<Map<String, String>> dataList = new ArrayList<>();
+ if(rowIdexDataMap.containsKey(rowIndex)){
+ SheetRowData sheetRowData=rowIdexDataMap.get(rowIndex);
+ Map<String, String> dataMap = new HashMap<>();
+ Map<Integer, String> data = sheetRowData.getData();
+ fieldIndexMap.forEach((integer, s) -> {
+ String field = fieldIndexMap.get(integer);
+ if (data.containsKey(integer)) {
+ String vlues = data.get(integer);
+ dataMap.put(field, vlues);
+ }
+ });
+ dataMap.put("oid",cbo.getOid());
+ dataList.add(dataMap);
+ }
+ if(clsfDataMap.containsKey(templateVO.getOid())){
+ codeImprotDataVO=clsfDataMap.get(templateVO.getOid());
+ dataList.addAll(codeImprotDataVO.getDatas());
+ }
+ codeImprotDataVO.setColNames(dataSet.getColName());
+ codeImprotDataVO.setDatas(dataList);
+ clsfDataMap.put(templateVO.getOid(),codeImprotDataVO);
+ });
+ if(!CollectionUtils.isEmpty(clsfDataMap)) {
+ Collection codeImprotDataVOS=clsfDataMap.values();
+ List<CodeImprotDataVO> codeImprotDataVOList=new ArrayList<>();
+ codeImprotDataVOList.addAll(codeImprotDataVOS);
+ bladeRedis.set(uuid+"-"+templateVO.getOid(), codeImprotDataVOList);
+ bladeRedis.expire(uuid+"-"+templateVO.getOid(),BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿
+ }
+ }
+ /******
+ * 鏍规嵁缂栫爜瑙勫垯缂撳瓨鏁版嵁
+ * @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());
- private void createRedisDatas(String uuid, CodeClassifyTemplateVO templateVO, 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(MdmEngineConstant.IMPORT_ROW_INDEX);
- 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杩囨湡鏃堕棿
- }else{
- dataLists= codeImprotDataVO.getDatas();
- }
- BeanUtilForVCI.copyPropertiesIgnoreCase(codeImprotDataVO,newCodeImprotDataVO);
- newCodeImprotDataVO.setDatas(dataLists);
- List<CodeImprotDataVO> codeImprotDataVOList=new ArrayList<>();
- codeImprotDataVOList.add(newCodeImprotDataVO);
- redisService.setCacheList(uuid+"-"+codeImprotDataVO.getCodeClassifyOid(), codeImprotDataVOList);
- logger.info(uuid+"-"+codeImprotDataVO.getCodeClassifyOid()+":鏉＄洰鏁�"+codeImprotDataVOList.size());
- //redisService.expire(uuid+"-"+codeImprotDataVO.getCodeClassifyOid(),6000000);//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
+ * @param templateVO
+ * @param cboList
+ * @param resembleMap
+ * @param btmtypeid
+ * @param dataResembleVOS
+ */
+ private void bathcResembleQuery(String codeClassifyOid, CodeClassifyTemplateVO templateVO, List<ClientBusinessObject> cboList,Map<String,String>resembleMap,String btmtypeid,List<DataResembleVO> dataResembleVOS){
+ CodeClassifyFullInfoBO fullInfoBO = classifyService.getClassifyFullInfo(codeClassifyOid);
+ Map<String, String> conditionMap = new HashMap<>();
+ CodeResembleRuleVO resembleRuleVO = Optional.ofNullable(engineService.getUseResembleRule(fullInfoBO, fullInfoBO.getCurrentClassifyVO())).orElseGet(() -> new CodeResembleRuleVO());
+ //闇�瑕佽幏鍙栨槸鍚︽湁鐩镐技鏌ヨ灞炴��
+ Map<String, CodeClassifyTemplateAttrVO> attrVOs = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSameRepeatAttrFlag())).collect(Collectors.toMap(s -> s.getId(), t -> t));
+ if (CollectionUtils.isEmpty(attrVOs)) {
+ return;
+ }
+ Map<String,CodeImprotResembleVO> codeImprotResembleVOMap=new HashMap<>();
+ List<CodeImprotResembleVO> codeImprotResembleVOList=new ArrayList<>();
+ Map<String,String> rowIndePathMap=new HashMap<>();
+ cboList.stream().forEach(clientBusinessObject -> {
+ CodeImprotResembleVO codeImprotResembleVO=new CodeImprotResembleVO();
+ final String[] path = {""};
+ List<String> fieldList=new ArrayList<>();
+ List<String> rowIndeList=new ArrayList<>();
+ String rowIndex = clientBusinessObject.getAttributeValue(IMPORT_ROW_INDEX);
+ attrVOs.forEach((attrId, attrVO) -> {
+ String value="";
+ /*if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
+ value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
+ }else {*/
+ value= clientBusinessObject.getAttributeValue(attrId);
+ // }
+ fieldList.add(attrId);
+ value=StringUtils.isBlank(value)?"":value;
+ path[0] +=value+"#";
+ engineService.wrapperResembleConditionMap(value, resembleRuleVO, attrId, conditionMap);
+ });
+ List<Map<String,String>> dataMap=new ArrayList<>();
+ if(codeImprotResembleVOMap.containsKey(path[0])) {
+ codeImprotResembleVO=codeImprotResembleVOMap.get(path[0]);
+ rowIndeList=codeImprotResembleVO.getRownIndex();
+ dataMap= codeImprotResembleVO.getDataList();
+ resembleMap.put(rowIndex, "瀛樺湪鐩镐技鏁版嵁");
+ }else{
+ if (!CollectionUtils.isEmpty(conditionMap)) {
+ Map<String, String> andConditionMap = new HashMap<>();
+ andConditionMap.put("lastr", "1");
+ andConditionMap.put("lastv", "1");
+ conditionMap.putAll(andConditionMap);
+ PageHelper pageHelper = new PageHelper(-1);
+ pageHelper.addDefaultDesc("id");
+ CodeTemplateAttrSqlBO sqlBO = engineService.getSqlByTemplateVO(btmtypeid, templateVO, conditionMap, pageHelper);
+ List<Map<String,String>> dataMapList=commonsMapper.queryByOnlySqlForMap(sqlBO.getSqlUnPage());
+ List<ClientBusinessObject> resembleCboList= ChangeMapTOClientBusinessObjects(dataMapList);
+ if(!CollectionUtils.isEmpty(resembleCboList)) {
+ List<Map<String, String>> finalDataMap = dataMap;
+ resembleCboList.stream().forEach(cbo->{
+ Map<String,String> resembDataMap=new HashMap<>();
+ fieldList.stream().forEach(field->{
+ String value=cbo.getAttributeValue(field);
+ value=StringUtils.isBlank(value)?"":value;
+ resembDataMap.put(field,value);
+ });
+ resembDataMap.put("codetemplateoid",templateVO.getOid());
+ resembDataMap.put("id",StringUtils.isBlank(cbo.getAttributeValue("id"))?"":cbo.getAttributeValue("id"));
+ resembDataMap.put("rowIndex","");
+ resembDataMap.put("oid",cbo.getOid());
+ finalDataMap.add(resembDataMap);
+ });
+ resembleMap.put(rowIndex, "瀛樺湪鐩镐技鏁版嵁");
+
+ }
+ }
+ }
+ rowIndePathMap.put(rowIndex,path[0]);
+ rowIndeList.add(rowIndex);
+ codeImprotResembleVO.setPath(path[0]);
+ codeImprotResembleVO.setRownIndex(rowIndeList);
+ codeImprotResembleVO.setConditionMap(conditionMap);
+ codeImprotResembleVO.setFields(fieldList);
+ codeImprotResembleVO.setDataList(dataMap);
+ codeImprotResembleVOMap.put(path[0],codeImprotResembleVO);
+ });
+ Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
+ if(!CollectionUtils.isEmpty(rowIndePathMap)){
+ rowIndePathMap.forEach((rowIndex, path) -> {
+ if(codeImprotResembleVOMap.containsKey(path)){
+ CodeImprotResembleVO codeImprotResembleVO= codeImprotResembleVOMap.get(path);
+ List<String> fieldList=codeImprotResembleVO.getFields();
+ List<String> rownIndexList= codeImprotResembleVO.getRownIndex();
+ List<String> newRownIndexList = rownIndexList.stream().filter(cbo -> {
+ return rowIndex!=cbo;
+ }).collect(Collectors.toList());
+ newRownIndexList.stream().forEach(s -> {
+ resembleMap.put(s, "瀛樺湪鐩镐技鏁版嵁");
+ });
+ List<Map<String, String>>newDataList=new ArrayList<>();
+ DataResembleVO dataResembleVO=new DataResembleVO();
+ dataResembleVO.setOid(cboMap.get(rowIndex).getOid());
+ List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
+ String newRowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ return rownIndexList.contains(newRowIndex)&&(!newRowIndex.equalsIgnoreCase(rowIndex));
+ }).collect(Collectors.toList());
+ if(!CollectionUtils.isEmpty(needSaveCboList)) {
+ needSaveCboList.stream().forEach(cbo -> {
+ String newRowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
+ Map<String, String> resembDataMap = new HashMap<>();
+ fieldList.stream().forEach(field -> {
+ String value = cbo.getAttributeValue(field);
+ value = StringUtils.isBlank(value) ? "" : value;
+ resembDataMap.put(field, value);
+ });
+ resembDataMap.put("codetemplateoid",templateVO.getOid());
+ resembDataMap.put("id",StringUtils.isBlank(cbo.getAttributeValue("id"))?"":cbo.getAttributeValue("id"));
+ resembDataMap.put("rowIndex", newRowIndex);
+ resembDataMap.put("oid",cbo.getOid());
+ newDataList.add(resembDataMap);
+ });
+ }
+ List<Map<String, String>>dataList=codeImprotResembleVO.getDataList();
+ newDataList.addAll(dataList);
+ dataResembleVO.setDataList(newDataList);
+ dataResembleVOS.add(dataResembleVO);
+ }
+ });
+ }
+ }
+
+ /***
+ * 瀛樺偍鍒嗙被瀵硅薄鍙婂叾鍒楀悕
+ * @param uuid
+ * @param templateVOList
+ * @param dataSet
+ * @param fieldIndexMap
+ * @param iscContain
+ */
+ private void createRedisByCodeClassify(String uuid,CodeClassifyTemplateVO templateVOList,SheetDataSet dataSet, Map<Integer/**鍒楀彿**/,String/**瀛楁鐨勫悕绉�**/> fieldIndexMap,boolean iscContain){
+ List<ColumnVO> columnVOList = new ArrayList<>();
+ List<String> outNameList = dataSet.getColName();
+ fieldIndexMap.forEach((integer, s) -> {
+ ColumnVO columnVOS = new ColumnVO();
+ String field = fieldIndexMap.get(integer);
+ String outName = outNameList.get(integer);
+ columnVOS.setField(field);
+ columnVOS.setTitle(outName);
+ columnVOList.add(columnVOS);
+ });
+ CodeImportTemplateVO codeImportTemplateVO=new CodeImportTemplateVO();
+ codeImportTemplateVO.setCodeClassifyTemplateVO(templateVOList);
+ codeImportTemplateVO.setCloNamesList(columnVOList);
+ List<CodeImportTemplateVO> codeImportTemplateVOs= new ArrayList<>();
+
+ codeImportTemplateVOs.add(codeImportTemplateVO);
+ if(codeImportTemplateVOs.size()>0) {
+ bladeRedis.set(uuid, codeImportTemplateVOs);
+ bladeRedis.expire(uuid, BATCHADD_REDIS_TIME);//redis杩囨湡鏃堕棿
+ }
+ }
+ /**
+ * 鎷疯礉涓氬姟绫诲瀷鍒癿ap
+ * @param cbo 涓氬姟鏁版嵁
+ * @param map map
+ */
+ public static void copyValueToMapFromCbos(ClientBusinessObject cbo,Map<String,String> map){
+ if(cbo!=null){
+ copyValueToMapFromBos(cbo,map);
+ }
+ }
+
+ /**
+ * 鎷疯礉涓氬姟绫诲瀷鍒癿ap
+ * @param bo 涓氬姟鏁版嵁
+ * @param map map
+ */
+ public static void copyValueToMapFromBos(ClientBusinessObject bo,Map<String,String> map){
+ if(bo!=null ){
+ //鍏堟妸鎵�鏈夌殑瀛楁鏄犲皠鎵惧埌
+ AttributeValue[] newAList = bo.newAttrValList;
+ AttributeValue[] hisAList = bo.hisAttrValList;
+ if(hisAList!=null&&hisAList.length>0){//
+ for(int i = 0 ; i < hisAList.length;i++){
+ AttributeValue av = hisAList[i];
+ String attrName = av.attrName.toLowerCase();
+ map.put(attrName, av.attrVal);
+ }
+ }
+ if(newAList!=null&&newAList.length>0){//NEW鐨勪紭鍏堢骇楂樹簺
+ for(int i = 0 ; i < newAList.length;i++){
+ AttributeValue av = newAList[i];
+ String attrName = av.attrName.toLowerCase();
+ map.put(attrName, av.attrVal);
+ }
+ }
+ }
+ }
}
--
Gitblit v1.9.3