From 27cddefb0cb28da699954ba1a1756d6bcabafbbe Mon Sep 17 00:00:00 2001
From: ludc <ludc@vci-tech.com>
Date: 星期三, 05 三月 2025 17:41:29 +0800
Subject: [PATCH] 集成申码接口调整：当码值按照约定传表名为空的业务场景下传null校验问题和码值组装问题。
---
Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmProductCodeServiceImpl.java | 2106 +++++++++++++++++++++++++++++++++++++++-------------------
1 files changed, 1,409 insertions(+), 697 deletions(-)
diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmProductCodeServiceImpl.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmProductCodeServiceImpl.java
index f57a5dd..3c6c37b 100644
--- a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmProductCodeServiceImpl.java
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmProductCodeServiceImpl.java
@@ -1,743 +1,1455 @@
package com.vci.ubcs.code.service.impl;
-import com.vci.ubcs.code.constant.MdmEngineConstant;
-import com.vci.ubcs.code.dao.CodeAllCodeDaoI;
-import com.vci.ubcs.code.mapper.CodeSerialValueMapper;
+import com.alibaba.fastjson.JSON;
+import com.vci.ubcs.code.algorithm.CustomSerialEnum;
+import com.vci.ubcs.code.annotation.MdmSerialAlgorithm;
+import com.vci.ubcs.code.annotation.MdmSerialAlgorithmMethod;
+import com.vci.ubcs.code.dto.CodeCustomSerialDTO;
+import com.alibaba.nacos.common.utils.StringUtils;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
+import com.vci.ubcs.code.dto.CodeOrderSecDTO;
+import com.vci.ubcs.code.entity.CodeAllCode;
+import com.vci.ubcs.code.entity.CodeClassifyValue;
+import com.vci.ubcs.code.entity.CodeSerialValue;
import com.vci.ubcs.code.enumpack.CodeCutTypeEnum;
import com.vci.ubcs.code.enumpack.CodeGetValueTypeEnum;
import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
import com.vci.ubcs.code.enumpack.CodeSecTypeEnum;
import com.vci.ubcs.code.lifecycle.CodeAllCodeLC;
-import com.vci.ubcs.code.entity.CodeAllCodeDO;
-import com.vci.ubcs.code.entity.CodeSerialValueDO;
-import com.vci.ubcs.code.service.MdmProductCodeServiceI;
-import com.vci.corba.common.VCIError;
-import com.vci.starter.web.constant.QueryOptionConstant;
-import com.vci.starter.web.constant.RegExpConstant;
-import com.vci.starter.web.exception.VciBaseException;
-import com.vci.starter.web.pagemodel.PageHelper;
-import com.vci.starter.web.pagemodel.SessionInfo;
-import com.vci.starter.web.util.VciBaseUtil;
-import com.vci.starter.web.util.VciDateUtil;
-import com.vci.web.enumpck.OsCodeFillTypeEnum;
-import com.vci.web.pageModel.BatchCBO;
-import com.vci.web.service.WebBoServiceI;
-import com.vci.web.service.impl.FormulaServiceImpl;
-import com.vci.web.util.WebUtil;
-import org.apache.commons.lang3.StringUtils;
-import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
-import com.vci.ubcs.code.dto.CodeOrderSecDTO;
+import com.vci.ubcs.code.mapper.CodeClassifyValueMapper;
+import com.vci.ubcs.code.mapper.CodeSerialValueMapper;
+import com.vci.ubcs.code.service.MdmEngineService;
+import com.vci.ubcs.code.service.MdmProductCodeService;
import com.vci.ubcs.code.vo.pagemodel.CodeBasicSecVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
+import com.vci.ubcs.omd.cache.EnumCache;
+import com.vci.ubcs.starter.exception.VciBaseException;
+import com.vci.ubcs.starter.revision.model.BaseModel;
+import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
+import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
+import com.vci.ubcs.starter.web.constant.QueryOptionConstant;
+import com.vci.ubcs.starter.web.constant.RegExpConstant;
+import com.vci.ubcs.starter.web.enumpck.OsCodeFillTypeEnum;
+import com.vci.ubcs.starter.web.util.ApplicationContextProvider;
+import com.vci.ubcs.starter.web.util.VciBaseUtil;
+import com.vci.ubcs.starter.web.util.VciDateUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.springblade.core.log.exception.ServiceException;
+import org.springblade.core.secure.BladeUser;
+import org.springblade.core.secure.utils.AuthUtil;
+import org.springblade.core.tool.utils.Func;
+import org.springblade.core.tool.utils.WebUtil;
import org.springframework.beans.factory.annotation.Autowired;
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 javax.servlet.http.HttpServletRequest;
+import java.lang.reflect.Method;
import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
-import static com.vci.web.other.BdSelectInputCharAspect.SEP;
+import static com.vci.ubcs.code.constant.MdmEngineConstant.*;
+import static com.vci.ubcs.code.enumpack.CodeSecTypeEnum.CODE_SERIAL_SEC;
-/**
- * 鐢熸垚缂栫爜鐨勬湇鍔�
- * @author weidy
- * @date 2022-3-6
- */
@Service
-public class MdmProductCodeServiceImpl implements MdmProductCodeServiceI {
+@Slf4j
+public class MdmProductCodeServiceImpl implements MdmProductCodeService {
- /**
- * 涓氬姟鏁版嵁鐨勬湇鍔�
- */
- @Autowired
- @Lazy
- private WebBoServiceI boService;
+ /**
+ * 娴佹按鍙风殑鐩稿叧鐨勪俊鎭�
+ */
+ @Resource
+ private CodeSerialValueMapper serialValueMapper;
- /**
- * 鎵�鏈夌殑缂栫爜鐨勫唴瀹�
- */
- @Autowired
- private CodeAllCodeDaoI allCodeMapper;
+ /**
+ * 娴佹按鍙风殑鐩稿叧鐨勪俊鎭�
+ */
+ @Resource
+ private CodeClassifyValueMapper codeClassifyValueMapper;
- /**
- * 娴佹按鍙风殑鐩稿叧鐨勪俊鎭�
- */
- @Autowired
- private CodeSerialValueMapper serialValueMapper;
+ /**
+ * 鎵�鏈夌殑缂栫爜鐨勫唴瀹�
+ */
+ @Resource
+ private CodeAllCodeServiceImpl codeAllCodeService;
- /**
- * 鍏紡鐨勬湇鍔�
- */
- @Autowired
- private FormulaServiceImpl formulaService;
- /**
- * 鐢熸垚缂栫爜--骞朵笖淇濆瓨鏁版嵁
- *
- * @param classifyFullInfoBO 鍒嗙被鐨勫叏閮ㄤ俊鎭�
- * @param templateVO 妯℃澘鐨勬樉绀哄璞�
- * @param ruleVO 缂栫爜瑙勫垯鐨勬樉绀哄璞�
- * @param secDTOList 鍚勪釜鐮佹鐨勫��
- * @param dataCBOList 涓氬姟鏁版嵁
- */
- @Override
- public synchronized List<String> productCodeAndSaveData(CodeClassifyFullInfoBO classifyFullInfoBO, CodeClassifyTemplateVO templateVO,
- CodeRuleVO ruleVO, List<CodeOrderSecDTO> secDTOList, List<ClientBusinessObject> dataCBOList) {
- BatchCBO batchCBO = new BatchCBO();
- WebUtil.setPersistence(false);
- dataCBOList = dataCBOList.stream().sorted(((o1, o2) -> o1.getCreateTime().compareTo(o2.getCreateTime()))).collect(Collectors.toList());
- batchCBO.getCreateCbos().addAll(dataCBOList);
- List<String> codeList = new ArrayList<>();
+ /**
+ * 鎵�鏈夌殑缂栫爜鐨勫唴瀹�
+ */
+ @Resource
+ @Lazy
+ private MdmEngineService mdmEngineService;
- /*****
- * 淇濊瘉骞跺彂鐨勬椂鍊欙紝鏈�澶ф祦姘村彿閮藉鐨勶紝浣嗘槸杩欑鍔犻攣鏈夊紛绔�
- *
- */
+ /**
+ * 鍏紡鐨勬湇鍔�
+ */
+ @Autowired
+ private FormulaServiceImpl formulaService;
- if(dataCBOList.stream().anyMatch(cbo->StringUtils.isNotBlank(cbo.getId()) && StringUtils.isNotBlank(cbo.getAttributeValue(MdmEngineConstant.CODE_SEC_LENGTH_FIELD)))){
- //鏄巻鍙叉暟鎹鍏�
- //鍘嗗彶鏁版嵁鎵ц鐨勬椂鍊欙紝杩欎釜绯荤粺浼氬緢鍗�
- //涓昏鏄负浜嗗綍鍏ユ渶澶ф祦姘村彿鍜宎llcode
- SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
- List<CodeAllCodeDO> allCodeDOList = new ArrayList<>();
- Map<String/**娴佹按渚濇嵁**/,Map<String/**鐮佹鐨勪富閿�**/,Double/**鏈�澶ф祦姘村彿**/>> maxSerialMap = new HashMap<>();
- dataCBOList.parallelStream().forEach(cbo->{
- VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
- String code = cbo.getId();
- List<String> serialUnitList = new ArrayList<>();
- String[] secLengths = cbo.getAttributeValue(MdmEngineConstant.CODE_SEC_LENGTH_FIELD).split("#");
- List<CodeBasicSecVO> secVOList = ruleVO.getSecVOList().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
- Map<String/**鐮佹鐨勪富閿�**/,String/**鐮佹鐨勫��**/> serialValueMap = new HashMap<>();
- Map<String, CodeBasicSecVO> secVOMap = secVOList.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
- for (int i = 0; i < secLengths.length; i++) {
- CodeBasicSecVO secVO = secVOList.get(i);
- String thisSecValue = "";
- if(i == 0){
- thisSecValue = code.contains("#")?code.substring(0,code.indexOf("#")):code;
- } else if(i == secLengths.length-1){
- //鏈�鍚�
- thisSecValue = code.contains("#")?code.substring(code.lastIndexOf("#")):code;
- }else {
- int start = 0;
- for (int j = 0; j < i; j++) {
- start += VciBaseUtil.getInt(secLengths[j]) + 1;
- }
- thisSecValue = code.substring(start,start+VciBaseUtil.getInt(secLengths[1]));
- }
- if(VciBaseUtil.getBoolean(secVO.getSerialDependFlag())){
- serialUnitList.add(thisSecValue);
- }
- if(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue().equalsIgnoreCase(secVO.getSectype())){
- serialValueMap.put(secVO.getOid(),thisSecValue);
- }
- }
- String serialUnitString = serialUnitList.size() == 0 ? MdmEngineConstant.EMPTY_SERIAL_UNIT : serialUnitList.stream().collect(Collectors.joining(MdmEngineConstant.SERIAL_UNIT_SPACE));
- List<String> serialUnFileStringList = new ArrayList<>();
- if(!CollectionUtils.isEmpty(serialValueMap)){
- serialValueMap.forEach((secOid,secValue)->{
- //瑕佺湅鏄笉鏄ˉ浣嶇殑
- CodeBasicSecVO secVO = secVOMap.get(secOid);
- Double serialDb = null;
- if(OsCodeFillTypeEnum.NONE.getValue().equalsIgnoreCase(secVO.getCodeFillType())){
- //涓嶈ˉ鐮�
- //鎶婃墍鏈変笉鏄暟瀛楃殑鍘绘帀锛屽洜涓哄彲鑳戒細鏄�佹暟鎹紝鏂拌鍒�
- serialDb = VciBaseUtil.getDouble(killUnNumberChar(secValue));
- }else {
- //宸﹀彸濉厖鐨勶紝鎴戜滑闇�瑕�
- serialDb = VciBaseUtil.getDouble(killUnNumberChar(killFillChar(secValue,secVO.getCodeFillSeparator(),
- OsCodeFillTypeEnum.LEFT.getValue().equalsIgnoreCase(secVO.getCodeFillType()))));
- }
- Map<String, Double> thisUnitMaxMap = maxSerialMap.getOrDefault(serialUnitString, new HashMap<>());
- thisUnitMaxMap.put(secOid,serialDb);
- maxSerialMap.put(serialUnitString,thisUnitMaxMap);
- serialUnFileStringList.add(String.valueOf(serialDb));
- });
- }
- CodeAllCodeDO allCodeDO = new CodeAllCodeDO();
- allCodeDO.setCodeClassifyOid(classifyFullInfoBO.getCurrentClassifyVO().getOid());
- allCodeDO.setCodeRuleOid(ruleVO.getOid());
- allCodeDO.setId(cbo.getId());
- allCodeDO.setCodeClassifyTemplateOid(templateVO.getOid());
- allCodeDO.setCreateCodeBtm(cbo.getBtmName());
- allCodeDO.setCreateCodeOid(cbo.getOid());
- allCodeDO.setSerialUnit(serialUnitString);
- allCodeDO.setUnFillSerial(serialUnFileStringList.stream().collect(Collectors.joining(MdmEngineConstant.SERIAL_VALUE_SPACE)));
- allCodeDO.setLcStatus(cbo.getLcStatus());
- allCodeDOList.add(allCodeDO);
- });
- //澶勭悊鏈�澶х殑娴佹按鍙�
- List<CodeSerialValueDO> addSerialValueList = new ArrayList<>();
- List<CodeSerialValueDO> editSerialValueList = new ArrayList<>();
- maxSerialMap.forEach((serialUnit,secOidMaxMap)->{
- secOidMaxMap.forEach((secOid,maxSerial)->{
- Map<String, String> conditionMap = new HashMap<>();
- conditionMap.put("codeRuleOid", ruleVO.getOid());
- conditionMap.put("serialUnit", serialUnit);
- //杩欎釜瀛楁鏄负浜嗚В鍐冲涓祦姘寸殑闂
- conditionMap.put("codeSecOid", secOid);
- List<CodeSerialValueDO> serialValueDOS = serialValueMapper.selectByCondition(conditionMap, new PageHelper(-1));
- if (!CollectionUtils.isEmpty(serialValueDOS)) {
- CodeSerialValueDO serialValueDO = serialValueDOS.get(0);
- if(VciBaseUtil.getDouble(serialValueDO.getMaxSerial())<maxSerial){
- serialValueDO.setMaxSerial(String.valueOf(maxSerial));
- editSerialValueList.add(serialValueDO);
- }
- }else{
- //娌℃湁
- CodeSerialValueDO serialValueDO = new CodeSerialValueDO();
- serialValueDO.setCodeRuleOid(ruleVO.getOid());
- serialValueDO.setSerialUnit(serialUnit);
- serialValueDO.setCodeSecOid(secOid);
- serialValueDO.setMaxSerial(maxSerial.toString());
- addSerialValueList.add(serialValueDO);
- }
- });
- });
- if(!CollectionUtils.isEmpty(addSerialValueList)){
- batchCBO.copyFromOther(serialValueMapper.batchInsert(addSerialValueList));
- }
- if(!CollectionUtils.isEmpty(editSerialValueList)){
- batchCBO.copyFromOther(serialValueMapper.batchUpdate(editSerialValueList));
- }
- //澶勭悊allCode
- if(!CollectionUtils.isEmpty(allCodeDOList)){
- Map<String, List<CodeAllCodeDO>> ruleGroup = allCodeDOList.stream().collect(Collectors.groupingBy(s -> s.getCodeRuleOid()));
- Map<String, CodeAllCodeDO> codeDOMap = allCodeDOList.stream().collect(Collectors.toMap(s -> s.getCodeRuleOid() + SEP + s.getId(), t -> t));
- List<CodeAllCodeDO> addCodeDOs = new ArrayList<>();
- List<CodeAllCodeDO> editCodeDOs = new ArrayList<>();
- ruleGroup.forEach((ruleOid,allCodeDOS)->{
- VciBaseUtil.switchCollectionForOracleIn(allCodeDOS).stream().forEach(codeDOs->{
- Map<String,String> conditionMap = new HashMap<>();
- conditionMap.put("coderuleoid",ruleOid);
- conditionMap.put("id",QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(codeDOs.stream().map(s->s.getId()).collect(Collectors.toList()).toArray(new String[0])) + ")");
- List<CodeAllCodeDO> existCodes = allCodeMapper.selectByCondition(conditionMap, new PageHelper(-1));
- if(!CollectionUtils.isEmpty(existCodes)){
- existCodes.stream().forEach(existCode->{
- String rule_id = existCode.getCodeRuleOid() + SEP + existCode.getId();
- if(codeDOMap.containsKey(rule_id)){
- CodeAllCodeDO newCodeDO = codeDOMap.get(rule_id);
- existCode.setCreateCodeOid(newCodeDO.getOid());
- existCode.setCreateCodeBtm(newCodeDO.getCreateCodeBtm());
- existCode.setCodeClassifyTemplateOid(newCodeDO.getCodeClassifyTemplateOid());
- existCode.setCodeClassifyOid(newCodeDO.getCodeClassifyOid());
- existCode.setLcStatus(newCodeDO.getLcStatus());
- editCodeDOs.add(existCode);
- }
- });
- }
- });
- });
- if(!CollectionUtils.isEmpty(editCodeDOs)){
- Set<String> exitIds = editCodeDOs.stream().map(s -> s.getCodeRuleOid() + SEP + s.getId()).collect(Collectors.toSet());
- addCodeDOs = allCodeDOList.stream().filter(s -> !exitIds.contains(s.getCodeRuleOid() + SEP + s.getId())).collect(Collectors.toList());
- }else{
- addCodeDOs = allCodeDOList;
- }
- if(!CollectionUtils.isEmpty(editCodeDOs)){
- batchCBO.copyFromOther(allCodeMapper.batchUpdate(editCodeDOs));
- }
- if(!CollectionUtils.isEmpty(addCodeDOs)){
- batchCBO.copyFromOther(allCodeMapper.batchInsert(addCodeDOs));
- Map<String, String> statusMap = addCodeDOs.stream().collect(Collectors.toMap(s -> s.getOid(), s -> s.getLcStatus()));
- batchCBO.getCreateCbos().stream().filter(s -> StringUtils.equalsIgnoreCase("codeallcode",s.getBtmName())).forEach(s -> {
- s.setLcStatus(statusMap.get(s.getOid()));
- try {
- s.setAttributeValue("lcstatus",statusMap.get(s.getOid()));
- } catch (VCIError e) {
- e.printStackTrace();
- }
- });
- }
- }
- WebUtil.setPersistence(true);
- boService.persistenceBatch(batchCBO);
- return codeList;
- }else {
- List<CodeBasicSecVO> secVOList = ruleVO.getSecVOList().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
- List<String> serialUnitList = new LinkedList<>();
- List<String> secValueList = new ArrayList<>();
- Map<String, String> secValueMap = secDTOList.stream().collect(Collectors.toMap(s -> s.getSecOid(), s -> s.getSecValue()));
- List<CodeBasicSecVO> serialSecVOList = new ArrayList<>();
- List<CodeBasicSecVO> attrSecVOList = new ArrayList<>();
- for (int i = 0; i < secVOList.size(); i++) {
- CodeBasicSecVO secVO = secVOList.get(i);
- switchSecValue(secVO, secValueMap, classifyFullInfoBO, serialSecVOList, attrSecVOList, serialUnitList, secValueList);
- }
- //澶勭悊灞炴�х爜娈靛拰娴佹按鐮佹
- Map<String/**娴佹按鐮佹鐨勪富閿�**/, Map<String/**娴佹按渚濇嵁**/, Double>> lastMaxSerialValueMap = new HashMap<>();
- List<CodeAllCodeDO> allCodeDOList = new ArrayList<>();
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public List<String> productCodeAndSaveData(CodeClassifyFullInfoBO classifyFullInfoBO, CodeClassifyTemplateVO templateVO, CodeRuleVO ruleVO, List<CodeOrderSecDTO> secDTOList, List<BaseModel> dataCBOList,BladeUser user) throws Exception {
+ dataCBOList = dataCBOList.stream().sorted(((o1, o2) -> o1.getCreateTime().compareTo(o2.getCreateTime()))).collect(Collectors.toList());
+ List<String> codeList = new ArrayList<>();
+ final CodeRuleVO finalRuleVO = ruleVO;
+ /*****
+ * 淇濊瘉骞跺彂鐨勬椂鍊欙紝鏈�澶ф祦姘村彿閮藉鐨勶紝浣嗘槸杩欑鍔犻攣鏈夊紛绔�
+ */
+ if(dataCBOList.stream().anyMatch(cbo-> StringUtils.isNotBlank(cbo.getId()))
+ // && StringUtils.isNotBlank(cbo.getAttributeValue(CODE_SEC_LENGTH_FIELD))
+ ){
+ //鏄巻鍙叉暟鎹鍏�
+ //涓昏鏄负浜嗗綍鍏ユ渶澶ф祦姘村彿鍜宎llcode
+ //SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
+ List<CodeAllCode> allCodeDOList = new CopyOnWriteArrayList<>();
+ Map<String/**娴佹按渚濇嵁**/, HashMap<String/**鐮佹鐨勪富閿�**/,String/**鏈�澶ф祦姘村彿**/>> maxSerialMap = new HashMap<>();
+ // TODO 澶氱嚎绋嬫祦寮曞彂鐨勯棶棰樺凡淇敼
+ dataCBOList.parallelStream().forEach(cbo->{
+ log.info("code:----->"+cbo.getId());
+ //VciBaseUtil.setCurrentUserSessionInfo(sessionInfo);
+ String code = cbo.getId();
+ List<String> serialUnitList = new CopyOnWriteArrayList<>();
+ //String seclenghStr=cbo.getData().get(CODE_SEC_LENGTH_FIELD);
+ String[] secLengths = cbo.getData().get(CODE_SEC_LENGTH_FIELD).split("#");
+ cbo.getData().remove(CODE_SEC_LENGTH_FIELD);//灏嗘key闄ゅ幓
+ cbo.getData().remove(IMPORT_ROW_INDEX);//灏嗘key闄ゅ幓
+ cbo.getData().remove("codeclassifyid");//灏嗘key闄ゅ幓
+ List<CodeBasicSecVO> secVOList = finalRuleVO.getSecVOList().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
+ Map<String/**鐮佹鐨勪富閿�**/,String/**鐮佹鐨勫��**/> serialValueMap = new HashMap<>();
+ Map<String, CodeBasicSecVO> secVOMap = secVOList.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
+ Map<String,Integer> serialSecOidIndexMap=new HashMap<>();
+ LinkedList<String> codeValueList=new LinkedList<>();
+ for (int i = 0; i < secLengths.length; i++) {
+ CodeBasicSecVO secVO = secVOList.get(i);
+ String thisSecValue = "";
+ /*if(i == 0){
+ thisSecValue = seclenghStr.contains("#")?code.substring(0,VciBaseUtil.getInt(secLengths[i])):code;
+ } else if(i == secLengths.length-1){
+ //鏈�鍚�
+ thisSecValue = seclenghStr.contains("#")?code.substring(VciBaseUtil.getInt(secLengths[i-1]),code.length()):code;
+ }else {*/
+ int start = 0;
+ for (int j = 0; j < i; j++) {
+ start += VciBaseUtil.getInt(secLengths[j]);
+ }
+ thisSecValue = code.substring(start,start+VciBaseUtil.getInt(secLengths[i]));
+ // }
+ if(VciBaseUtil.getBoolean(secVO.getSerialDependFlag())){
+ serialUnitList.add(thisSecValue);
+ serialSecOidIndexMap.put(secVO.getOid(),i);
+ }
+ if(CODE_SERIAL_SEC.getValue().equalsIgnoreCase(secVO.getSecType())){
+ serialValueMap.put(secVO.getOid(),thisSecValue);
+ }
+ codeValueList.add(thisSecValue);
+ }
+ List<String> serialUnFileStringList = new ArrayList<>();
+ AtomicReference<String> newSerialUnitString = new AtomicReference<>("");
+ if(!CollectionUtils.isEmpty(serialValueMap)){
+ AtomicInteger index = new AtomicInteger();
+ serialValueMap.forEach((secOid,secValue)->{
+ //瑕佺湅鏄笉鏄ˉ浣嶇殑
+ CodeBasicSecVO secVO = secVOMap.get(secOid);
+ List<String >newSerialUnitList=new ArrayList<>();
+ newSerialUnitList.addAll(serialUnitList);
+ if(index.get() ==0){
+ if(serialSecOidIndexMap.containsKey(secOid)) {
+ int num = serialSecOidIndexMap.get(secOid);
+ newSerialUnitList.set(num, "");
+ }
+ }
+ String serialUnitString = newSerialUnitList.size() == 0 ? EMPTY_SERIAL_UNIT : newSerialUnitList.stream().collect(Collectors.joining(SERIAL_UNIT_SPACE));
+ newSerialUnitString.set(serialUnitString);
+ index.getAndIncrement();
+ String serialDb = "";
+ // 鎴彇鎺夊墠鍚庣紑涔嬪悗鐨勭爜娈�
+ String subSecValue = killPriffixSuffix(secValue, secVO.getPrefixCode(), secVO.getSuffixCode());
+ if(OsCodeFillTypeEnum.NONE.getValue().equalsIgnoreCase(secVO.getCodeFillType())){
+ //涓嶈ˉ鐮�
+ //鎶婃墍鏈変笉鏄暟瀛楃殑鍘绘帀锛屽洜涓哄彲鑳戒細鏄�佹暟鎹紝鏂拌鍒�
+ //serialDb = VciBaseUtil.getDouble(killUnNumberChar(subSecValue));
+ //serialDb = killUnNumberChar(subSecValue);
+ serialDb=subSecValue;
+ }else {
+ //宸﹀彸濉厖鐨勶紝鎴戜滑闇�瑕�
+ serialDb = killFillChar(subSecValue,secVO.getCodeFillSeparator(),
+ OsCodeFillTypeEnum.LEFT.getValue().equalsIgnoreCase(secVO.getCodeFillType()));
+ }
+ Double newSerialDb = CustomSerialEnum.getDoubleCustomSerialValue(serialDb,secVO.getCustomCodeSerialType());
+ //TODO: 20240822闇�瑕佽繖鍧椾唬鐮佹槸鍚屾鎬х殑锛宮axSerialMap杩欏効浼氬洜涓虹嚎绋嬪彈褰卞搷锛屼慨鏀瑰悗娴嬭瘯澶氭鎬绘暟涓�5000鏉′竴娆″鍏ヨ�楄垂鏃堕棿涓�3鍒�30绉掑乏鍙�
+ synchronized(this) {
+ HashMap<String, String> thisUnitMaxMap = maxSerialMap.getOrDefault(serialUnitString, new HashMap<>());
+ Double maxValue=newSerialDb;
+ if(thisUnitMaxMap.containsKey(secOid)){
+ String newMaxValue = thisUnitMaxMap.getOrDefault(secOid,"");
+ maxValue = StringUtils.isBlank(newMaxValue)?-1:VciBaseUtil.getDouble(newMaxValue);
+ if(maxValue < newSerialDb){
+ maxValue = newSerialDb;
+ }
+ }
+ String newMaxValue=CustomSerialEnum.getStringCustomSerialValue(maxValue,secVO.getCustomCodeSerialType());
+ serialDb=CustomSerialEnum.getStringCustomSerialValue(newSerialDb,secVO.getCustomCodeSerialType());
+ thisUnitMaxMap.put(secOid,newMaxValue);
+ maxSerialMap.put(serialUnitString,thisUnitMaxMap);
+ serialUnFileStringList.add(String.valueOf(serialDb));
+ }
+ });
+ }
+ CodeAllCode allCodeDO = new CodeAllCode();
+ DefaultAttrAssimtUtil.addDefaultAttrAssimt(allCodeDO, MdmBtmTypeConstant.CODE_ALL_CODE,user);
+ allCodeDO.setCodeClassifyOid(classifyFullInfoBO.getCurrentClassifyVO().getOid());
+ allCodeDO.setCodeRuleOid(finalRuleVO.getOid());
+ allCodeDO.setId(cbo.getId());
+ allCodeDO.setCodeClassifyTemplateOid(templateVO.getOid());
+ allCodeDO.setCreateCodeBtm(cbo.getBtmname());
+ allCodeDO.setCreateCodeOid(cbo.getOid());
+ allCodeDO.setSerialUnit(newSerialUnitString.get());
+ String unFillSerial =serialUnFileStringList.size()==1?serialUnFileStringList.get(0)+ SERIAL_VALUE_SPACE:serialUnFileStringList.stream().collect(Collectors.joining(SERIAL_VALUE_SPACE));
+ allCodeDO.setUnFillSerial(unFillSerial);
+ allCodeDO.setLcStatus(cbo.getLcStatus());
+ allCodeDO.setLctid("codeAllCodeLC");
+ allCodeDO.setCodeDelimit(codeValueList.stream().collect(Collectors.joining(SERIAL_VALUE_SPACE)));//娣诲姞閾炬帴绗�
+ allCodeDOList.add(allCodeDO);
+ });
+ //澶勭悊鏈�澶х殑娴佹按鍙�
+ List<CodeSerialValue> addSerialValueList = new ArrayList<>();
+ List<CodeSerialValue> editSerialValueList = new ArrayList<>();
+ log.info("maxSerialMap:----->"+maxSerialMap.size());
+ maxSerialMap.forEach((serialUnit,secOidMaxMap)->{
+ secOidMaxMap.forEach((secOid,maxSerial)->{
+ QueryWrapper<CodeSerialValue> queryWrapper = new QueryWrapper<>();
+ queryWrapper.eq("codeRuleOid", finalRuleVO.getOid());
+ queryWrapper.eq("serialUnit", serialUnit);
+ //杩欎釜瀛楁鏄负浜嗚В鍐冲涓祦姘寸殑闂
+ queryWrapper.eq("codeSecOid", secOid);
- //宸茬粡瀛樺偍鐨勬渶澶ф祦姘村彿鐨勫唴瀹�
- Map<String/**鐮佹鐨勪富閿�**/, Map<String, CodeSerialValueDO>> maxSerialValueMap = new HashMap<>();
+ List<CodeSerialValue> serialValueDOS = serialValueMapper.selectList(queryWrapper);
+ log.info("serialValueDOS--->"+serialValueDOS.size());
+ if (!CollectionUtils.isEmpty(serialValueDOS)) {
+ CodeSerialValue serialValueDO = serialValueDOS.get(0);
+ log.info("oldmaxSerial--->"+serialValueDO.getMaxSerial()+"---- newmaxSerial---->"+maxSerial);
+ if(VciBaseUtil.getDouble(serialValueDO.getMaxSerial())<VciBaseUtil.getDouble(maxSerial)){
+ serialValueDO.setMaxSerial(String.valueOf(maxSerial));
+ DefaultAttrAssimtUtil.updateDefaultAttrAssimt(serialValueDO,user);
+ editSerialValueList.add(serialValueDO);
+ }
+ }else{
+ //娌℃湁
+ CodeSerialValue serialValueDO = new CodeSerialValue();
+ DefaultAttrAssimtUtil.addDefaultAttrAssimt(serialValueDO, MdmBtmTypeConstant.CODE_SERIAL_VALUE,user);
+ serialValueDO.setCodeRuleOid(finalRuleVO.getOid());
+ serialValueDO.setSerialUnit(serialUnit);
+ serialValueDO.setCodeSecOid(secOid);
+ serialValueDO.setMaxSerial(maxSerial.toString());
+ addSerialValueList.add(serialValueDO);
+ }
+ });
+ });
+ if(!CollectionUtils.isEmpty(addSerialValueList)){
+ for (CodeSerialValue codeSerialValue : addSerialValueList) {
+ serialValueMapper.insert(codeSerialValue);
+ }
+ }
+ if(!CollectionUtils.isEmpty(editSerialValueList)){
+ for (CodeSerialValue codeSerialValue : editSerialValueList) {
+ serialValueMapper.updateById(codeSerialValue);
+ }
+ }
+ //澶勭悊allCode
+ if(!CollectionUtils.isEmpty(allCodeDOList)){
+ Map<String,List<CodeAllCode>> ruleGroup = allCodeDOList.stream().collect(Collectors.groupingBy(s -> s.getCodeRuleOid()));
+ Map<String, CodeAllCode> codeDOMap = allCodeDOList.stream().collect(Collectors.toMap(s -> s.getCodeRuleOid() + "${SEP}" + s.getId(), t -> t));
+ List<CodeAllCode> addCodeDOs = new CopyOnWriteArrayList<>();
+ List<CodeAllCode> editCodeDOs = new CopyOnWriteArrayList<>();
+ ruleGroup.forEach((ruleOid,allCodeDOS)->{
+ VciBaseUtil.switchCollectionForOracleIn(allCodeDOS).stream().forEach(codeDOs->{
+ QueryWrapper<CodeAllCode> allCodeWrapper = new QueryWrapper<>();
+ allCodeWrapper.eq("coderuleoid",ruleOid);
+ allCodeWrapper.in("id", QueryOptionConstant.IN + "(" +
+ VciBaseUtil.toInSql(codeDOs.stream().map(s->s.getId()).collect(Collectors.toList()).toArray(new String[0])) + ")");
+ List<CodeAllCode> existCodes = codeAllCodeService.selectByWrapper(allCodeWrapper);
- for (int i = 0; i < dataCBOList.size(); i++) {
- ClientBusinessObject cbo = dataCBOList.get(i);
- List<String> thisSecValueList = new LinkedList<>();
- for (int j = 0; j < secValueList.size(); j++) {
- thisSecValueList.add(secValueList.get(j));
- }
- List<String> thisSerialUnitList = new LinkedList<>();
- //鍥犱负娴佹按渚濇嵁姣忔鍙兘涓嶄竴鏍凤紝鎵�浠ユ瘡娆￠兘鎷疯礉涓�浠�
- for (int j = 0; j < serialUnitList.size(); j++) {
- thisSerialUnitList.add(serialUnitList.get(j));
- }
- //鍏堢湅鐪嬫湁娌℃湁灞炴�х殑鐮佹
- boolean attrSevIsSerialDepend = CollectionUtils.isEmpty(attrSecVOList) ? false : (attrSecVOList.stream().anyMatch(s -> VciBaseUtil.getBoolean(s.getSerialDependFlag())));
- switchAttrSecValue(attrSecVOList, cbo, thisSecValueList, attrSevIsSerialDepend, thisSerialUnitList);
+ if(!CollectionUtils.isEmpty(existCodes)){
+ existCodes.stream().forEach(existCode->{
+ String rule_id = existCode.getCodeRuleOid() + "${SEP}" + existCode.getId();
+ if(codeDOMap.containsKey(rule_id)){
+ CodeAllCode newCodeDO = codeDOMap.get(rule_id);
+ existCode.setCreateCodeOid(newCodeDO.getOid());
+ existCode.setCreateCodeBtm(newCodeDO.getCreateCodeBtm());
+ existCode.setCodeClassifyTemplateOid(newCodeDO.getCodeClassifyTemplateOid());
+ existCode.setCodeClassifyOid(newCodeDO.getCodeClassifyOid());
+ existCode.setLcStatus(newCodeDO.getLcStatus());
+ editCodeDOs.add(existCode);
+ }
+ });
+ }
+ });
+ });
+ if(!CollectionUtils.isEmpty(editCodeDOs)){
+ Set<String> exitIds = editCodeDOs.stream().map(s -> s.getCodeRuleOid() + "${SEP}" + s.getId()).collect(Collectors.toSet());
+ addCodeDOs = allCodeDOList.stream().filter(s -> !exitIds.contains(s.getCodeRuleOid() + "${SEP}" + s.getId())).collect(Collectors.toList());
+ }else{
+ addCodeDOs = allCodeDOList;
+ }
+ if(!CollectionUtils.isEmpty(editCodeDOs)){
+ codeAllCodeService.updateBatchById(editCodeDOs);
+ }
+ if(!CollectionUtils.isEmpty(addCodeDOs)){
+ Map<String, String> statusMap = addCodeDOs.stream().collect(Collectors.toMap(s -> s.getOid(), s -> s.getLcStatus()));
+ addCodeDOs.stream().filter(s -> StringUtils.equalsIgnoreCase("codeallcode",s.getBtmname())).forEach(s -> {
+ s.setLcStatus(statusMap.get(s.getOid()));
+ });
+ //閫氳繃ID鏉ヨ繘琛屽幓閲�
+ List<CodeAllCode> distinctCodeAllCOdes = addCodeDOs.stream().collect(Collectors
+ .collectingAndThen(
+ Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(CodeAllCode::getId))),
+ ArrayList::new));
+ if(distinctCodeAllCOdes.size() != addCodeDOs.size() ){
+ throw new VciBaseException("缂栫爜鏁版嵁閲嶅锛屾棤娉曚繚瀛橈紝璇锋敞鎰忥紒");
+ }
+ QueryWrapper<CodeAllCode> wrapper = new QueryWrapper<>();
+ wrapper.eq("CREATECODEBTM",addCodeDOs.get(0).getCreateCodeBtm());
+ wrapper.in("ID",addCodeDOs.stream().map(CodeAllCode::getId).collect(Collectors.toList()));
+ List<CodeAllCode> codeAllCodes = codeAllCodeService.selectByWrapper(wrapper);
+ List<CodeAllCode> takeBack = codeAllCodes.stream().filter(e -> e.getLcStatus().equals("TakeBack")).collect(Collectors.toList());
+ if(codeAllCodes.size()>takeBack.size()){
+ throw new ServiceException("鐢熸垚缂栫爜鏁版嵁ID宸叉湁鍘嗗彶璁板綍,璇风‘璁ゅ涓嬬敓鎴愮殑ID鏁版嵁锛�"+ addCodeDOs.stream().map(CodeAllCode::getId).collect(Collectors.toList()));
+ }
+ for (CodeAllCode codeAllCode : takeBack) {
+ codeAllCode.setTs(new Date());
+ codeAllCode.setLastModifyTime(new Date());
+ codeAllCode.setLastModifier(Func.isNotEmpty(user) ? user.getAccount():AuthUtil.getUserAccount());
+ for (int i = 0; i < addCodeDOs.size(); i++) {
+ if(codeAllCode.getId().equals(addCodeDOs.get(i).getId())){
+ codeAllCode.setCreateCodeOid(addCodeDOs.get(i).getCreateCodeOid());
+ codeAllCode.setLcStatus(addCodeDOs.get(i).getLcStatus());
+ addCodeDOs.remove(i);
+ }
+ }
+ /*Iterator<CodeAllCode> iterator = addCodeDOs.iterator();
+ while (iterator.hasNext()){
+ CodeAllCode next = iterator.next();
+ if(codeAllCode.getId().equals(next.getId())){
+ codeAllCode.setCreateCodeOid(next.getCreateCodeOid());
+ codeAllCode.setLcStatus(next.getLcStatus());
+ // TODO: 杩欏効鍏堟殏鏃舵敞閲婃帀锛屾病鐪嬫噦杩欏効涓轰粈涔堣杩欐牱鍋氾紝瀵艰嚧鎶ラ敊
+ iterator.remove();
+ }
+ }*/
+ }
+ if(takeBack.size()>0){
+ codeAllCodeService.updateBatchById(takeBack);
+ }
- String serialUnitString = thisSerialUnitList.size() == 0 ? MdmEngineConstant.EMPTY_SERIAL_UNIT : thisSerialUnitList.stream().collect(Collectors.joining(MdmEngineConstant.SERIAL_UNIT_SPACE));
- switchSerialSecValue(serialSecVOList, attrSevIsSerialDepend, ruleVO, serialUnitString, maxSerialValueMap, thisSecValueList, lastMaxSerialValueMap, i == 0);
+ codeAllCodeService.saveBatch(addCodeDOs);
+ }
+ mdmEngineService.insertBatchByType(dataCBOList.get(0).getBtmname(),dataCBOList);
+ }
+ return codeList;
+ }else {
+ List<CodeBasicSecVO> secVOList = finalRuleVO.getSecVOList().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
+ List<String> serialUnitList = new LinkedList<>();
+ List<String> secValueList = new ArrayList<>();
+ Map<String, String> secValueMap = secDTOList.stream().collect(Collectors.toMap(s -> s.getSecOid(), s -> s.getSecValue()==null?"":s.getSecValue()));
+ List<CodeBasicSecVO> serialSecVOList = new ArrayList<>();
+ List<CodeBasicSecVO> attrSecVOList = new ArrayList<>();
+ for (int i = 0; i < secVOList.size(); i++) {
+ CodeBasicSecVO secVO = secVOList.get(i);
+ try{
+ switchSecValue(secVO, secValueMap, classifyFullInfoBO, serialSecVOList, attrSecVOList, serialUnitList, secValueList);
+ }catch (Exception e){
+ throw new ServiceException("鐮佸�艰浆鎹㈡椂鍑虹幇閿欒锛屽師鍥狅細"+e.getMessage());
+ }
+ }
+ //澶勭悊灞炴�х爜娈靛拰娴佹按鐮佹
+ Map<String/**娴佹按鐮佹鐨勪富閿�**/, Map<String/**娴佹按渚濇嵁**/, String>> lastMaxSerialValueMap = new HashMap<>();
+ List<CodeAllCode> allCodeDOList = new ArrayList<>();
- //缁勮缂栫爜鐨勫��
- cbo.setId(thisSecValueList.stream().collect(Collectors.joining()));
- codeList.add(cbo.getId());
- StringBuilder sb = new StringBuilder();
- //鎶婄爜娈甸噷闈㈤兘鎵句竴涓嬫祦姘村彿
- for (int j = 0; j < serialSecVOList.size(); j++) {
- CodeBasicSecVO secVO = serialSecVOList.get(j);
- Double serialValue = lastMaxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>()).getOrDefault(serialUnitString, 0d);
- if (serialValue != null) {
- sb.append(String.valueOf(serialValue.longValue())).append(MdmEngineConstant.SERIAL_VALUE_SPACE);
- }
- }
- //瑕佸瓨鍌ㄦ渶鍚庣殑鍏ㄩ儴allcode
- wrapperAllCode(classifyFullInfoBO, ruleVO, cbo, templateVO, allCodeDOList, serialUnitString, sb.toString());
- }
- batchCBO.copyFromOther(allCodeMapper.batchInsert(allCodeDOList));
- saveSerialValue(batchCBO, ruleVO, lastMaxSerialValueMap, maxSerialValueMap);
+ //宸茬粡瀛樺偍鐨勬渶澶ф祦姘村彿鐨勫唴瀹�
+ Map<String/**鐮佹鐨勪富閿�**/, Map<String, CodeSerialValue>> maxSerialValueMap = new HashMap<>();
- Map<String, String> statusMap = allCodeDOList.stream().collect(Collectors.toMap(s -> s.getOid(), s -> s.getLcStatus()));
- batchCBO.getCreateCbos().stream().filter(s -> StringUtils.equalsIgnoreCase("codeallcode",s.getBtmName())).forEach(s -> {
- s.setLcStatus(statusMap.get(s.getOid()));
- try {
- s.setAttributeValue("lcstatus",statusMap.get(s.getOid()));
- } catch (VCIError e) {
- e.printStackTrace();
- }
- });
+ for (int i = 0; i < dataCBOList.size(); i++) {
+ BaseModel cbo = dataCBOList.get(i);
+ cbo.getData().remove(CODE_SEC_LENGTH_FIELD);//灏嗘key闄ゅ幓
+ cbo.getData().remove(IMPORT_ROW_INDEX);//灏嗘key闄ゅ幓
+ cbo.getData().remove("codeclassifyid");//灏嗘key闄ゅ幓
+ List<String> thisSecValueList = new LinkedList<>();
+ for (int j = 0; j < secValueList.size(); j++) {
+ thisSecValueList.add(secValueList.get(j));
+ }
+ List<String> thisSerialUnitList = new LinkedList<>();
+ //鍥犱负娴佹按渚濇嵁姣忔鍙兘涓嶄竴鏍凤紝鎵�浠ユ瘡娆￠兘鎷疯礉涓�浠�
+ for (int j = 0; j < serialUnitList.size(); j++) {
+ thisSerialUnitList.add(serialUnitList.get(j));
+ }
+ //鍏堢湅鐪嬫湁娌℃湁灞炴�х殑鐮佹
+ boolean attrSevIsSerialDepend = CollectionUtils.isEmpty(attrSecVOList) ? false : (attrSecVOList.stream().anyMatch(s -> VciBaseUtil.getBoolean(s.getSerialDependFlag())));
+ switchAttrSecValue(attrSecVOList, cbo, thisSecValueList, attrSevIsSerialDepend, thisSerialUnitList);
+ String serialUnitString = thisSerialUnitList.size() == 0 ? EMPTY_SERIAL_UNIT : thisSerialUnitList.stream().collect(Collectors.joining(SERIAL_UNIT_SPACE));
+ switchSerialSecValue(cbo,serialSecVOList, attrSevIsSerialDepend, finalRuleVO, serialUnitString, maxSerialValueMap, thisSecValueList, lastMaxSerialValueMap, i == 0);
- }
- WebUtil.setPersistence(true);
- boService.persistenceBatch(batchCBO);
- return codeList;
- }
+ //缁勮缂栫爜鐨勫��
+ cbo.setId(thisSecValueList.stream().collect(Collectors.joining()));
+ codeList.add(cbo.getId());
+ StringBuilder sb = new StringBuilder();
+ //鎶婄爜娈甸噷闈㈤兘鎵句竴涓嬫祦姘村彿
+ for (int j = 0; j < serialSecVOList.size(); j++) {
+ CodeBasicSecVO secVO = serialSecVOList.get(j);
+ String serialValue = lastMaxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>()).getOrDefault(serialUnitString, "");
+ if (serialValue != null) {
+ sb.append(serialValue).append(SERIAL_VALUE_SPACE);
+ }
+ }
+ String codeDelimiter=thisSecValueList.stream().collect(Collectors.joining(SERIAL_VALUE_SPACE));
+ //瑕佸瓨鍌ㄦ渶鍚庣殑鍏ㄩ儴allcode
+ wrapperAllCode(classifyFullInfoBO, finalRuleVO, cbo, templateVO, allCodeDOList, serialUnitString, sb.toString(),codeDelimiter);
+ }
+ //澶勭悊鏈�澶ф祦姘�
+ saveSerialValue( finalRuleVO, lastMaxSerialValueMap, maxSerialValueMap);
- /**
- * 鍘婚櫎琛ヤ綅瀛楃
- * @param s 瀛楃
- * @param fillString 琛ヤ綅瀛楃
- * @param left 鏄惁宸﹁ˉ浣�
- * @return 鏇挎崲鍚庣殑鍊�
- */
- private String killFillChar(String s, String fillString,boolean left){
- Integer index = 0;
- String value = s;
- if(left){
- for (int i = 0; i < s.length(); i++) {
- char c = s.charAt(i);
- if((new String(new char[]{c})).equalsIgnoreCase(fillString)){
- index = i;
- }
- }
- if(index >0){
- value = value.substring(index);
- }
- }else{
- //浠庡彸寰�宸︽壘
- for (int i = s.length()-1; i >=0; i++) {
- char c = s.charAt(i);
- if((new String(new char[]{c})).equalsIgnoreCase(fillString)){
- index = i;
- }
- }
- if(index >0){
- value = value.substring(0,index);
- }
- }
- return value;
+ allCodeDOList.stream().forEach(
+ allCode -> {DefaultAttrAssimtUtil.addDefaultAttrAssimt(allCode,"codeallcode",user);allCode.setLctid("codeAllCodeLC");}
+ );
- }
+ Map<String, String> statusMap = allCodeDOList.stream().collect(Collectors.toMap(s -> s.getOid(), s -> s.getLcStatus()));
+ allCodeDOList.stream().filter(s -> StringUtils.equalsIgnoreCase("codeallcode",s.getBtmname())).forEach(s -> {
+ s.setLcStatus(statusMap.get(s.getOid()));
+ });
- /**
- * 鍘绘帀涓嶆槸鏁板瓧鐨勫瓧绗�
- * @param s 瀛楃
- * @return 鏇挎崲鍚庣殑鍊�
- */
- private String killUnNumberChar(String s){
- Integer lastUnNumberIndex = 0;
- for (int i = 0; i < s.length(); i++) {
- char c = s.charAt(i);
- if(!(new String(new char[]{c})).matches(RegExpConstant.NUMBER)){
- lastUnNumberIndex = i;
- }
- }
- String value = s;
- if(lastUnNumberIndex >0){
- value = value.substring(lastUnNumberIndex);
- }
- return value;
- }
+ //閫氳繃ID鏉ヨ繘琛屽幓閲�
+ List<CodeAllCode> distinctCodeAllCOdes = allCodeDOList.stream().collect(Collectors
+ .collectingAndThen(
+ Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(CodeAllCode::getId))),
+ ArrayList::new));
+ if(distinctCodeAllCOdes.size() != allCodeDOList.size() ){
+ throw new ServiceException("缂栫爜鏁版嵁閲嶅锛屾棤娉曚繚瀛橈紝璇锋敞鎰忥紒");
+ }
+ QueryWrapper<CodeAllCode> wrapper = new QueryWrapper<>();
+ wrapper.eq("CREATECODEBTM",allCodeDOList.get(0).getCreateCodeBtm());
+ wrapper.in("ID",allCodeDOList.stream().map(CodeAllCode::getId).collect(Collectors.toList()));
+ List<CodeAllCode> codeAllCodes = codeAllCodeService.selectByWrapper(wrapper);
+ List<CodeAllCode> takeBack = codeAllCodes.stream().filter(e -> e.getLcStatus().equals("TakeBack")).collect(Collectors.toList());
+ if(codeAllCodes.size()>takeBack.size()){
+ throw new ServiceException("鐢熸垚缂栫爜鏁版嵁ID宸叉湁鍘嗗彶璁板綍,璇风‘璁ゅ涓嬬敓鎴愮殑ID鏁版嵁锛�"+ allCodeDOList.stream().map(CodeAllCode::getId).collect(Collectors.toList()));
+ }
- /**
- * 鍥炴敹鐮佸��
- *
- * @param btmId 涓氬姟鏁版嵁鐨勪笟鍔＄被鍨�
- * @param businessOidCollection 涓氬姟鏁版嵁鐨勪富閿�
- * @return 鍙楀奖鍝嶇殑鏁版嵁鍐呭
- */
- @Override
- public BatchCBO recycleCode(String btmId, Collection<String> businessOidCollection) {
- boolean oldPersistence = WebUtil.isPersistence();
- WebUtil.setPersistence(false);
- BatchCBO batchCBO = new BatchCBO();
- VciBaseUtil.switchCollectionForOracleIn(businessOidCollection).stream().forEach(oids-> {
- Map<String, String> conditionMap = new HashMap<>();
- //缂栫爜瑕佽褰曚负鍥炴敹鐨勭姸鎬�
- conditionMap.put("createcodeoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oids.toArray(new String[0])) + ")");
- conditionMap.put("createcodebtm", btmId);
- List<CodeAllCodeDO> allCodeDOS = allCodeMapper.selectByCondition(conditionMap, new PageHelper(-1));
- if (!CollectionUtils.isEmpty(allCodeDOS)) {
- allCodeDOS.stream().forEach(codeDO->{
- codeDO.setLcStatus(CodeAllCodeLC.TASK_BACK.getValue());
- });
- batchCBO.copyFromOther(allCodeMapper.batchUpdate(allCodeDOS));
- }
- });
- WebUtil.setPersistence(oldPersistence);
- return batchCBO;
- }
+ for (CodeAllCode codeAllCode : takeBack) {
+ codeAllCode.setTs(new Date());
+ codeAllCode.setLastModifyTime(new Date());
+ codeAllCode.setLastModifier(Func.isNotEmpty(user) ? user.getAccount():AuthUtil.getUserAccount());
+ for (int i = 0; i < allCodeDOList.size(); i++) {
+ if(codeAllCode.getId().equals(allCodeDOList.get(i).getId())){
+ codeAllCode.setCreateCodeOid(allCodeDOList.get(i).getCreateCodeOid());
+ codeAllCode.setLcStatus(allCodeDOList.get(i).getLcStatus());
+ allCodeDOList.remove(i);
+ }
+ }
+ /*while (iterator.hasNext()){
+ CodeAllCode next = iterator.next();
+ if(codeAllCode.getId().equals(next.getId())){
+ codeAllCode.setCreateCodeOid(next.getCreateCodeOid());
+ codeAllCode.setLcStatus(next.getLcStatus());
+ //iterator.remove();
+ }
+ }*/
+ }
+ if(takeBack.size()>0){
+ codeAllCodeService.updateBatchById(takeBack);
+ }
+ codeAllCodeService.saveBatch(allCodeDOList);
+ mdmEngineService.insertBatchByType(dataCBOList.get(0).getBtmname(),dataCBOList);
+ }
+ return codeList;
+ }
- /**
- * 杞崲鐮佸�肩殑鍐呭
- * @param secVO 鐮佹鐨勫唴瀹�
- * @param secValueMap 鐮佸�肩殑鍐呭锛宬ey鏄爜娈电殑涓婚敭锛寁alue鏄爜鍊�
- * @param classifyFullInfoBO 鍒嗙被鐨勫叏閮ㄤ俊鎭�
- * @param serialSecVOList 娴佹按鐮佹
- * @param attrSecVOList 灞炴�х爜娈�
- * @param serialUnitList 娴佹按渚濇嵁
- * @param secValueList 鐮佸�煎垪琛�
- */
- private void switchSecValue(CodeBasicSecVO secVO,Map<String,String> secValueMap,
- CodeClassifyFullInfoBO classifyFullInfoBO,List<CodeBasicSecVO> serialSecVOList,
- List<CodeBasicSecVO> attrSecVOList, List<String> serialUnitList,
- List<String> secValueList ){
- CodeSecTypeEnum secType = CodeSecTypeEnum.forValue(secVO.getSectype());
- String secValue = secValueMap.getOrDefault(secVO.getOid(), "");
- switch (secType) {
- case CODE_FIXED_SEC:
- //鍥哄畾鐮佹鐨勶紝鐩存帴鐢ㄧ爜鍊�,涓嶈鐮佸�肩殑闀垮害鏄灏戯紝鍥犱负鍙彉闀垮害鍜屽浐瀹氶暱搴︽槸鎺у埗鍦ㄧ爜娈电鐞嗛噷闈㈢殑鐮佸�煎畾涔夌殑
- break;
- case CODE_DATE_SEC:
- //鏃堕棿鐮佹锛岄渶瑕佸皢褰撳墠鏃堕棿渚濇嵁鏃堕棿鏍煎紡杩涜杞崲.
- //鏃堕棿鐮佹涓嶆秹鍙婂埌鏄惁琛ヤ綅
- secValue = VciDateUtil.date2Str(new Date(), secVO.getCodeDateFormatStr());
- break;
- case CODE_CLASSIFY_SEC:
- //鍒嗙被鐮佹鐨勶紝涔熸槸浠庡墠绔�夋嫨浜嗙爜鍊煎嵆鍙紝涓嶈鐮佸�肩殑闀垮害鏄灏�
- break;
- case CODE_LEVEL_SEC:
- //灞傜骇鐮佹锛岄渶瑕佷粠鍒嗙被涓婅幏鍙栫浉搴旂殑淇℃伅
- if (CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(secVO.getCodeLevelType())) {
- //鏈�灏忓眰锛屽洜涓烘垜浠彧鑳藉湪鍙跺瓙鑺傜偣涓婄敵璇风紪鐮侊紝鎵�浠ヨ繖涓氨鏄綋鍓嶅垎绫荤殑
- if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType()) || CollectionUtils.isEmpty(classifyFullInfoBO.getParentClassifyVOs())) {
- //灏辨槸褰撳墠鍒嗙被鐨�
- secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
- } else {
- //鎴戜滑闇�瑕佷粠椤跺眰寮�濮嬫壘鍒板綋鍓嶅垎绫讳负姝�
- secValue = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel()))).map(CodeClassifyVO::getId).collect(Collectors.joining()) + classifyFullInfoBO.getCurrentClassifyVO().getId();
- }
- } else {
- //鎸囧畾灞傦紝鎴戜滑闇�瑕侀�氳繃涓婄骇鐨勬潵鑾峰彇
- if (CollectionUtils.isEmpty(classifyFullInfoBO.getParentClassifyVOs())) {
- //璇存槑褰撳墠宸茬粡鏄渶楂樼殑浜�
- secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
- } else {
- //杩欎釜鎴戜滑闇�瑕佺湅鐪�,灞傜骇鏄笉鏄ぇ浜庝簡鏈�澶у眰绾х殑鏁�
- List<CodeClassifyVO> parentClassifyVOList = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel()))).collect(Collectors.toList());
- if (secVO.getCodeLevelValue() > (parentClassifyVOList.size() + 1)) {
- //鎸囧畾鐨勫眰绾ф瘮褰撳墠鐨勫眰绾ц繕澶т簡锛屾墍浠ュ彧鑳借幏鍙栧綋鍓嶅眰绾т簡
- if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType())) {
- secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
- } else {
- secValue = parentClassifyVOList.stream().map(CodeClassifyVO::getId).collect(Collectors.joining()) + classifyFullInfoBO.getCurrentClassifyVO().getId();
- }
- } else {
- //鎴戜滑鑾峰彇鍏朵腑鎸囧畾灞傜殑鍐呭
- if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType())) {
- CodeClassifyVO classifyVO = parentClassifyVOList.stream().filter(s -> s.getDataLevel().intValue() == secVO.getCodeLevelValue().intValue()).findFirst().orElseGet(() -> null);
- if (classifyVO != null) {
- secValue = classifyVO.getId();
- }
- } else {
- //灏忎簬绛変簬鐨勫叏閮ㄦ嬁鍑烘潵
- secValue = parentClassifyVOList.stream().filter(s -> s.getDataLevel().intValue() <= secVO.getCodeLevelValue().intValue()).sorted(((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel()))).map(CodeClassifyVO::getId).collect(Collectors.joining());
- }
- }
- }
- }
- //鐪嬬湅闀垮害鏄惁闇�瑕佹埅鏂�
- if (!CodeCutTypeEnum.NONE.getValue().equalsIgnoreCase(secVO.getValueCutType()) &&
- secVO.getValueCutLength() != null && secVO.getValueCutLength() > 0 && secValue.length() > secVO.getValueCutLength()) {
- if (CodeCutTypeEnum.RIGHT.getValue().equalsIgnoreCase(secVO.getValueCutType())) {
- //宸︽埅鍙栨槸浠庡乏杈瑰壀鎺夛紝鍙虫埅鍙栨槸浠庡彸杈瑰壀鎺�--淇濈暀宸﹁竟
- secValue = secValue.substring(0, secVO.getValueCutLength());
- } else {
- secValue = secValue.substring(secValue.length() - secVO.getValueCutLength());
- }
- }
- break;
- case CODE_REFER_SEC:
- //寮曠敤鐨勫湪椤甸潰涓婂凡缁忛�夋嫨浜嗭紝鎵�浠ョ洿鎺ヤ娇鐢ㄥ墠绔笂浼犻�掔殑鍊�
- //寮曠敤灏辨槸鍙傜収锛屽彲鑳芥槸鍏朵粬鐨勫垎绫伙紙涓氬姟绫诲瀷锛変笅鐨勬暟鎹紝鎵�浠ュ彧鍦ㄩ〉闈笂閫夋嫨
- break;
- case CODE_ATTR_SEC:
- //灞炴�т笌寮曠敤鐨勫尯鍒槸锛屽睘鎬ф槸褰撳墠鏁版嵁閲岀殑灞炴�э紝鑰屽紩鐢ㄥ彲鑳芥槸寮曠敤鍏朵粬鐨勫垎绫荤殑锛堜笟鍔＄被鍨嬶級
- //鍥犱负鍙兘鏄壒閲忕殑鏁版嵁鐨勬搷浣滐紝鎵�浠ユ垜浠繖閲屼笉鑳界洿鎺ュ鐞嗗睘鎬э紝闇�瑕佸悗杈逛竴杈瑰鐞�
- secValue = "${attr_" + secVO.getOid() + "}";
- attrSecVOList.add(secVO);
- break;
- case CODE_VARIABLE_SEC:
- //鍙彉鐮佹锛屾槸鍦ㄩ〉闈笂杈撳叆鍐呭
- if (secValue.length() > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
- throw new VciBaseException("銆恵0}銆戣繖涓爜娈垫槸鍙彉鐮佹锛屼絾鏄幇鍦ㄨ緭鍏ョ殑鐮佸�肩殑闀垮害({1})瓒呰繃浜嗚瀹氱殑闀垮害{2}", new String[]{secVO.getName(), String.valueOf(secValue.length()), secVO.getCodeSecLength()});
- }
- OsCodeFillTypeEnum fillTypeEnum = OsCodeFillTypeEnum.forValue(secVO.getCodeFillType());
- secValue = fillString(VciBaseUtil.getInt(secVO.getCodeSecLength()), fillTypeEnum, secValue, secVO.getCodeFillSeparator());
- break;
- case CODE_SERIAL_SEC:
- //娴佹按鐮佹
- serialSecVOList.add(secVO);
- secValue = "${" + secVO.getOid() + "}";
- default:
- break;
- }
- if (VciBaseUtil.getBoolean(secVO.getSerialDependFlag())) {
- serialUnitList.add(secValue);
- }
- secValueList.add(secValue);
- }
-
-
- /**
- * 琛ヤ綅
- * @param totalLength 鎬婚暱搴�
- * @param fillTypeEnum 琛ヤ綅鏂瑰紡
- * @param text 褰撳墠鐨勫唴瀹�
- * @param fillChar 琛ヤ綅鐨勫瓧绗�
- * @return 涓嶅～鍏呬綅缃拰闀垮害宸茬粡杈惧埌/瓒呰繃鐨勬椂鍊欎笉浼氬～鍏�
- */
- private String fillString(int totalLength,OsCodeFillTypeEnum fillTypeEnum,String text,String fillChar){
- if(text.length() >= totalLength || OsCodeFillTypeEnum.NONE.equals(fillTypeEnum)){
- //涓嶇敤琛ヤ綅浜�
- return text;
- }
- int balance = totalLength - text.length();
- StringBuilder sb = new StringBuilder();
- for (int i = 0; i < balance; i++) {
- sb.append(fillChar);
- }
- if(OsCodeFillTypeEnum.LEFT.equals(fillTypeEnum)) {
- text = sb.toString() + text;
- }else {
- text = text + sb.toString();
- }
- return text;
- }
-
- /**
- * 杞崲灞炴�х爜娈电殑鍊�
- * @param attrSecVOList 灞炴�х爜娈电殑鏄剧ず瀵硅薄
- * @param cbo 涓氬姟鏁版嵁锛岀敤浜庤幏鍙栫爜娈电殑鍊�
- * @param thisSecValueList 鐮佸�肩殑鍒楄〃
- * @param attrSevIsSerialDepend 鏄惁鏈変綔涓烘祦姘翠緷鎹�
- * @param serialUnitList 娴佹按渚濇嵁鐨勫唴瀹�
- */
- private void switchAttrSecValue(List<CodeBasicSecVO> attrSecVOList,ClientBusinessObject cbo,
- List<String> thisSecValueList,boolean attrSevIsSerialDepend,
+ /**
+ * 杞崲灞炴�х爜娈电殑鍊�
+ * @param attrSecVOList 灞炴�х爜娈电殑鏄剧ず瀵硅薄
+ * @param cbo 涓氬姟鏁版嵁锛岀敤浜庤幏鍙栫爜娈电殑鍊�
+ * @param thisSecValueList 鐮佸�肩殑鍒楄〃
+ * @param attrSevIsSerialDepend 鏄惁鏈変綔涓烘祦姘翠緷鎹�
+ * @param serialUnitList 娴佹按渚濇嵁鐨勫唴瀹�
+ * 杩橀渶瑕佸悗缁殑涓�涓Щ妞嶅皢浼氭秹鍙婂埌鍏朵粬鐨勬湇鍔�
+ */
+ private void switchAttrSecValue(List<CodeBasicSecVO> attrSecVOList, BaseModel cbo,
+ List<String> thisSecValueList, boolean attrSevIsSerialDepend,
List<String> serialUnitList){
- if (!CollectionUtils.isEmpty(attrSecVOList)) {
- attrSecVOList.stream().forEach(attrSevVO -> {
- String value = "";
- if (StringUtils.isNotBlank(attrSevVO.getGetValueClass())) {
- //浣跨敤缁勫悎瑙勫垯鏉ュ鐞嗙殑
- value = getValueByFormulaForCBO(cbo, attrSevVO.getGetValueClass());
- } else {
- value = cbo.getAttributeValue(attrSevVO.getReferAttributeId());
- }
- if (value == null) {
- value = "";
- }
- //鏇挎崲secValueList閲岄潰鐨勫唴瀹�
- for (int j = 0; j < thisSecValueList.size(); j++) {
- String secValue = thisSecValueList.get(j);
- if (secValue.equalsIgnoreCase("${attr_" + attrSevVO.getOid() + "}")) {
- thisSecValueList.set(j, value);
- }
- }
- if (attrSevIsSerialDepend) {
- //鏄祦姘翠緷璧栫殑璇濓紝闇�瑕佸幓鏇挎崲涓�涓�
- for (int j = 0; j < serialUnitList.size(); j++) {
- String secValue = serialUnitList.get(j);
- if (secValue.equalsIgnoreCase("${attr_" + attrSevVO.getOid() + "}")) {
- serialUnitList.set(j, value);
- }
- }
- }
- });
- }
- }
+ if (!CollectionUtils.isEmpty(attrSecVOList)) {
+ attrSecVOList.stream().forEach(attrSevVO -> {
+ String value = "";
+ if (StringUtils.isNotBlank(attrSevVO.getGetValueClass())) {
+ //浣跨敤缁勫悎瑙勫垯鏉ュ鐞嗙殑
+ value = getValueByFormulaForCBO(cbo, attrSevVO.getGetValueClass());
+ } else {
+ value = cbo.getData().get(attrSevVO.getReferAttributeId());
+ }
+ if (value == null) {
+ value = "";
+ }
+ //鏇挎崲secValueList閲岄潰鐨勫唴瀹�
+ for (int j = 0; j < thisSecValueList.size(); j++) {
+ String secValue = thisSecValueList.get(j);
+ if (secValue.equalsIgnoreCase("${attr_" + attrSevVO.getOid() + "}")) {
+ // TODO: 灞炴�х爜娈电敓鎴愮爜鍊煎悗锛屾嫾鎺ュ墠鍚庣紑
+ thisSecValueList.set(j, joinPreffixAndSuffix(attrSevVO,value));
+ }
+ }
+ if (attrSevIsSerialDepend) {
+ //鏄祦姘翠緷璧栫殑璇濓紝闇�瑕佸幓鏇挎崲涓�涓�
+ for (int j = 0; j < serialUnitList.size(); j++) {
+ String secValue = serialUnitList.get(j);
+ if (secValue.equalsIgnoreCase("${attr_" + attrSevVO.getOid() + "}")) {
+ serialUnitList.set(j, joinPreffixAndSuffix(attrSevVO,value));
+ }
+ }
+ }
+ });
+ }
+ }
- /**
- * 浣跨敤CBO澶勭悊缁勫悎瑙勫垯鐨勫唴瀹�
- * @param cbo 鏁版嵁鐨勫唴瀹�
- * @param rule 瑙勫垯鐨勫唴瀹�
- * @return 杞崲鍚庣殑
- */
- private String getValueByFormulaForCBO(ClientBusinessObject cbo,String rule){
- Map<String,String> dataMap = new HashMap<>();
- WebUtil.copyValueToMapFromCbos(cbo,dataMap);
- return formulaService.getValueByFormula(dataMap,rule);
- }
+ /**
+ * 杞崲娴佹按鐮佹鐨勫��
+ * @param serialSecVOList 娴佹按鐮佹
+ * @param secDTOS;娴佹按鍊�
+ * @param attrSevIsSerialDepend 鏄惁鏈夊睘鎬х爜娈靛弬涓庢祦姘�
+ * @param ruleVO 瑙勫垯鐨勫唴瀹�
+ * @param serialUnitMap 娴佹按渚濇嵁
+ * @param maxSerialValueMap 鏈�澶х殑娴佹按鍙�
+ * @param thisSecValueList 鏈鐨勭爜鍊�
+ * @param lastMaxSerialValueMap 灏佽鍚�
+ * @param firstData 鏄惁涓虹涓�鏉℃暟鎹�
+ */
+ private void switchSerialSecValueBZ(BaseModel cbo,List<CodeOrderSecDTO> secDTOS, List<CodeBasicSecVO> serialSecVOList,boolean attrSevIsSerialDepend,
+ CodeRuleVO ruleVO,Map<String,String> serialUnitMap,
+ Map<String/**鐮佹鐨勪富閿�**/,Map<String/**娴佹按渚濇嵁**/,CodeSerialValue>> maxSerialValueMap,List<String> thisSecValueList,
+ Map<String/**鐮佹鐨勪富閿�**/,Map<String/**娴佹按渚濇嵁**/, String>> lastMaxSerialValueMap,boolean firstData){
+ if (!CollectionUtils.isEmpty(serialSecVOList)) {
+ Map<String/**鐮佹oid**/, String/**鐮佹鐮佸��**/> attrNameIdMap = secDTOS.stream().collect(Collectors.toMap(s -> s.getSecOid(), t -> t.getSecValue().toLowerCase(Locale.ROOT),(o1, o2)->o2));
+ Map<String,String> secIdserialValueMap=new LinkedHashMap<>();
+ for (int j = 0; j < serialSecVOList.size(); j++) {
+ AtomicReference<String> serialUnitString= new AtomicReference<>("");
+ CodeBasicSecVO secVO = serialSecVOList.get(j);
+ String secVOValue="";
+ if(attrNameIdMap.containsKey(secVO.getOid())){
+ secVOValue=attrNameIdMap.get(secVO.getOid());
+ if(StringUtils.isNotBlank(secVOValue)){
+ continue;
+ }
+ }
+ if(serialUnitMap.containsKey(secVO.getOid())){
+ serialUnitString.set(serialUnitMap.get(secVO.getOid()));
+ secIdserialValueMap.forEach((key,vaule)->{
+ serialUnitString.set(serialUnitString.get().replace("${"+key+"}", vaule));
+ });
+ if (attrSevIsSerialDepend || firstData) {
+ QueryWrapper<CodeSerialValue> codeSerialWrapper = new QueryWrapper<>();
+ codeSerialWrapper.eq("codeRuleOid", ruleVO.getOid());
+ codeSerialWrapper.eq("serialUnit", serialUnitString.get());
+ codeSerialWrapper.eq("codeSecOid", secVO.getOid());
+ List<CodeSerialValue> serialValueDOS = serialValueMapper.selectList(codeSerialWrapper);
+ if (!CollectionUtils.isEmpty(serialValueDOS)) {
+ Map<String, CodeSerialValue> unitSerialMap = maxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>());
+ CodeSerialValue serialValueDO = serialValueDOS.get(0);
+ unitSerialMap.put(serialValueDO.getSerialUnit(),serialValueDO);
+ maxSerialValueMap.put(secVO.getOid(), unitSerialMap);
+ }
+ }
+ String serialString="";
+ String thisSerialValue = "";
+ String startValue = null;
+ if (maxSerialValueMap.containsKey(secVO.getOid()) && maxSerialValueMap.get(secVO.getOid()).containsKey(serialUnitString.get())) {
+ startValue = maxSerialValueMap.get(secVO.getOid()).get(serialUnitString.get()).getMaxSerial();
+ }
+ if (lastMaxSerialValueMap.containsKey(secVO.getOid()) && lastMaxSerialValueMap.get(secVO.getOid()).containsKey(serialUnitString.get())) {
+ //璇存槑澶氫釜鐢宠锛屼箣鍓嶅凡缁忓姞浜嗘祦姘村彿浜�
+ startValue = lastMaxSerialValueMap.get(secVO.getOid()).get(serialUnitString.get());
+ }
+ if(StringUtils.isNotBlank(secVO.getCustomCodeSerialClass())){//鑷畾涔夋祦姘村鐞�
+ String currentFlowValue=startValue;
+ CodeCustomSerialDTO codeCustomSerialDTO=new CodeCustomSerialDTO();
+ codeCustomSerialDTO.setSerialUnitString(serialUnitString.get());
+ codeCustomSerialDTO.setSerialCodeCodeBasicSec(secVO);
+ codeCustomSerialDTO.setCurrentFlowValue(startValue);
+ codeCustomSerialDTO.setCodeBasicSecVOList(ruleVO.getSecVOList());
+ codeCustomSerialDTO.setCodeRuleOid(ruleVO.getOid());
+ codeCustomSerialDTO.setBaseModel(cbo);
+ codeCustomSerialDTO.setSerialUnitString(serialUnitString.get());
+ codeCustomSerialDTO.setSecValueList(thisSecValueList);
+ thisSerialValue=customCodeSerial(secVO.getCustomCodeSerialClass(),codeCustomSerialDTO);
+ serialUnitString.set(codeCustomSerialDTO.getSerialUnitString());
+ log.info(secVO.getCustomCodeSerialClassText()+"---->"+thisSerialValue);
+ }else {
+ Double newThisSerialValue = 0d;
+ if (startValue == null) {
+ //绗竴涓紪鐮�
+ newThisSerialValue = VciBaseUtil.getDouble(secVO.getSerialStart());
+ } else {
+ //娴佹按鍙疯偗瀹氭槸鏁板瓧
+ newThisSerialValue = Double.parseDouble(startValue) + (j + 1) * secVO.getSerialStep();
+ }
+ //瑕佺湅鏄惁瓒呰繃鏈�澶х殑娴佹按鍊�
+ if (newThisSerialValue >= secVO.getCodeFillLimit()) {
+ throw new VciBaseException("娴佹按鍙峰凡缁忚秴杩囧厑璁哥殑鏈�澶ф祦姘村�納0}", new String[]{secVO.getCodeFillLimit().toString()});
+ }
+ thisSerialValue=String.valueOf(newThisSerialValue.intValue());
+ }
+ //瑕佺湅琛ヤ綅鐨勫唴瀹�
+ Integer fillLength = VciBaseUtil.getInt(secVO.getCodeFillLength());
+ if (fillLength == 0 || fillLength > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
+ //闃叉鍦ㄦ坊鍔犵殑鍦版柟娌℃湁鎺у埗姝ｇ‘
+ fillLength = VciBaseUtil.getInt(secVO.getCodeSecLength());
+ }
+ serialString = thisSerialValue;
+ serialString = fillString(fillLength, OsCodeFillTypeEnum.forValue(secVO.getCodeFillType()), serialString, secVO.getCodeFillSeparator());
+ for (int z = 0; z < thisSecValueList.size(); z++) {
+ String secValue = thisSecValueList.get(z);
+ if (secValue.equalsIgnoreCase("${" + secVO.getOid() + "}")) {
+ // TODO: 娴佹按鐢熸垚鐮佸�煎悗鎷兼帴鍓嶅悗缂�
+ thisSecValueList.set(z, joinPreffixAndSuffix(secVO, serialString));
+ }
+ }
+ secIdserialValueMap.put(secVO.getOid(),thisSerialValue);//璁板綍娴佹按鐮佹褰撳墠鐨勫��
+ if(StringUtils.isNotBlank(thisSerialValue)) {
+ Map<String, String> unitSerialMap = lastMaxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>());
+ unitSerialMap.put(serialUnitString.get(), String.valueOf(thisSerialValue));
+ lastMaxSerialValueMap.put(secVO.getOid(), unitSerialMap);
+ }
+ }
+ }
+ }
+ }
- /**
- * 杞崲娴佹按鐮佹鐨勫��
- * @param serialSecVOList 娴佹按鐮佹
- * @param attrSevIsSerialDepend 鏄惁鏈夊睘鎬х爜娈靛弬涓庢祦姘�
- * @param ruleVO 瑙勫垯鐨勫唴瀹�
- * @param serialUnitString 娴佹按渚濇嵁
- * @param maxSerialValueMap 鏈�澶х殑娴佹按鍙�
- * @param thisSecValueList 鏈鐨勭爜鍊�
- * @param lastMaxSerialValueMap 灏佽鍚�
- * @param firstData 鏄惁涓虹涓�鏉℃暟鎹�
- */
- private void switchSerialSecValue(List<CodeBasicSecVO> serialSecVOList,boolean attrSevIsSerialDepend,
- CodeRuleVO ruleVO,String serialUnitString,
- Map<String/**鐮佹鐨勪富閿�**/,Map<String/**娴佹按渚濇嵁**/,CodeSerialValueDO>> maxSerialValueMap,List<String> thisSecValueList,
- Map<String/**鐮佹鐨勪富閿�**/,Map<String/**娴佹按渚濇嵁**/, Double>> lastMaxSerialValueMap,boolean firstData){
- if (!CollectionUtils.isEmpty(serialSecVOList)) {
- for (int j = 0; j < serialSecVOList.size(); j++) {
- CodeBasicSecVO secVO = serialSecVOList.get(j);
- if (attrSevIsSerialDepend || firstData) {
- //濡傛灉灞炴�х爜娈典篃鏄緷璧栵紝鍒欐瘡娆￠兘瑕佹煡璇紝濡傛灉灞炴�х爜娈典笉鏄緷璧栵紝鍒欏彧鏌ヨ涓�娆�
- Map<String, String> conditionMap = new HashMap<>();
- conditionMap.put("codeRuleOid", ruleVO.getOid());
- conditionMap.put("serialUnit", serialUnitString);
- //杩欎釜瀛楁鏄负浜嗚В鍐冲涓祦姘寸殑闂
- conditionMap.put("codeSecOid", secVO.getOid());
- List<CodeSerialValueDO> serialValueDOS = serialValueMapper.selectByCondition(conditionMap, new PageHelper(-1));
- if (!CollectionUtils.isEmpty(serialValueDOS)) {
- Map<String, CodeSerialValueDO> unitSerialMap = maxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>());
- CodeSerialValueDO serialValueDO = serialValueDOS.get(0);
- unitSerialMap.put(serialValueDO.getSerialUnit(),serialValueDO);
- maxSerialValueMap.put(secVO.getOid(), unitSerialMap);
- }
- }
- Double startValue = null;
- if(maxSerialValueMap.containsKey(secVO.getOid()) && maxSerialValueMap.get(secVO.getOid()).containsKey(serialUnitString)){
- startValue = VciBaseUtil.getDouble(maxSerialValueMap.get(secVO.getOid()).get(serialUnitString).getMaxSerial());
- }
- if(lastMaxSerialValueMap.containsKey(secVO.getOid()) && lastMaxSerialValueMap.get(secVO.getOid()).containsKey(serialUnitString)){
- //璇存槑澶氫釜鐢宠锛屼箣鍓嶅凡缁忓姞浜嗘祦姘村彿浜�
- startValue = lastMaxSerialValueMap.get(secVO.getOid()).get(serialUnitString);
- }
- Double thisSerialValue = 0d;
- if (startValue == null) {
- //绗竴涓紪鐮�
- thisSerialValue = VciBaseUtil.getDouble(secVO.getSerialStart());
- } else {
- //娴佹按鍙疯偗瀹氭槸鏁板瓧
- thisSerialValue = startValue + (j + 1) * secVO.getSerialStep();
- }
- //瑕佺湅鏄惁瓒呰繃鏈�澶х殑娴佹按鍊�
- if (thisSerialValue >= secVO.getCodeFillLimit()) {
- throw new VciBaseException("娴佹按鍙峰凡缁忚秴杩囧厑璁哥殑鏈�澶ф祦姘村�納0}",new String[]{secVO.getCodeFillLimit().toString()});
- }
- //瑕佺湅琛ヤ綅鐨勫唴瀹�
- Integer fillLength = VciBaseUtil.getInt(secVO.getCodeFillLength());
- if (fillLength == 0 || fillLength > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
- //闃叉鍦ㄦ坊鍔犵殑鍦版柟娌℃湁鎺у埗姝ｇ‘
- fillLength = VciBaseUtil.getInt(secVO.getCodeSecLength());
- }
- String serialString = String.valueOf(thisSerialValue.longValue());
- serialString = fillString(fillLength, OsCodeFillTypeEnum.forValue(secVO.getCodeFillType()), serialString, secVO.getCodeFillSeparator());
- for (int z = 0; z < thisSecValueList.size(); z++) {
- String secValue = thisSecValueList.get(z);
- if (secValue.equalsIgnoreCase("${" + secVO.getOid() + "}")) {
- thisSecValueList.set(z, serialString);
- }
- }
- Map<String, Double> unitSerialMap = lastMaxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>());
- unitSerialMap.put(serialUnitString, thisSerialValue);
- lastMaxSerialValueMap.put(secVO.getOid(),unitSerialMap);
- }
- }
- }
+ /**
+ * 杞崲娴佹按鐮佹鐨勫��
+ * @param serialSecVOList 娴佹按鐮佹
+ * @param attrSevIsSerialDepend 鏄惁鏈夊睘鎬х爜娈靛弬涓庢祦姘�
+ * @param ruleVO 瑙勫垯鐨勫唴瀹�
+ * @param serialUnitString 娴佹按渚濇嵁
+ * @param maxSerialValueMap 鏈�澶х殑娴佹按鍙�
+ * @param thisSecValueList 鏈鐨勭爜鍊�
+ * @param lastMaxSerialValueMap 灏佽鍚�
+ * @param firstData 鏄惁涓虹涓�鏉℃暟鎹�
+ */
+ private void switchSerialSecValue(BaseModel cbo, List<CodeBasicSecVO> serialSecVOList,boolean attrSevIsSerialDepend,
+ CodeRuleVO ruleVO,String serialUnitString,
+ Map<String/**鐮佹鐨勪富閿�**/,Map<String/**娴佹按渚濇嵁**/,CodeSerialValue>> maxSerialValueMap,List<String> thisSecValueList,
+ Map<String/**鐮佹鐨勪富閿�**/,Map<String/**娴佹按渚濇嵁**/, String>> lastMaxSerialValueMap,boolean firstData){
+ if (!CollectionUtils.isEmpty(serialSecVOList)) {
+ Map<String,String> secIdserialValueMap=new LinkedHashMap<>();
+ for (int j = 0; j < serialSecVOList.size(); j++) {
+ CodeBasicSecVO secVO = serialSecVOList.get(j);
+ String secVOValue="";
+ AtomicReference<String> newSerialUnitString= new AtomicReference<>(serialUnitString);
+ if(j==0){
+ secVOValue="";
+ newSerialUnitString.set(serialUnitString.replace("${" + secVO.getOid() + "}", secVOValue));
+ }else{
+ CodeBasicSecVO upSecVO =serialSecVOList.get(j-1);
+ secIdserialValueMap.forEach((key,vaule)->{
+ newSerialUnitString.set(serialUnitString.replace("${"+key+"}", vaule));
+ });
+ }
- /**
- * 灏佽瀛樺偍鐮佸�肩殑瀵硅薄
- * @param classifyFullInfoBO 鍒嗙被鍏ㄩ儴鐨勪俊鎭�
- * @param ruleVO 瑙勫垯鐨勫唴瀹�
- * @param cbo 涓氬姟鏁版嵁
- * @param templateVO 妯℃澘鐨勪俊鎭�
- * @param allCodeDOList 鎵�鏈夌殑鐮佸�肩殑瀵硅薄鍒楄〃
- */
- private void wrapperAllCode(CodeClassifyFullInfoBO classifyFullInfoBO,CodeRuleVO ruleVO,
- ClientBusinessObject cbo,CodeClassifyTemplateVO templateVO,
- List<CodeAllCodeDO> allCodeDOList,String serialUnitString,String serialValueString){
- CodeAllCodeDO allCodeDO = new CodeAllCodeDO();
- allCodeDO.setCodeClassifyOid(classifyFullInfoBO.getCurrentClassifyVO().getOid());
- allCodeDO.setCodeRuleOid(ruleVO.getOid());
- allCodeDO.setId(cbo.getId());
- allCodeDO.setCodeClassifyTemplateOid(templateVO.getOid());
- allCodeDO.setCreateCodeBtm(cbo.getBtmName());
- allCodeDO.setCreateCodeOid(cbo.getOid());
- allCodeDO.setSerialUnit(serialUnitString);
- allCodeDO.setUnFillSerial(serialValueString);
- allCodeDO.setLcStatus(cbo.getLcStatus());
- allCodeDOList.add(allCodeDO);
- }
+ if (attrSevIsSerialDepend || firstData) {
+ //濡傛灉灞炴�х爜娈典篃鏄緷璧栵紝鍒欐瘡娆￠兘瑕佹煡璇紝濡傛灉灞炴�х爜娈典笉鏄緷璧栵紝鍒欏彧鏌ヨ涓�娆�
+// Map<String, String> conditionMap = new HashMap<>();
+// conditionMap.put("codeRuleOid", ruleVO.getOid());
+// conditionMap.put("serialUnit", serialUnitString);
+// //杩欎釜瀛楁鏄负浜嗚В鍐冲涓祦姘寸殑闂
+// conditionMap.put("codeSecOid", secVO.getOid());
+ QueryWrapper<CodeSerialValue> codeSerialWrapper = new QueryWrapper<>();
- /**
- * 淇濆瓨娴佹按鐨勪俊鎭�
- * @param batchCBO 鏁版嵁瀛樺偍瀹瑰櫒
- * @param ruleVO 瑙勫垯鐨勬樉绀哄璞�
- * @param lastMaxSerialValueMap 鏈�澶х殑娴佹按鍊兼槧灏�
- * @param maxSerialValueMap 渚濇嵁瀛樺偍鐨勬渶澶ф祦姘寸殑鍐呭
- */
- private void saveSerialValue(BatchCBO batchCBO,CodeRuleVO ruleVO,
- Map<String/**鐮佹鐨勪富閿�**/,Map<String, Double>> lastMaxSerialValueMap,
- Map<String/**鐮佹鐨勪富閿�**/,Map<String, CodeSerialValueDO>> maxSerialValueMap){
- List<CodeSerialValueDO> editSerialValueDOList = new ArrayList<>();
- List<CodeSerialValueDO> addSerialValueDOList = new ArrayList<>();
- //瀛樺偍鏈�澶ф祦姘村彿
- lastMaxSerialValueMap.forEach((secOid,maxSerialMap)->{
- maxSerialMap.forEach((unit,maxSerial)->{
- CodeSerialValueDO serialValueDO = null;
- if(maxSerialValueMap.containsKey(secOid) && maxSerialValueMap.get(secOid).containsKey(unit)){
- //璇存槑鏈�
- serialValueDO = maxSerialValueMap.get(secOid).get(unit);
- serialValueDO.setMaxSerial(maxSerial.toString());
- editSerialValueDOList.add(serialValueDO);
- }else{
- serialValueDO = new CodeSerialValueDO();
- serialValueDO.setCodeRuleOid(ruleVO.getOid());
- serialValueDO.setSerialUnit(unit);
- serialValueDO.setCodeSecOid(secOid);
- serialValueDO.setMaxSerial(maxSerial.toString());
- addSerialValueDOList.add(serialValueDO);
- }
- });
- });
- if(!CollectionUtils.isEmpty(editSerialValueDOList)){
- batchCBO.copyFromOther(serialValueMapper.batchUpdate(editSerialValueDOList));
- }
- if(!CollectionUtils.isEmpty(addSerialValueDOList)){
- batchCBO.copyFromOther(serialValueMapper.batchInsert(addSerialValueDOList));
- }
- }
+ codeSerialWrapper.eq("codeRuleOid", ruleVO.getOid());
+ codeSerialWrapper.eq("serialUnit", newSerialUnitString.get());
+ codeSerialWrapper.eq("codeSecOid", secVO.getOid());
+ List<CodeSerialValue> serialValueDOS = serialValueMapper.selectList(codeSerialWrapper);
+ if (!CollectionUtils.isEmpty(serialValueDOS)) {
+ Map<String, CodeSerialValue> unitSerialMap = maxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>());
+ CodeSerialValue serialValueDO = serialValueDOS.get(0);
+ unitSerialMap.put(serialValueDO.getSerialUnit(),serialValueDO);
+ maxSerialValueMap.put(secVO.getOid(), unitSerialMap);
+ }
+ }
+ String serialString="";
+ String thisSerialValue = "";
+ String startValue = null;
+ if (maxSerialValueMap.containsKey(secVO.getOid()) && maxSerialValueMap.get(secVO.getOid()).containsKey(newSerialUnitString.get())) {
+ startValue = maxSerialValueMap.get(secVO.getOid()).get(newSerialUnitString.get()).getMaxSerial();
+ }
+ if (lastMaxSerialValueMap.containsKey(secVO.getOid()) && lastMaxSerialValueMap.get(secVO.getOid()).containsKey(newSerialUnitString.get())) {
+ //璇存槑澶氫釜鐢宠锛屼箣鍓嶅凡缁忓姞浜嗘祦姘村彿浜�
+ startValue = lastMaxSerialValueMap.get(secVO.getOid()).get(newSerialUnitString.get());
+ }
+ if(StringUtils.isNotBlank(secVO.getCustomCodeSerialClass())){//鑷畾涔夋祦姘村鐞�
+ String currentFlowValue=startValue;
+ CodeCustomSerialDTO codeCustomSerialDTO=new CodeCustomSerialDTO();
+ codeCustomSerialDTO.setSerialUnitString(newSerialUnitString.get());
+ codeCustomSerialDTO.setSerialCodeCodeBasicSec(secVO);
+ codeCustomSerialDTO.setCurrentFlowValue(startValue);
+ codeCustomSerialDTO.setCodeBasicSecVOList(ruleVO.getSecVOList());
+ codeCustomSerialDTO.setCodeRuleOid(ruleVO.getOid());
+ codeCustomSerialDTO.setBaseModel(cbo);
+ codeCustomSerialDTO.setSerialUnitString(newSerialUnitString.get());
+ codeCustomSerialDTO.setSecValueList(thisSecValueList);
+ thisSerialValue=customCodeSerial(secVO.getCustomCodeSerialClass(),codeCustomSerialDTO);
+ newSerialUnitString.set(codeCustomSerialDTO.getSerialUnitString());
+ log.info(secVO.getCustomCodeSerialClassText()+"---->"+thisSerialValue);
+ }else {
+ Double newThisSerialValue = 0d;
+ if (startValue == null) {
+ //绗竴涓紪鐮�
+ newThisSerialValue = VciBaseUtil.getDouble(secVO.getSerialStart());
+ } else {
+ //娴佹按鍙疯偗瀹氭槸鏁板瓧
+ newThisSerialValue = Double.parseDouble(startValue) + (j + 1) * secVO.getSerialStep();
+ }
+ //瑕佺湅鏄惁瓒呰繃鏈�澶х殑娴佹按鍊�
+ if (newThisSerialValue >= secVO.getCodeFillLimit()) {
+ throw new VciBaseException("娴佹按鍙峰凡缁忚秴杩囧厑璁哥殑鏈�澶ф祦姘村�納0}", new String[]{secVO.getCodeFillLimit().toString()});
+ }
+ thisSerialValue=String.valueOf(newThisSerialValue.intValue());
+ }
+ //瑕佺湅琛ヤ綅鐨勫唴瀹�
+ Integer fillLength = VciBaseUtil.getInt(secVO.getCodeFillLength());
+ if (fillLength == 0 || fillLength > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
+ //闃叉鍦ㄦ坊鍔犵殑鍦版柟娌℃湁鎺у埗姝ｇ‘
+ fillLength = VciBaseUtil.getInt(secVO.getCodeSecLength());
+ }
+ serialString = thisSerialValue;
+ serialString = fillString(fillLength, OsCodeFillTypeEnum.forValue(secVO.getCodeFillType()), serialString, secVO.getCodeFillSeparator());
+
+ for (int z = 0; z < thisSecValueList.size(); z++) {
+ String secValue = thisSecValueList.get(z);
+ if (secValue.equalsIgnoreCase("${" + secVO.getOid() + "}")) {
+ // TODO: 娴佹按鐢熸垚鐮佸�煎悗鎷兼帴鍓嶅悗缂�
+ thisSecValueList.set(z, joinPreffixAndSuffix(secVO, serialString));
+ }
+ }
+ secIdserialValueMap.put(secVO.getOid(),thisSerialValue);//璁板綍娴佹按鐮佹褰撳墠鐨勫��
+ Map<String, String> unitSerialMap = lastMaxSerialValueMap.getOrDefault(secVO.getOid(), new HashMap<>());
+ unitSerialMap.put(newSerialUnitString.get(), String.valueOf(thisSerialValue));
+ lastMaxSerialValueMap.put(secVO.getOid(),unitSerialMap);
+ }
+ }
+ }
+
+ private String customCodeSerial(String beanName, CodeCustomSerialDTO codeCustomSerialDTO){
+ AtomicReference<String> result = new AtomicReference<>("");
+ //BusAnnotationUtil.callForAnnotation(FlowNotifyWeb.class, FlowNotifyBefore.class,noticeInfo);
+ //鍦ㄧ櫥褰曚箣鍓嶏紝鐪嬬湅鏄惁鏈夋彃浠�
+ Map<String, Object> beanMap = ApplicationContextProvider.getApplicationContext().getBeansWithAnnotation(MdmSerialAlgorithm.class);
+ if (!CollectionUtils.isEmpty(beanMap)) {
+ if(beanMap.containsKey(beanName)){
+ Object v=beanMap.get(beanName);
+ Method[] methods = v.getClass().getDeclaredMethods();
+ if (methods != null && methods.length > 0) {
+ for (Method method : methods) {
+ if (method.isAnnotationPresent(MdmSerialAlgorithmMethod.class)) {
+ try {
+ Object o= method.invoke(v, codeCustomSerialDTO);
+ result.set(Func.isEmpty(o) ?"":o.toString());
+ } catch (Throwable e) {
+ if (log.isErrorEnabled()) {
+ log.error("璋冪敤鎻掍欢鍑洪敊", e);
+ }
+ throw new VciBaseException("璋冪敤鎻掍欢鍑洪敊,{0},{1}", new String[]{v.getClass().getName(), method.getName()}, e);
+ }
+ }
+ }
+ }
+ }
+ }
+ /*
+ String result = "";
+ try {
+ Class classInstance=Class.forName(className);
+ Object obj =classInstance.newInstance();
+ Method method= classInstance.getMethod("serialGenerate",CodeCustomSerialDTO.class);
+ method.setAccessible(Boolean.TRUE);
+ //method.invoke(obj);
+ Object o= method.invoke(obj,codeCustomSerialDTO);
+ result= Func.isEmpty(o) ?"":o.toString();
+ } catch (ClassNotFoundException e) {
+ throw new VciBaseException("鏈壘鍒拌嚜瀹氫箟娴佹按绠楁硶绫绘枃浠�");
+ } catch (InvocationTargetException e) {
+ throw new VciBaseException("鎵ц鑷畾涔夋祦姘寸畻娉曞鐞嗘柟娉曞嚭鐜板紓甯�");
+ } catch (NoSuchMethodException e) {
+ throw new VciBaseException("鏈壘鍒拌嚜瀹氫箟娴佹按绠楁硶澶勭悊鏂规硶");
+ } catch (IllegalAccessException e) {
+ throw new VciBaseException("鎵ц鑷畾涔夋祦姘寸畻娉曞鐞嗘柟娉曞嚭鐜板紓甯�");
+ } catch (InstantiationException e) {
+ e.printStackTrace();
+ }*/
+ return result.get();
+ }
+
+ /**
+ * 杞崲鐮佸�肩殑鍐呭
+ * @param secVO 鐮佹鐨勫唴瀹�
+ * @param secValueMap 鐮佸�肩殑鍐呭锛宬ey鏄爜娈电殑涓婚敭锛寁alue鏄爜鍊�
+ * @param classifyFullInfoBO 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+ * @param serialSecVOList 娴佹按鐮佹
+ * @param attrSecVOList 灞炴�х爜娈�
+ * @param serialUnitList 娴佹按渚濇嵁
+ * @param secValueList 鐮佸�煎垪琛�
+ */
+ private void switchSecValue(CodeBasicSecVO secVO,Map<String,String> secValueMap,
+ CodeClassifyFullInfoBO classifyFullInfoBO,List<CodeBasicSecVO> serialSecVOList,
+ List<CodeBasicSecVO> attrSecVOList, List<String> serialUnitList,
+ List<String> secValueList ){
+ CodeSecTypeEnum secType = CodeSecTypeEnum.forValue(secVO.getSecType());
+ String secValue = secValueMap.getOrDefault(secVO.getOid(), "");
+ switch (secType) {
+ case CODE_FIXED_SEC:
+ secValue = joinPreffixAndSuffix(secVO, secValue);
+ //鍥哄畾鐮佹鐨勶紝鐩存帴鐢ㄧ爜鍊�,涓嶈鐮佸�肩殑闀垮害鏄灏戯紝鍥犱负鍙彉闀垮害鍜屽浐瀹氶暱搴︽槸鎺у埗鍦ㄧ爜娈电鐞嗛噷闈㈢殑鐮佸�煎畾涔夌殑
+ break;
+ case CODE_DATE_SEC:
+ //鏃堕棿鐮佹锛岄渶瑕佸皢褰撳墠鏃堕棿渚濇嵁鏃堕棿鏍煎紡杩涜杞崲.
+ //鏃堕棿鐮佹涓嶆秹鍙婂埌鏄惁琛ヤ綅
+ secValue =joinPreffixAndSuffix(secVO, VciDateUtil.date2Str(new Date(), secVO.getCodeDateFormatStr()));
+ break;
+ case CODE_CLASSIFY_SEC:
+ //鍒嗙被鐮佹鐨勶紝涔熸槸浠庡墠绔�夋嫨浜嗙爜鍊煎嵆鍙紝涓嶈鐮佸�肩殑闀垮害鏄灏�
+ CodeClassifyValue codeClassifyValueDO= codeClassifyValueMapper.selectById(secValue);
+ //褰撶爜鍊间负绌烘垨#NaN?鏃跺嵆琛ㄧず浣滀负绌哄瓧绗︿覆杩涜鎷兼帴
+ String nullSymbol = EnumCache.getValue("nullSymbol", "NULL");
+ nullSymbol = Func.isBlank(nullSymbol) ? "#NaN?":nullSymbol;
+ if(Func.isBlank(codeClassifyValueDO.getId()) || codeClassifyValueDO.getId().equals(nullSymbol)){
+ codeClassifyValueDO.setId("");
+ }
+ if(codeClassifyValueDO!=null) {
+ secValue = joinPreffixAndSuffix(secVO, codeClassifyValueDO.getId());
+ }
+ break;
+ case CODE_LEVEL_SEC:
+ //灞傜骇鐮佹锛岄渶瑕佷粠鍒嗙被涓婅幏鍙栫浉搴旂殑淇℃伅
+ if (CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(secVO.getCodeLevelType())) {
+ //鏈�灏忓眰锛屽洜涓烘垜浠彧鑳藉湪鍙跺瓙鑺傜偣涓婄敵璇风紪鐮侊紝鎵�浠ヨ繖涓氨鏄綋鍓嶅垎绫荤殑
+ if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType()) || CollectionUtils.isEmpty(classifyFullInfoBO.getParentClassifyVOs())) {
+ //灏辨槸褰撳墠鍒嗙被鐨�
+ secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
+ } else {
+ //鎴戜滑闇�瑕佷粠椤跺眰寮�濮嬫壘鍒板綋鍓嶅垎绫讳负姝�
+ secValue = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> -o1.getDataLevel().compareTo(o2.getDataLevel()))).map(CodeClassifyVO::getId).collect(Collectors.joining()) + classifyFullInfoBO.getCurrentClassifyVO().getId();
+ }
+ } else {
+ //鎸囧畾灞傦紝鎴戜滑闇�瑕侀�氳繃涓婄骇鐨勬潵鑾峰彇
+ if (CollectionUtils.isEmpty(classifyFullInfoBO.getParentClassifyVOs())) {
+ //璇存槑褰撳墠宸茬粡鏄渶楂樼殑浜�
+ secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
+ } else {
+ //杩欎釜鎴戜滑闇�瑕佺湅鐪�,灞傜骇鏄笉鏄ぇ浜庝簡鏈�澶у眰绾х殑鏁�
+ List<CodeClassifyVO> parentClassifyVOList = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> -o1.getDataLevel().compareTo(o2.getDataLevel()))).collect(Collectors.toList());
+ if (secVO.getCodeLevelValue() > (parentClassifyVOList.size() + 1)) {
+ //鎸囧畾鐨勫眰绾ф瘮褰撳墠鐨勫眰绾ц繕澶т簡锛屾墍浠ュ彧鑳借幏鍙栧綋鍓嶅眰绾т簡
+ if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType())) {
+ secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
+ } else {
+ secValue = parentClassifyVOList.stream().map(CodeClassifyVO::getId).collect(Collectors.joining()) + classifyFullInfoBO.getCurrentClassifyVO().getId();
+ }
+ } else {
+ //鎴戜滑鑾峰彇鍏朵腑鎸囧畾灞傜殑鍐呭
+ if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType())) {
+ CodeClassifyVO classifyVO = parentClassifyVOList.stream().filter(s -> s.getDataLevel().intValue() == secVO.getCodeLevelValue().intValue()).findFirst().orElseGet(() -> null);
+ if (classifyVO != null) {
+ secValue = classifyVO.getId();
+ }
+ } else {
+ //灏忎簬绛変簬鐨勫叏閮ㄦ嬁鍑烘潵
+ secValue = parentClassifyVOList.stream().filter(s -> s.getDataLevel().intValue() <= secVO.getCodeLevelValue().intValue()).sorted(((o1, o2) -> -o1.getDataLevel().compareTo(o2.getDataLevel()))).map(CodeClassifyVO::getId).collect(Collectors.joining());
+ }
+ }
+ }
+ }
+ //鐪嬬湅闀垮害鏄惁闇�瑕佹埅鏂�
+ if (!CodeCutTypeEnum.NONE.getValue().equalsIgnoreCase(secVO.getValueCutType()) &&
+ secVO.getValueCutLength() != null && secVO.getValueCutLength() > 0 && secValue.length() > secVO.getValueCutLength()) {
+ if (CodeCutTypeEnum.RIGHT.getValue().equalsIgnoreCase(secVO.getValueCutType())) {
+ //宸︽埅鍙栨槸浠庡乏杈瑰壀鎺夛紝鍙虫埅鍙栨槸浠庡彸杈瑰壀鎺�--淇濈暀宸﹁竟
+ secValue = secValue.substring(0, secVO.getValueCutLength());
+ } else {
+ secValue = secValue.substring(secValue.length() - secVO.getValueCutLength());
+ }
+ }
+ secValue = joinPreffixAndSuffix(secVO,secValue);
+ break;
+ case CODE_REFER_SEC:
+ //寮曠敤鐨勫湪椤甸潰涓婂凡缁忛�夋嫨浜嗭紝鎵�浠ョ洿鎺ヤ娇鐢ㄥ墠绔笂浼犻�掔殑鍊�
+ //寮曠敤灏辨槸鍙傜収锛屽彲鑳芥槸鍏朵粬鐨勫垎绫伙紙涓氬姟绫诲瀷锛変笅鐨勬暟鎹紝鎵�浠ュ彧鍦ㄩ〉闈笂閫夋嫨
+ secValue = joinPreffixAndSuffix(secVO,secValue);
+ break;
+ case CODE_ATTR_SEC:
+ //灞炴�т笌寮曠敤鐨勫尯鍒槸锛屽睘鎬ф槸褰撳墠鏁版嵁閲岀殑灞炴�э紝鑰屽紩鐢ㄥ彲鑳芥槸寮曠敤鍏朵粬鐨勫垎绫荤殑锛堜笟鍔＄被鍨嬶級
+ //鍥犱负鍙兘鏄壒閲忕殑鏁版嵁鐨勬搷浣滐紝鎵�浠ユ垜浠繖閲屼笉鑳界洿鎺ュ鐞嗗睘鎬э紝闇�瑕佸悗杈逛竴杈瑰鐞�
+ secValue = "${attr_" + secVO.getOid() + "}";
+ attrSecVOList.add(secVO);
+ break;
+ case CODE_VARIABLE_SEC:
+ //鍙彉鐮佹锛屾槸鍦ㄩ〉闈笂杈撳叆鍐呭
+ if (secValue.length() > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
+ throw new ServiceException(String.format("銆恵%s}銆戣繖涓爜娈垫槸鍙彉鐮佹锛屼絾鏄幇鍦ㄨ緭鍏ョ殑鐮佸�肩殑闀垮害({%s})瓒呰繃浜嗚瀹氱殑闀垮害{%s}", secVO.getName(), secValue.length(), secVO.getCodeSecLength()));
+ }
+ OsCodeFillTypeEnum fillTypeEnum = OsCodeFillTypeEnum.forValue(secVO.getCodeFillType());
+ secValue = fillString(VciBaseUtil.getInt(secVO.getCodeSecLength()), fillTypeEnum, secValue, secVO.getCodeFillSeparator());
+ secValue = joinPreffixAndSuffix(secVO,secValue);
+ break;
+ case CODE_SERIAL_SEC:
+ //娴佹按鐮佹
+ serialSecVOList.add(secVO);
+ secValue = "${" + secVO.getOid() + "}";
+ default:
+ break;
+ }
+ if (VciBaseUtil.getBoolean(secVO.getSerialDependFlag())) {
+ serialUnitList.add(secValue);
+ }
+ secValueList.add(secValue);
+ }
+
+ /**
+ * 鎷兼帴鍓嶅悗缂�
+ * @param secVO 鐮佹
+ * @param secValue 鐮佸��
+ * @return
+ */
+ public String joinPreffixAndSuffix(CodeBasicSecVO secVO, String secValue){
+ StringBuilder joinSecValue = new StringBuilder();
+ // 鎷兼帴鍓嶇紑
+ if (Func.isNotEmpty(secVO.getPrefixCode()) && Func.isNotEmpty(secValue)) {
+ joinSecValue = joinSecValue.append(secVO.getPrefixCode());
+ }
+ // 鍦ㄤ腑闂存嫾鎺ュ��
+ joinSecValue.append(secValue);
+ // 鎷兼帴鍚庣紑
+ if(Func.isNotEmpty(secVO.getSuffixCode()) && Func.isNotEmpty(secValue)){
+ joinSecValue = joinSecValue.append(secVO.getSuffixCode());
+ }
+ return joinSecValue.toString();
+ }
+
+ /**
+ * 琛ヤ綅
+ * @param totalLength 鎬婚暱搴�
+ * @param fillTypeEnum 琛ヤ綅鏂瑰紡
+ * @param text 褰撳墠鐨勫唴瀹�
+ * @param fillChar 琛ヤ綅鐨勫瓧绗�
+ * @return 涓嶅～鍏呬綅缃拰闀垮害宸茬粡杈惧埌/瓒呰繃鐨勬椂鍊欎笉浼氬～鍏�
+ */
+ private String fillString(int totalLength,OsCodeFillTypeEnum fillTypeEnum,String text,String fillChar){
+ if(text.length() >= totalLength || OsCodeFillTypeEnum.NONE.equals(fillTypeEnum)){
+ //涓嶇敤琛ヤ綅浜�
+ return text;
+ }
+ int balance = totalLength - text.length();
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < balance; i++) {
+ sb.append(fillChar);
+ }
+ if(OsCodeFillTypeEnum.LEFT.equals(fillTypeEnum)) {
+ text = sb.toString() + text;
+ }else {
+ text = text + sb.toString();
+ }
+ return text;
+ }
+
+ /**
+ * 灏佽瀛樺偍鐮佸�肩殑瀵硅薄
+ * @param classifyFullInfoBO 鍒嗙被鍏ㄩ儴鐨勪俊鎭�
+ * @param ruleVO 瑙勫垯鐨勫唴瀹�
+ * @param cbo 涓氬姟鏁版嵁
+ * @param templateVO 妯℃澘鐨勪俊鎭�
+ * @param allCodeDOList 鎵�鏈夌殑鐮佸�肩殑瀵硅薄鍒楄〃
+ * @param codeDelimiter 鐮佸�煎垎鍓茬
+ */
+ private void wrapperAllCode(CodeClassifyFullInfoBO classifyFullInfoBO, CodeRuleVO ruleVO,
+ BaseModel cbo, CodeClassifyTemplateVO templateVO,
+ List<CodeAllCode> allCodeDOList, String serialUnitString, String serialValueString,String codeDelimiter){
+ CodeAllCode allCodeDO = new CodeAllCode();
+ DefaultAttrAssimtUtil.addDefaultAttrAssimt(allCodeDO, MdmBtmTypeConstant.CODE_ALL_CODE);
+ allCodeDO.setCodeClassifyOid(classifyFullInfoBO.getCurrentClassifyVO().getOid());
+ allCodeDO.setCodeRuleOid(ruleVO.getOid());
+ allCodeDO.setId(cbo.getId());
+ allCodeDO.setCodeClassifyTemplateOid(templateVO.getOid());
+ allCodeDO.setCreateCodeBtm(cbo.getBtmname());
+ allCodeDO.setCreateCodeOid(cbo.getOid());
+ allCodeDO.setSerialUnit(serialUnitString);
+ allCodeDO.setUnFillSerial(serialValueString);
+ allCodeDO.setLcStatus(cbo.getLcStatus());
+ allCodeDO.setCodeDelimit(codeDelimiter);
+ allCodeDOList.add(allCodeDO);
+ }
+
+ /**
+ * 淇濆瓨娴佹按鐨勪俊鎭�
+ * @param ruleVO 瑙勫垯鐨勬樉绀哄璞�
+ * @param lastMaxSerialValueMap 鏈�澶х殑娴佹按鍊兼槧灏�
+ * @param maxSerialValueMap 渚濇嵁瀛樺偍鐨勬渶澶ф祦姘寸殑鍐呭
+ */
+ private void saveSerialValue(CodeRuleVO ruleVO,
+ Map<String/**鐮佹鐨勪富閿�**/,Map<String, String>> lastMaxSerialValueMap,
+ Map<String/**鐮佹鐨勪富閿�**/,Map<String, CodeSerialValue>> maxSerialValueMap){
+ List<CodeSerialValue> editSerialValueDOList = new ArrayList<>();
+ List<CodeSerialValue> addSerialValueDOList = new ArrayList<>();
+ //瀛樺偍鏈�澶ф祦姘村彿
+ lastMaxSerialValueMap.forEach((secOid,maxSerialMap)->{
+ maxSerialMap.forEach((unit,maxSerial)->{
+ CodeSerialValue serialValueDO = null;
+ if(maxSerialValueMap.containsKey(secOid) && maxSerialValueMap.get(secOid).containsKey(unit)){
+ //璇存槑鏈�
+ serialValueDO = maxSerialValueMap.get(secOid).get(unit);
+ serialValueDO.setMaxSerial(maxSerial.toString());
+ DefaultAttrAssimtUtil.updateDefaultAttrAssimt(serialValueDO);
+ editSerialValueDOList.add(serialValueDO);
+ }else{
+ serialValueDO = new CodeSerialValue();
+ DefaultAttrAssimtUtil.addDefaultAttrAssimt(serialValueDO, MdmBtmTypeConstant.CODE_SERIAL_VALUE);
+ serialValueDO.setCodeRuleOid(ruleVO.getOid());
+ serialValueDO.setSerialUnit(unit);
+ serialValueDO.setCodeSecOid(secOid);
+ serialValueDO.setMaxSerial(maxSerial.toString());
+ addSerialValueDOList.add(serialValueDO);
+ }
+ });
+ });
+ if(!CollectionUtils.isEmpty(editSerialValueDOList)){
+// batchCBO.copyFromOther(serialValueMapper.batchUpdate(editSerialValueDOList));
+ for (CodeSerialValue codeSerialValue : editSerialValueDOList) {
+ serialValueMapper.updateById(codeSerialValue);
+ }
+ }
+ if(!CollectionUtils.isEmpty(addSerialValueDOList)){
+ for (CodeSerialValue codeSerialValue : addSerialValueDOList) {
+ serialValueMapper.insert(codeSerialValue);
+ }
+// batchCBO.copyFromOther(serialValueMapper.batchInsert(addSerialValueDOList));
+ }
+ }
+
+ /**
+ * 鍘绘帀涓嶆槸鏁板瓧鐨勫瓧绗�
+ * @param s 瀛楃
+ * @return 鏇挎崲鍚庣殑鍊�
+ */
+ private String killUnNumberChar(String s){
+ Integer lastUnNumberIndex = 0;
+ for (int i = 0; i < s.length(); i++) {
+ char c = s.charAt(i);
+ if(!(new String(new char[]{c})).matches(RegExpConstant.NUMBER)){
+ lastUnNumberIndex = i;
+ }
+ }
+ String value = s;
+ if(lastUnNumberIndex >0){
+ value = value.substring(lastUnNumberIndex);
+ }
+ return value;
+ }
+
+ /**
+ * 鍘绘帀鍓嶅悗缂�
+ * @param secValue 瀛楃
+ * @param priffix 鍓嶇紑
+ * @param suffix 鍚庣紑
+ * @return 鏇挎崲鍚庣殑鍊�
+ */
+ private String killPriffixSuffix(String secValue, String priffix,String suffix){
+ if (priffix != null && secValue.startsWith(priffix)) {
+ secValue = secValue.substring(priffix.length());
+ }
+ if (suffix != null && secValue.endsWith(suffix)) {
+ secValue = secValue.substring(0, secValue.length() - suffix.length());
+ }
+ return secValue;
+ }
+
+ /**
+ * 鍘婚櫎琛ヤ綅瀛楃
+ * @param s 瀛楃
+ * @param fillString 琛ヤ綅瀛楃
+ * @param left 鏄惁宸﹁ˉ浣�
+ * @return 鏇挎崲鍚庣殑鍊�
+ */
+ private String killFillChar(String s, String fillString,boolean left){
+ Integer index = 0;
+ String value = s;
+
+ if(left){
+ for (int i = 0; i < s.length(); i++) {
+ char c = s.charAt(i);
+ if(!(new String(new char[]{c})).equalsIgnoreCase(fillString)){
+ break;
+ }
+ index = i;
+ }
+ if(index >0){
+ value = value.substring(index);
+ }
+ }else{
+ //浠庡彸寰�宸︽壘
+ for (int i = s.length()-1; i >=0; i++) {
+ char c = s.charAt(i);
+ if(!(new String(new char[]{c})).equalsIgnoreCase(fillString)){
+ break;
+ }
+ index = i;
+ }
+ if(index >0){
+ value = value.substring(0,index);
+ }
+ }
+ return value;
+
+ }
+
+ /**
+ * 鍥炴敹鐮佸��
+ *
+ * @param btmId 涓氬姟鏁版嵁鐨勪笟鍔＄被鍨�
+ * @param businessOidCollection 涓氬姟鏁版嵁鐨勪富閿�
+ * @return 鏄惁鏇存柊鎴愬姛
+ */
+ @Override
+ public Boolean recycleCode(String btmId, Collection<String> businessOidCollection) {
+// boolean oldPersistence = WebUtil.isPersistence();
+// WebUtil.setPersistence(false);
+// BatchCBO batchCBO = new BatchCBO();
+ AtomicReference<Boolean> updateFlag = new AtomicReference<>(false);
+ VciBaseUtil.switchCollectionForOracleIn(businessOidCollection).stream().forEach(oids-> {
+// Map<String, String> conditionMap = new HashMap<>();
+// //缂栫爜瑕佽褰曚负鍥炴敹鐨勭姸鎬�
+// conditionMap.put("createcodeoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oids.toArray(new String[0])) + ")");
+// conditionMap.put("createcodebtm", btmId);
+
+ QueryWrapper<CodeAllCode> wrapper = new QueryWrapper<>();
+ wrapper.in("createcodeoid",QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oids.toArray(new String[0])) + ")");
+ wrapper.eq("createcodebtm", btmId);
+
+
+ List<CodeAllCode> allCodeDOS = codeAllCodeService.selectByWrapper(wrapper);
+// allCodeMapper.selectByCondition(conditionMap, new PageHelper(-1));
+ if (!CollectionUtils.isEmpty(allCodeDOS)) {
+ allCodeDOS.stream().forEach(codeDO->{
+ codeDO.setLcStatus(CodeAllCodeLC.TASK_BACK.getValue());
+ });
+ updateFlag.set(codeAllCodeService.updateBatchById(allCodeDOS));
+// batchCBO.copyFromOther(allCodeMapper.batchUpdate(allCodeDOS));
+ }
+ });
+// WebUtil.setPersistence(oldPersistence);
+ return updateFlag.get();
+ }
+
+ /***
+ *
+ * @param classifyFullInfoBO 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+ * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+ * @param ruleVO 缂栫爜瑙勫垯鐨勬樉绀哄璞�
+ * @param secDTOList 鍚勪釜鐮佹鐨勫��
+ * @param dataCBOList 涓氬姟鏁版嵁
+ * @return
+ * @throws Exception
+ */
+ @Override
+ public List<String> productCodeAndSaveDataBZ(CodeClassifyFullInfoBO classifyFullInfoBO, CodeClassifyTemplateVO templateVO, CodeRuleVO ruleVO, List<CodeOrderSecDTO> secDTOList, List<BaseModel> dataCBOList) throws Exception {
+ dataCBOList = dataCBOList.stream().sorted(((o1, o2) -> o1.getCreateTime().compareTo(o2.getCreateTime()))).collect(Collectors.toList());
+ List<String> codeList = new ArrayList<>();
+ final CodeRuleVO finalRuleVO = ruleVO;
+
+ List<CodeBasicSecVO> secVOList = finalRuleVO.getSecVOList().stream().sorted(((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()))).collect(Collectors.toList());
+ List<String> serialUnitList = new LinkedList<>();
+ List<String> secValueList = new ArrayList<>();
+ Map<String, String> secValueMap = secDTOList.stream().collect(Collectors.toMap(s -> s.getSecOid(), s -> s.getSecValue()==null?"":s.getSecValue()));
+ List<CodeBasicSecVO> serialSecVOList = new ArrayList<>();
+ List<CodeBasicSecVO> attrSecVOList = new ArrayList<>();
+ Map<String,String> secOdserialUnitMap=new HashMap<>();
+ LinkedHashMap<String,String> newSecValueMap=new LinkedHashMap<>();
+ for (int i = 0; i < secVOList.size(); i++) {
+ CodeBasicSecVO secVO = secVOList.get(i);
+ String secValue="";
+ String secOid=secVO.getOid();
+ if(secValueMap.containsKey(secOid)){
+ secValue=secValueMap.get(secOid);
+ }
+ newSecValueMap.put(secOid,secValue);
+ switchSecValueBZ(secVO, secValueMap, classifyFullInfoBO, serialSecVOList, attrSecVOList, serialUnitList, secValueList);
+ //鍒嗘瀛樺偍娴佹按渚濊禆
+ if(secVO.getSecType().equals(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue())){
+ int finalI = i;
+ final int[] index = {0};
+ List<String> newSerialUnitList= serialUnitList.stream().filter(secValueStr -> {
+ return index[0]++< finalI;//闄ゅ幓娴佹按鐨�
+ }).collect(Collectors.toList());
+ String serialUnitString = newSerialUnitList.size() == 0 ? EMPTY_SERIAL_UNIT : newSerialUnitList.stream().collect(Collectors.joining(SERIAL_UNIT_SPACE));
+ secOdserialUnitMap.put(secVO.getOid(),serialUnitString);
+ }
+ }
+ //澶勭悊灞炴�х爜娈靛拰娴佹按鐮佹
+ Map<String/**娴佹按鐮佹鐨勪富閿�**/, Map<String/**娴佹按渚濇嵁**/, String>> lastMaxSerialValueMap = new HashMap<>();
+ List<CodeAllCode> allCodeDOList = new ArrayList<>();
+ //宸茬粡瀛樺偍鐨勬渶澶ф祦姘村彿鐨勫唴瀹�
+ Map<String/**鐮佹鐨勪富閿�**/, Map<String, CodeSerialValue>> maxSerialValueMap = new HashMap<>();
+ for (int i = 0; i < dataCBOList.size(); i++) {
+ BaseModel cbo = dataCBOList.get(i);
+ cbo.getData().remove(CODE_SEC_LENGTH_FIELD);//灏嗘key闄ゅ幓
+ cbo.getData().remove(IMPORT_ROW_INDEX);//灏嗘key闄ゅ幓
+ cbo.getData().remove("codeclassifyid");//灏嗘key闄ゅ幓
+ List<String> thisSecValueList = new LinkedList<>();
+ for (int j = 0; j < secValueList.size(); j++) {
+ thisSecValueList.add(secValueList.get(j));
+ }
+ List<String> thisSerialUnitList = new LinkedList<>();
+ //鍥犱负娴佹按渚濇嵁姣忔鍙兘涓嶄竴鏍凤紝鎵�浠ユ瘡娆￠兘鎷疯礉涓�浠�
+ for (int j = 0; j < serialUnitList.size(); j++) {
+ thisSerialUnitList.add(serialUnitList.get(j));
+ }
+ //鍏堢湅鐪嬫湁娌℃湁灞炴�х殑鐮佹
+ boolean attrSevIsSerialDepend = CollectionUtils.isEmpty(attrSecVOList) ? false : (attrSecVOList.stream().anyMatch(s -> VciBaseUtil.getBoolean(s.getSerialDependFlag())));
+ switchAttrSecValue(attrSecVOList, cbo, thisSecValueList, attrSevIsSerialDepend, thisSerialUnitList);
+
+ switchSerialSecValueBZ(cbo,secDTOList,serialSecVOList, attrSevIsSerialDepend, finalRuleVO, secOdserialUnitMap, maxSerialValueMap, thisSecValueList, lastMaxSerialValueMap, i == 0);
+
+ //缁勮缂栫爜鐨勫��
+ cbo.setId(thisSecValueList.stream().collect(Collectors.joining()));
+ codeList.add(cbo.getId());
+ StringBuilder sb = new StringBuilder();
+ //鎶婄爜娈甸噷闈㈤兘鎵句竴涓嬫祦姘村彿
+ AtomicReference<String> serialUnitString= new AtomicReference<>("");
+ for (int j = 0; j < serialSecVOList.size(); j++) {
+ CodeBasicSecVO secVO = serialSecVOList.get(j);
+ if(lastMaxSerialValueMap.containsKey(secVO.getOid())){//姝や负鏈�鍚庨渶瑕佸瓨鍏ユ祦姘翠緷璧栫殑鏈�澶ф祦姘�
+ Map<String/**娴佹按渚濇嵁**/, String> serialValueMap = lastMaxSerialValueMap.get(secVO.getOid());
+ serialValueMap.forEach((maxSerialUnitString,serialValue)->{
+ if(StringUtils.isNotBlank(serialValue)){
+ serialUnitString.set(maxSerialUnitString);
+ sb.append(serialValue).append(SERIAL_VALUE_SPACE);
+ }
+ });
+ }else{
+ if(secValueMap.containsKey(secVO.getOid())) {//浼佷笟鏍囧噯澶勭悊淇椤哄簭鍙峰凡缁忓瓨鍦ㄧ殑鏁版嵁鍒欎笉闇�瑕佸姩娴佹按渚濊禆琛ㄧ殑鏁版嵁
+ serialUnitString.set(secOdserialUnitMap.get(secVO.getOid()));
+ sb.append(secValueMap.get(secVO.getOid())).append(SERIAL_VALUE_SPACE);
+ }
+ }
+ }
+ String codeDelimiter=thisSecValueList.stream().collect(Collectors.joining(SERIAL_VALUE_SPACE));
+ //瑕佸瓨鍌ㄦ渶鍚庣殑鍏ㄩ儴allcode
+ wrapperAllCode(classifyFullInfoBO, finalRuleVO, cbo, templateVO, allCodeDOList, serialUnitString.get(), sb.toString(),codeDelimiter);
+ }
+ //澶勭悊鏈�澶ф祦姘�
+ saveSerialValue( finalRuleVO, lastMaxSerialValueMap, maxSerialValueMap);
+
+ allCodeDOList.stream().forEach(
+ allCode -> {DefaultAttrAssimtUtil.addDefaultAttrAssimt(allCode,"codeallcode");allCode.setLctid("codeAllCodeLC");}
+ );
+
+ Map<String, String> statusMap = allCodeDOList.stream().collect(Collectors.toMap(s -> s.getOid(), s -> s.getLcStatus()));
+ allCodeDOList.stream().filter(s -> StringUtils.equalsIgnoreCase("codeallcode",s.getBtmname())).forEach(s -> {
+ s.setLcStatus(statusMap.get(s.getOid()));
+ });
+ //閫氳繃ID鏉ヨ繘琛屽幓閲�
+ List<CodeAllCode> distinctCodeAllCOdes = allCodeDOList.stream().collect(Collectors
+ .collectingAndThen(
+ Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(CodeAllCode::getId))),
+ ArrayList::new));
+ if( distinctCodeAllCOdes.size() != allCodeDOList.size() ){
+ throw new ServiceException("缂栫爜鏁版嵁閲嶅锛屾棤娉曚繚瀛橈紝璇锋敞鎰忥紒");
+ }
+ QueryWrapper<CodeAllCode> wrapper = new QueryWrapper<>();
+ wrapper.eq("CREATECODEBTM",allCodeDOList.get(0).getCreateCodeBtm());
+ wrapper.in("ID",allCodeDOList.stream().map(CodeAllCode::getId).collect(Collectors.toList()));
+ List<CodeAllCode> codeAllCodes = codeAllCodeService.selectByWrapper(wrapper);
+ List<CodeAllCode> takeBack = codeAllCodes.stream().filter(e -> e.getLcStatus().equals("TakeBack")).collect(Collectors.toList());
+ if(codeAllCodes.size()>takeBack.size()){
+ throw new ServiceException("鐢熸垚缂栫爜鏁版嵁ID宸叉湁鍘嗗彶璁板綍,璇风‘璁ゅ涓嬬敓鎴愮殑ID鏁版嵁锛�"+ allCodeDOList.stream().map(CodeAllCode::getId).collect(Collectors.toList()));
+ }
+ for (CodeAllCode codeAllCode : takeBack) {
+ codeAllCode.setTs(new Date());
+ codeAllCode.setLastModifyTime(new Date());
+ codeAllCode.setLastModifier(AuthUtil.getUserId().toString());
+ Iterator<CodeAllCode> iterator = allCodeDOList.iterator();
+ for (int i = 0; i < allCodeDOList.size(); i++) {
+ if(codeAllCode.getId().equals(allCodeDOList.get(i).getId())){
+ codeAllCode.setCreateCodeOid(allCodeDOList.get(i).getCreateCodeOid());
+ codeAllCode.setLcStatus(allCodeDOList.get(i).getLcStatus());
+ allCodeDOList.remove(i);
+ }
+ }
+ /*while (iterator.hasNext()){
+ CodeAllCode next = iterator.next();
+ if(codeAllCode.getId().equals(next.getId())){
+ codeAllCode.setCreateCodeOid(next.getCreateCodeOid());
+ codeAllCode.setLcStatus(next.getLcStatus());
+ //iterator.remove();
+ }
+ }*/
+ }
+ if(takeBack.size()>0){
+ codeAllCodeService.updateBatchById(takeBack);
+ }
+ codeAllCodeService.saveBatch(allCodeDOList);
+ mdmEngineService.insertBatchByType(dataCBOList.get(0).getBtmname(),dataCBOList);
+ return codeList;
+ }
+
+ /**
+ * 杞崲鐮佸�肩殑鍐呭
+ * @param secVO 鐮佹鐨勫唴瀹�
+ * @param secValueMap 鐮佸�肩殑鍐呭锛宬ey鏄爜娈电殑涓婚敭锛寁alue鏄爜鍊�
+ * @param classifyFullInfoBO 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+ * @param serialSecVOList 娴佹按鐮佹
+ * @param attrSecVOList 灞炴�х爜娈�
+ * @param serialUnitList 娴佹按渚濇嵁
+ * @param secValueList 鐮佸�煎垪琛�
+ */
+ private void switchSecValueBZ(CodeBasicSecVO secVO,Map<String,String> secValueMap,
+ CodeClassifyFullInfoBO classifyFullInfoBO,List<CodeBasicSecVO> serialSecVOList,
+ List<CodeBasicSecVO> attrSecVOList, List<String> serialUnitList,
+ List<String> secValueList ){
+ CodeSecTypeEnum secType = CodeSecTypeEnum.forValue(secVO.getSecType());
+ String secValue = secValueMap.getOrDefault(secVO.getOid(), "");
+ switch (secType) {
+ case CODE_FIXED_SEC:
+ secValue = joinPreffixAndSuffix(secVO, secValue);
+ //鍥哄畾鐮佹鐨勶紝鐩存帴鐢ㄧ爜鍊�,涓嶈鐮佸�肩殑闀垮害鏄灏戯紝鍥犱负鍙彉闀垮害鍜屽浐瀹氶暱搴︽槸鎺у埗鍦ㄧ爜娈电鐞嗛噷闈㈢殑鐮佸�煎畾涔夌殑
+ break;
+ case CODE_DATE_SEC:
+ //鏃堕棿鐮佹锛岄渶瑕佸皢褰撳墠鏃堕棿渚濇嵁鏃堕棿鏍煎紡杩涜杞崲.
+ //鏃堕棿鐮佹涓嶆秹鍙婂埌鏄惁琛ヤ綅
+ secValue =joinPreffixAndSuffix(secVO, VciDateUtil.date2Str(new Date(), secVO.getCodeDateFormatStr()));
+ break;
+ case CODE_CLASSIFY_SEC:
+ //鍒嗙被鐮佹鐨勶紝涔熸槸浠庡墠绔�夋嫨浜嗙爜鍊煎嵆鍙紝涓嶈鐮佸�肩殑闀垮害鏄灏�
+ CodeClassifyValue codeClassifyValueDO= codeClassifyValueMapper.selectById(secValue);
+ String nullSymbol = EnumCache.getValue("nullSymbol", "NULL");
+ nullSymbol = Func.isBlank(nullSymbol) ? "#NaN?":nullSymbol;
+ if(Func.isBlank(codeClassifyValueDO.getId()) || codeClassifyValueDO.getId().equals(nullSymbol)){
+ codeClassifyValueDO.setId("");
+ }
+ if(codeClassifyValueDO!=null) {
+ secValue = joinPreffixAndSuffix(secVO, codeClassifyValueDO.getId());
+ }
+ break;
+ case CODE_LEVEL_SEC:
+ //灞傜骇鐮佹锛岄渶瑕佷粠鍒嗙被涓婅幏鍙栫浉搴旂殑淇℃伅
+ if (CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(secVO.getCodeLevelType())) {
+ //鏈�灏忓眰锛屽洜涓烘垜浠彧鑳藉湪鍙跺瓙鑺傜偣涓婄敵璇风紪鐮侊紝鎵�浠ヨ繖涓氨鏄綋鍓嶅垎绫荤殑
+ if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType()) || CollectionUtils.isEmpty(classifyFullInfoBO.getParentClassifyVOs())) {
+ //灏辨槸褰撳墠鍒嗙被鐨�
+ secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
+ } else {
+ //鎴戜滑闇�瑕佷粠椤跺眰寮�濮嬫壘鍒板綋鍓嶅垎绫讳负姝�
+ secValue = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> -o1.getDataLevel().compareTo(o2.getDataLevel()))).map(CodeClassifyVO::getId).collect(Collectors.joining()) + classifyFullInfoBO.getCurrentClassifyVO().getId();
+ }
+ } else {
+ //鎸囧畾灞傦紝鎴戜滑闇�瑕侀�氳繃涓婄骇鐨勬潵鑾峰彇
+ if (CollectionUtils.isEmpty(classifyFullInfoBO.getParentClassifyVOs())) {
+ //璇存槑褰撳墠宸茬粡鏄渶楂樼殑浜�
+ secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
+ } else {
+ //杩欎釜鎴戜滑闇�瑕佺湅鐪�,灞傜骇鏄笉鏄ぇ浜庝簡鏈�澶у眰绾х殑鏁�
+ List<CodeClassifyVO> parentClassifyVOList = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> -o1.getDataLevel().compareTo(o2.getDataLevel()))).collect(Collectors.toList());
+ if (secVO.getCodeLevelValue() > (parentClassifyVOList.size() + 1)) {
+ //鎸囧畾鐨勫眰绾ф瘮褰撳墠鐨勫眰绾ц繕澶т簡锛屾墍浠ュ彧鑳借幏鍙栧綋鍓嶅眰绾т簡
+ if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType())) {
+ secValue = classifyFullInfoBO.getCurrentClassifyVO().getId();
+ } else {
+ secValue = parentClassifyVOList.stream().map(CodeClassifyVO::getId).collect(Collectors.joining()) + classifyFullInfoBO.getCurrentClassifyVO().getId();
+ }
+ } else {
+ //鎴戜滑鑾峰彇鍏朵腑鎸囧畾灞傜殑鍐呭
+ if (CodeGetValueTypeEnum.CURRENT.getValue().equalsIgnoreCase(secVO.getCodeGetValueType())) {
+ CodeClassifyVO classifyVO = parentClassifyVOList.stream().filter(s -> s.getDataLevel().intValue() == secVO.getCodeLevelValue().intValue()).findFirst().orElseGet(() -> null);
+ if (classifyVO != null) {
+ secValue = classifyVO.getId();
+ }
+ } else {
+ //灏忎簬绛変簬鐨勫叏閮ㄦ嬁鍑烘潵
+ secValue = parentClassifyVOList.stream().filter(s -> s.getDataLevel().intValue() <= secVO.getCodeLevelValue().intValue()).sorted(((o1, o2) -> -o1.getDataLevel().compareTo(o2.getDataLevel()))).map(CodeClassifyVO::getId).collect(Collectors.joining());
+ }
+ }
+ }
+ }
+ //鐪嬬湅闀垮害鏄惁闇�瑕佹埅鏂�
+ if (!CodeCutTypeEnum.NONE.getValue().equalsIgnoreCase(secVO.getValueCutType()) &&
+ secVO.getValueCutLength() != null && secVO.getValueCutLength() > 0 && secValue.length() > secVO.getValueCutLength()) {
+ if (CodeCutTypeEnum.RIGHT.getValue().equalsIgnoreCase(secVO.getValueCutType())) {
+ //宸︽埅鍙栨槸浠庡乏杈瑰壀鎺夛紝鍙虫埅鍙栨槸浠庡彸杈瑰壀鎺�--淇濈暀宸﹁竟
+ secValue = secValue.substring(0, secVO.getValueCutLength());
+ } else {
+ secValue = secValue.substring(secValue.length() - secVO.getValueCutLength());
+ }
+ }
+ secValue = joinPreffixAndSuffix(secVO,secValue);
+ break;
+ case CODE_REFER_SEC:
+ //寮曠敤鐨勫湪椤甸潰涓婂凡缁忛�夋嫨浜嗭紝鎵�浠ョ洿鎺ヤ娇鐢ㄥ墠绔笂浼犻�掔殑鍊�
+ //寮曠敤灏辨槸鍙傜収锛屽彲鑳芥槸鍏朵粬鐨勫垎绫伙紙涓氬姟绫诲瀷锛変笅鐨勬暟鎹紝鎵�浠ュ彧鍦ㄩ〉闈笂閫夋嫨
+ secValue = joinPreffixAndSuffix(secVO,secValue);
+ break;
+ case CODE_ATTR_SEC:
+ //灞炴�т笌寮曠敤鐨勫尯鍒槸锛屽睘鎬ф槸褰撳墠鏁版嵁閲岀殑灞炴�э紝鑰屽紩鐢ㄥ彲鑳芥槸寮曠敤鍏朵粬鐨勫垎绫荤殑锛堜笟鍔＄被鍨嬶級
+ //鍥犱负鍙兘鏄壒閲忕殑鏁版嵁鐨勬搷浣滐紝鎵�浠ユ垜浠繖閲屼笉鑳界洿鎺ュ鐞嗗睘鎬э紝闇�瑕佸悗杈逛竴杈瑰鐞�
+ secValue = "${attr_" + secVO.getOid() + "}";
+ attrSecVOList.add(secVO);
+ break;
+ case CODE_VARIABLE_SEC:
+ //鍙彉鐮佹锛屾槸鍦ㄩ〉闈笂杈撳叆鍐呭
+ if (secValue.length() > VciBaseUtil.getInt(secVO.getCodeSecLength())) {
+ throw new VciBaseException("銆恵0}銆戣繖涓爜娈垫槸鍙彉鐮佹锛屼絾鏄幇鍦ㄨ緭鍏ョ殑鐮佸�肩殑闀垮害({1})瓒呰繃浜嗚瀹氱殑闀垮害{2}", new String[]{secVO.getName(), String.valueOf(secValue.length()), secVO.getCodeSecLength()});
+ }
+ OsCodeFillTypeEnum fillTypeEnum = OsCodeFillTypeEnum.forValue(secVO.getCodeFillType());
+ secValue = fillString(VciBaseUtil.getInt(secVO.getCodeSecLength()), fillTypeEnum, secValue, secVO.getCodeFillSeparator());
+ secValue = joinPreffixAndSuffix(secVO,secValue);
+ break;
+ case CODE_SERIAL_SEC:
+ //娴佹按鐮佹
+ serialSecVOList.add(secVO);
+ if(secValueMap.containsKey(secVO.getOid())){
+ secValue=secValueMap.get(secVO.getOid());
+ }else{
+ secValue = "${" + secVO.getOid() + "}";
+ }
+ default:
+ break;
+ }
+ if (VciBaseUtil.getBoolean(secVO.getSerialDependFlag())) {
+ serialUnitList.add(secValue);
+ }
+ secValueList.add(secValue);
+ }
+
+ /**
+ * 浣跨敤CBO澶勭悊缁勫悎瑙勫垯鐨勫唴瀹�
+ * @param cbo 鏁版嵁鐨勫唴瀹�
+ * @param rule 瑙勫垯鐨勫唴瀹�
+ * @return 杞崲鍚庣殑
+ */
+ private String getValueByFormulaForCBO(BaseModel cbo,String rule) {
+ Map<String, Object> dataMap = null;
+ try{
+ dataMap = VciBaseUtil.convertBean2Map(cbo,null);
+ }catch(Exception e){
+ throw new VciBaseException("mapToBeanError:"+e);
+ }
+ Map<String, String> map = new HashMap<String, String>();
+ for (String i : dataMap.keySet()) {
+ map.put(i, String.valueOf(dataMap.get(i)).trim());
+ }
+// WebUtil.copyValueToMapFromCbos(cbo,dataMap);
+ return formulaService.getValueByFormula(map,rule);
+ }
}
--
Gitblit v1.9.3