package com.vci.web.service.impl;
|
|
import com.vci.frameworkcore.constant.FrameWorkDefaultValueConstant;
|
import com.vci.frameworkcore.lcstatuspck.FrameworkDataLCStatus;
|
import com.vci.starter.web.enumpck.BooleanEnum;
|
import com.vci.starter.web.exception.VciBaseException;
|
import com.vci.starter.web.pagemodel.DataGrid;
|
import com.vci.starter.web.pagemodel.PageHelper;
|
import com.vci.starter.web.util.BeanUtil;
|
import com.vci.starter.web.util.LangBaseUtil;
|
import com.vci.starter.web.util.VciBaseUtil;
|
import com.vci.starter.web.util.VciDateUtil;
|
import com.vci.web.bo.OsCodeSerialBuildBO;
|
import com.vci.web.dao.*;
|
import com.vci.web.dto.OsCodeEnumDTO;
|
import com.vci.web.dto.OsCodeRuleDTO;
|
import com.vci.web.dto.OsCodeRuleElementDTO;
|
import com.vci.web.dto.OsCodeRuleProduceDTO;
|
import com.vci.web.enumpck.OsCodeDateValueTypeEnum;
|
import com.vci.web.enumpck.OsCodeElementTypeEnum;
|
import com.vci.web.enumpck.OsCodeFillTypeEnum;
|
import com.vci.web.enumpck.OsCodeProductTypeEnum;
|
import com.vci.web.model.*;
|
import com.vci.web.pageModel.OsCodeEnumVO;
|
import com.vci.web.pageModel.OsCodeResultVO;
|
import com.vci.web.pageModel.OsCodeRuleElementVO;
|
import com.vci.web.pageModel.OsCodeRuleVO;
|
import com.vci.web.service.OsCodeRuleServiceI;
|
import com.vci.web.util.WebUtil;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
import java.util.*;
|
|
import static com.vci.frameworkcore.constant.FrameWorkBusLangCodeConstant.DATA_ID_NOT_EXIST;
|
import static com.vci.frameworkcore.constant.FrameWorkBusLangCodeConstant.DATA_OID_NOT_EXIST;
|
|
/**
|
* 编码规则的服务
|
*
|
* @author weidy
|
* @date 2020/9/2 14:28
|
*/
|
@Service
|
public class OsCodeRuleServiceImpl implements OsCodeRuleServiceI {
|
|
/**
|
* 编码规则的数据操作层
|
*/
|
@Resource
|
private OsCodeRuleDaoI codeRuleDao;
|
|
/**
|
* 编码规则明细的数据操作层
|
*/
|
@Resource
|
private OsCodeRuleElementDaoI codeRuleElementDao;
|
|
/**
|
* 枚举的映射数据操作层
|
*/
|
@Resource
|
private OsCodeEnumDaoI codeEnumDao;
|
|
/**
|
* 流水号存储的信息
|
*/
|
@Resource
|
private OsCodeSerialNumberDaoI serialNumberDao;
|
|
/**
|
* 断码的数据操作层
|
*/
|
@Resource
|
private OsCodeBreakCodeDaoI breakCodeDao;
|
|
/**
|
* 枚举是空的时候的映射值
|
*/
|
public static final String EMPTY = "${empty}";
|
|
/**
|
* 空的流水依据
|
*/
|
public static final String EMPTY_SERIAL_ACCORDING = "${nullSerialAccordingString}";
|
|
/**
|
* 使用数据传输对象获取规则的对象
|
* @param codeRuleProduceDTO 生成编码的数据传输对象
|
* @return 规则的内容
|
*/
|
private OsCodeRuleDO getRuleByDTO(OsCodeRuleProduceDTO codeRuleProduceDTO){
|
//查询编码规则，和相应的明细内容
|
OsCodeRuleDO ruleDO = null;
|
if (StringUtils.isNotBlank(codeRuleProduceDTO.getOwnbizBtm()) && StringUtils.isNotBlank(codeRuleProduceDTO.getUseRuleFlag())) {
|
ruleDO = selectByRuleFlag(codeRuleProduceDTO.getOwnbizBtm(), codeRuleProduceDTO.getUseRuleFlag());
|
} else if (StringUtils.isNotBlank(codeRuleProduceDTO.getCodeRuleId())) {
|
ruleDO = selectById(codeRuleProduceDTO.getCodeRuleId());
|
} else {
|
ruleDO = selectByOid(codeRuleProduceDTO.getCodeRuleOid());
|
}
|
return ruleDO;
|
}
|
|
/**
|
* 使用编码规则生成编码
|
*
|
* @param codeRuleProduceDTO 编码生成所属数据传输对象，规则编号优先级大于主键，传递的数据优先级大于业务数据
|
* @return 生成的编码的值
|
* @throws VciBaseException 参数错误，规则不存在，数据不支持编码的生成等会抛出异常
|
*/
|
@Override
|
public String produceCode(OsCodeRuleProduceDTO codeRuleProduceDTO) throws VciBaseException {
|
//判断规则的编号或者规则的主键
|
VciBaseUtil.alertNotNull(codeRuleProduceDTO, "编码生成来源数据");
|
if (StringUtils.isBlank(codeRuleProduceDTO.getCodeRuleId())
|
&& StringUtils.isBlank(codeRuleProduceDTO.getCodeRuleOid())
|
&& (StringUtils.isBlank(codeRuleProduceDTO.getUseRuleFlag()) || StringUtils.isBlank(codeRuleProduceDTO.getOwnbizBtm()))) {
|
throw new VciBaseException("编码规则主键和编号为空，无法生成编码");
|
}
|
OsCodeRuleDO ruleDO = getRuleByDTO(codeRuleProduceDTO);
|
List<OsCodeRuleElementDO> ruleItemDOs = listItemsByRuleOidOrderByRuleOrderNubmer(ruleDO.getOid());
|
VciBaseUtil.alertNotNull(ruleItemDOs,"规则的明细");
|
//查询生成编码的数据
|
Map<String, Object> businessDataMap = codeRuleProduceDTO.getOwnbizDataMap();
|
//每一个元素产生的内容
|
List<String> tempCode = new ArrayList<String>();
|
//流水号的元素
|
Map<Integer, OsCodeRuleElementDO> serialItemMap = new HashMap<Integer, OsCodeRuleElementDO>();
|
Map<Integer, String> serialAccordingMap = new HashMap<Integer, String>();
|
|
wrapperRuleElement(ruleItemDOs,codeRuleProduceDTO,tempCode,businessDataMap,serialItemMap,serialAccordingMap);
|
|
if (!CollectionUtils.isEmpty(serialItemMap)) {
|
//生成一条流水号
|
wrapperSerial(serialItemMap, serialAccordingMap, tempCode, ruleDO.getBreakReUseFlag());
|
}
|
|
String resultCode = "";
|
for (String code : tempCode) {
|
resultCode += code;
|
}
|
return resultCode;
|
}
|
|
/**
|
* 封装响应的内容
|
* @param ruleItemDOs 规则的明细
|
* @param codeRuleProduceDTO 创建编码的数据传输对象
|
* @param tempCode 临时的码段内容
|
* @param businessDataMap 业务数据的映射
|
* @param serialItemMap 序列号的明细
|
* @param serialAccordingMap 流水依据的内容
|
*/
|
private void wrapperRuleElement(List<OsCodeRuleElementDO> ruleItemDOs,OsCodeRuleProduceDTO codeRuleProduceDTO,
|
List<String> tempCode,Map<String, Object> businessDataMap, Map<Integer, OsCodeRuleElementDO> serialItemMap, Map<Integer, String> serialAccordingMap){
|
for (int i = 0; i < ruleItemDOs.size(); i++) {
|
OsCodeRuleElementDO item = ruleItemDOs.get(i);
|
OsCodeElementTypeEnum elementTypeEnum = OsCodeElementTypeEnum.forValue(item.getCodeElementType());
|
switch (elementTypeEnum) {
|
case INPUT:
|
if (CollectionUtils.isEmpty(codeRuleProduceDTO.getInputValueMap()) && !codeRuleProduceDTO.getInputValueMap().containsKey(item.getId())) {
|
throw new VciBaseException("手动输入的值");
|
}
|
String inputValue = codeRuleProduceDTO.getInputValueMap().get(item.getId());
|
if (inputValue.trim().length() < item.getMinLength()
|
&& OsCodeFillTypeEnum.NONE.getValue().equalsIgnoreCase(item.getCodeFillType())) {
|
throw new VciBaseException("【{0}】输入的内容长度小于了{1},实际为{2}", new String[]{item.getName(), item.getMinLength() + "", inputValue.length() + ""});
|
}
|
tempCode.add(i, fillCode(item, inputValue));
|
break;
|
case STATIC:
|
tempCode.add(i, item.getStaticCode() == null ? "" : item.getStaticCode());
|
break;
|
case DATE:
|
Date date = null;
|
OsCodeDateValueTypeEnum codeDateValueTypeEnum = OsCodeDateValueTypeEnum.forValue(item.getCodeDateValueType());
|
switch (codeDateValueTypeEnum) {
|
case BUSINESS:
|
if (CollectionUtils.isEmpty(businessDataMap) || !businessDataMap.containsKey(item.getCodeDateUseField())) {
|
throw new VciBaseException("[{0}]需要业务数据中的时间属性，但是未查询到业务数据的信息", new String[]{item.getName()});
|
}
|
try {
|
date = VciDateUtil.str2Date(businessDataMap.get(item.getCodeDateUseField()).toString(), VciDateUtil.DateTimeMillFormat);
|
} catch (Exception e) {
|
throw new VciBaseException(LangBaseUtil.getErrorMsg(e), new String[0], e);
|
}
|
default:
|
date = new Date();
|
break;
|
}
|
tempCode.add(i, VciDateUtil.date2Str(date, item.getCodeDateFormat()));
|
break;
|
case FIELD:
|
if (CollectionUtils.isEmpty(businessDataMap) || !businessDataMap.containsKey(item.getCodeUseField())) {
|
throw new VciBaseException("[{0}]需要业务数据中的属性信息，但是未查询到业务数据的信息", new String[]{item.getName()});
|
}
|
String fieldValue = businessDataMap.get(item.getCodeUseField()).toString();
|
tempCode.add(i, fillCode(item, fieldValue));
|
break;
|
case ENUM:
|
VciBaseUtil.alertNotNull(item.getCodeUseField(), "使用业务数据的属性名称");
|
if (CollectionUtils.isEmpty(businessDataMap) || !businessDataMap.containsKey(item.getCodeUseField())) {
|
throw new VciBaseException("[{0}]需要业务数据中的属性信息，但是未查询到业务数据的信息", new String[]{item.getName()});
|
}
|
String enumValue = businessDataMap.get(item.getCodeUseField()).toString();
|
if (StringUtils.isBlank(enumValue)) {
|
enumValue = EMPTY;
|
}
|
String enumMapValue = codeEnumDao.selectMapValueByRuleOidAndValue(item.getOid(), enumValue);
|
if (EMPTY.equalsIgnoreCase(enumMapValue)) {
|
enumMapValue = "";
|
}
|
tempCode.add(i, fillCode(item, enumMapValue));
|
break;
|
case EXPRESSION:
|
VciBaseUtil.alertNotNull(item.getCodeExpression(), "公式表达式");
|
String expressionValue = "";
|
//TODO 等待添加公式的内容
|
tempCode.add(i, fillCode(item, expressionValue));
|
break;
|
case SERIAL:
|
// 流水号
|
tempCode.add(i, "");
|
serialItemMap.put(i, item);
|
default:
|
//防止后面加别的内容
|
break;
|
}
|
if (BooleanEnum.TRUE.getValue().equalsIgnoreCase(item.getSerialAccording())) {
|
serialAccordingMap.put(i, tempCode.get(i));
|
}
|
}
|
}
|
|
|
/**
|
* 使用编码规则生成编码
|
*
|
* @param codeRuleProduceDTO 编码生成所属数据传输对象，规则编号优先级大于主键，传递的数据优先级大于业务数据
|
* @return 生成的编码的值
|
* @throws VciBaseException 参数错误，规则不存在，数据不支持编码的生成等会抛出异常
|
*/
|
@Override
|
public List<OsCodeResultVO> batchProduceCode(OsCodeRuleProduceDTO codeRuleProduceDTO, Integer needAddQuantity) {
|
//判断规则的编号或者规则的主键
|
VciBaseUtil.alertNotNull(codeRuleProduceDTO, "编码生成来源数据");
|
if (StringUtils.isBlank(codeRuleProduceDTO.getCodeRuleId())
|
&& StringUtils.isBlank(codeRuleProduceDTO.getCodeRuleOid())
|
&& (StringUtils.isBlank(codeRuleProduceDTO.getUseRuleFlag()) || StringUtils.isBlank(codeRuleProduceDTO.getOwnbizBtm()))) {
|
throw new VciBaseException("编码规则主键和编号为空，无法生成编码");
|
}
|
//查询编码规则，和相应的明细内容
|
OsCodeRuleDO ruleDO =getRuleByDTO(codeRuleProduceDTO);
|
List<OsCodeRuleElementDO> ruleItemDOs = listItemsByRuleOidOrderByRuleOrderNubmer(ruleDO.getOid());
|
VciBaseUtil.alertNotNull(ruleItemDOs,"规则的明细");
|
//查询生成编码的数据
|
Map<String, Object> businessDataMap = codeRuleProduceDTO.getOwnbizDataMap();
|
//每一个元素产生的内容
|
List<String> tempCode = new ArrayList<String>();
|
|
//用来存储流水号的元素
|
Map<Integer/**流水号所在的位置**/, OsCodeRuleElementDO> serialItemMap = new HashMap<Integer, OsCodeRuleElementDO>();
|
//用来存储流水依据的元素
|
Map<Integer/**流水依据在的位置**/, String> serialAccordingMap = new HashMap<Integer, String>();
|
|
wrapperRuleElement(ruleItemDOs,codeRuleProduceDTO,tempCode,businessDataMap,serialItemMap,serialAccordingMap);
|
List<OsCodeResultVO> resultVOList = new ArrayList<OsCodeResultVO>();
|
if (!CollectionUtils.isEmpty(serialItemMap)) {
|
//生成多条流水号
|
Map<Integer/**流水号所在的位置**/, OsCodeSerialBuildBO> serialReturnMap = batchWrapperSerial(serialItemMap, serialAccordingMap, ruleDO.getBreakReUseFlag(), needAddQuantity);
|
for (Integer i = 0; i < needAddQuantity; i++) {
|
OsCodeResultVO resultVO = new OsCodeResultVO();
|
List<String> codeCopy = new ArrayList<String>(tempCode);
|
OsCodeSerialBuildBO serialBuildBO= null;
|
for(Integer serialIndex : serialReturnMap.keySet()){
|
serialBuildBO = serialReturnMap.get(serialIndex);
|
if(!CollectionUtils.isEmpty(serialBuildBO.getSerialCodeList()) && serialBuildBO.getSerialCodeList().size()>i){
|
codeCopy.set(serialIndex,serialBuildBO.getSerialCodeList().get(i));
|
}
|
}
|
resultVO.setSerialNo(serialBuildBO.getSerialNoList().get(i));
|
resultVO.setSerialCode(serialBuildBO.getSerialCodeList().get(i));
|
resultVO.setSerialUnit(serialBuildBO.getSerialUnit());
|
StringBuilder sb = new StringBuilder();
|
for(int j = 0 ; j < codeCopy.size(); j++){
|
String s = codeCopy.get(j);
|
if(s == null){
|
s = "";
|
}
|
sb.append(s);
|
}
|
resultVO.setCode(sb.toString());
|
resultVOList.add(resultVO);
|
}
|
|
}
|
return resultVOList;
|
}
|
|
|
/**
|
* 使用规则主键获取明细，并且按照排序号进行排序
|
* @param ruleOid 规则的主键
|
* @return 元素的内容
|
*/
|
private List<OsCodeRuleElementDO> listItemsByRuleOidOrderByRuleOrderNubmer(String ruleOid) {
|
VciBaseUtil.alertNotNull(ruleOid, "规则的主键");
|
List<OsCodeRuleElementDO> codeRuleElementDOS = codeRuleElementDao.selectByRuleOidOrderByRuleOrderNumber(ruleOid.trim());
|
return codeRuleElementDOS;
|
}
|
|
/**
|
* 是否存在编码规则
|
*
|
* @param codeRuleProduceDTO 编码生成所属数据传输对象，规则编号优先级大于主键，传递的数据优先级大于业务数据
|
* @return 是否包含
|
*/
|
@Override
|
public boolean existRule(OsCodeRuleProduceDTO codeRuleProduceDTO) {
|
VciBaseUtil.alertNotNull(codeRuleProduceDTO, "编码生成来源数据");
|
if (StringUtils.isBlank(codeRuleProduceDTO.getCodeRuleId())
|
&& StringUtils.isBlank(codeRuleProduceDTO.getCodeRuleOid())
|
&& (StringUtils.isBlank(codeRuleProduceDTO.getUseRuleFlag()) || StringUtils.isBlank(codeRuleProduceDTO.getOwnbizBtm()))) {
|
throw new VciBaseException("编码规则主键和编号为空，无法生成编码");
|
}
|
//查询编码规则，和相应的明细内容
|
try {
|
OsCodeRuleDO ruleDO = getRuleByDTO(codeRuleProduceDTO);
|
return ruleDO!=null&&StringUtils.isNotBlank(ruleDO.getOid());
|
}catch (Throwable e){
|
return false;
|
}
|
}
|
|
/**
|
* 上移
|
*
|
* @param codeRuleElementOid 元素的主键
|
*/
|
@Override
|
public void upIndex(String codeRuleElementOid) {
|
VciBaseUtil.alertNotNull(codeRuleElementOid,"元素的主键");
|
OsCodeRuleElementDO elementDO = codeRuleElementDao.selectByPrimaryKey(codeRuleElementOid);
|
if(elementDO == null || StringUtils.isBlank(elementDO.getOid())){
|
throw new VciBaseException(DATA_OID_NOT_EXIST,new String[]{codeRuleElementOid});
|
}
|
//查询比它小一个的
|
if(elementDO.getRuleOrderNumber() ==0){
|
return;//已经到头了
|
}
|
List<OsCodeRuleElementDO> lastElementDOList = codeRuleElementDao.selectByRuleOidAndIndex(elementDO.getPkCodeRule(),elementDO.getRuleOrderNumber()-1);
|
if(!CollectionUtils.isEmpty(lastElementDOList)){
|
OsCodeRuleElementDO elementDO1 = lastElementDOList.get(0);
|
Integer index = elementDO1.getRuleOrderNumber();
|
elementDO1.setRuleOrderNumber(elementDO.getRuleOrderNumber());
|
elementDO.setRuleOrderNumber(index);
|
codeRuleElementDao.updateByPrimaryKey(elementDO1);
|
codeRuleElementDao.updateByPrimaryKey(elementDO);
|
}
|
}
|
|
/**
|
* 下移
|
*
|
* @param codeRuleElementOid 元素的主键
|
*/
|
@Override
|
public void downIndex(String codeRuleElementOid) {
|
VciBaseUtil.alertNotNull(codeRuleElementOid,"元素的主键");
|
OsCodeRuleElementDO elementDO = codeRuleElementDao.selectByPrimaryKey(codeRuleElementOid);
|
if(elementDO == null || StringUtils.isBlank(elementDO.getOid())){
|
throw new VciBaseException(DATA_OID_NOT_EXIST,new String[]{codeRuleElementOid});
|
}
|
List<OsCodeRuleElementDO> lastElementDOList = codeRuleElementDao.selectByRuleOidAndIndex(elementDO.getPkCodeRule(),elementDO.getRuleOrderNumber()+1);
|
if(!CollectionUtils.isEmpty(lastElementDOList)){
|
OsCodeRuleElementDO elementDO1 = lastElementDOList.get(0);
|
Integer index = elementDO1.getRuleOrderNumber();
|
elementDO1.setRuleOrderNumber(elementDO.getRuleOrderNumber());
|
elementDO.setRuleOrderNumber(index);
|
codeRuleElementDao.updateByPrimaryKey(elementDO1);
|
codeRuleElementDao.updateByPrimaryKey(elementDO);
|
}
|
}
|
|
/**
|
* 获取流程依据
|
*
|
* @param ruleDTO 创建内容的数据传输对象
|
* @return 流水依据
|
*/
|
@Override
|
public String getSerialUnit(OsCodeRuleProduceDTO ruleDTO) {
|
//判断规则的编号或者规则的主键
|
VciBaseUtil.alertNotNull(ruleDTO, "编码生成来源数据");
|
if (StringUtils.isBlank(ruleDTO.getCodeRuleId())
|
&& StringUtils.isBlank(ruleDTO.getCodeRuleOid())
|
&& (StringUtils.isBlank(ruleDTO.getUseRuleFlag()) || StringUtils.isBlank(ruleDTO.getOwnbizBtm()))) {
|
throw new VciBaseException("编码规则主键和编号为空，无法生成编码");
|
}
|
//查询编码规则，和相应的明细内容
|
OsCodeRuleDO ruleDO =getRuleByDTO(ruleDTO);
|
List<OsCodeRuleElementDO> ruleItemDOs = listItemsByRuleOidOrderByRuleOrderNubmer(ruleDO.getOid());
|
VciBaseUtil.alertNotNull(ruleItemDOs,"规则的明细");
|
//查询生成编码的数据
|
Map<String, Object> businessDataMap = ruleDTO.getOwnbizDataMap();
|
//每一个元素产生的内容
|
List<String> tempCode = new ArrayList<String>();
|
|
//用来存储流水号的元素
|
Map<Integer/**流水号所在的位置**/, OsCodeRuleElementDO> serialItemMap = new HashMap<Integer, OsCodeRuleElementDO>();
|
//用来存储流水依据的元素
|
Map<Integer/**流水依据在的位置**/, String> serialAccordingMap = new HashMap<Integer, String>();
|
|
wrapperRuleElement(ruleItemDOs,ruleDTO,tempCode,businessDataMap,serialItemMap,serialAccordingMap);
|
|
String serialAccordingString = "";
|
for (String value : serialAccordingMap.values()) {
|
serialAccordingString += value;
|
}
|
if (StringUtils.isBlank(serialAccordingString)) {
|
serialAccordingString = EMPTY_SERIAL_ACCORDING;
|
}
|
return serialAccordingString;
|
}
|
|
/**
|
* 流水号生成
|
*
|
* @param serialItemMap 需要生成流水号的元素
|
* @param serialAccordingMap 流水依据的元素映射
|
* @param breakReUseFlag 是否补码
|
* @param needAddQuantity 生成编码条数
|
* @throws VciBaseException 执行出错的时候会抛出异常
|
*/
|
private synchronized Map<Integer/**流水号在的位置**/, OsCodeSerialBuildBO> batchWrapperSerial(Map<Integer/**流水号在的位置**/, OsCodeRuleElementDO> serialItemMap, Map<Integer, String> serialAccordingMap, String breakReUseFlag, Integer needAddQuantity) {
|
String serialAccordingString = "";
|
Map<Integer,OsCodeSerialBuildBO> returnMap = new HashMap<Integer, OsCodeSerialBuildBO>();
|
for (String value : serialAccordingMap.values()) {
|
serialAccordingString += value;
|
}
|
if (StringUtils.isBlank(serialAccordingString)) {
|
serialAccordingString = EMPTY_SERIAL_ACCORDING;
|
}
|
String finalSerialAccordingString = serialAccordingString;
|
//遍历生成对应位置的流水号元素
|
Set<Integer> keySet = serialItemMap.keySet();
|
for (Integer tempIndex : keySet) {
|
OsCodeRuleElementDO item = serialItemMap.get(tempIndex);
|
String serialValue = "";
|
if (BooleanEnum.TRUE.getValue().equalsIgnoreCase(breakReUseFlag)) {
|
//说明是支持断码来补的
|
OsCodeBreakCodeDO codeBreakCodeDO = breakCodeDao.selectByAccordingAndRuleOid(item.getPkCodeRule(), finalSerialAccordingString);
|
if (codeBreakCodeDO != null || StringUtils.isBlank(codeBreakCodeDO.getOid())) {
|
serialValue = codeBreakCodeDO.getBreakSerial() + "";
|
}
|
}
|
boolean persistence = WebUtil.isPersistence();
|
WebUtil.setPersistence(true);
|
if (StringUtils.isBlank(serialValue)) {
|
//找这个规则，当前流水号下的内容
|
OsCodeSerialNumberDO serialNumberDO = serialNumberDao.selectByAccordingAndRuleOid(item.getPkCodeRule(), finalSerialAccordingString);
|
if (serialNumberDO == null || StringUtils.isBlank(serialNumberDO.getOid())) {
|
//说明是第一个，需要添加
|
serialNumberDO = new OsCodeSerialNumberDO();
|
serialNumberDO.setPkCodeRule(item.getPkCodeRule());
|
serialNumberDO.setSerialUnit(finalSerialAccordingString);
|
serialNumberDO.setMaxSerial(VciBaseUtil.getInt(item.getSerialStart()) + item.getSerialStep() * needAddQuantity);
|
serialNumberDao.insert(serialNumberDO);
|
serialValue = item.getSerialStart();
|
} else {
|
//不是第一个，则重新计算起始值和最大值
|
serialValue = String.valueOf(serialNumberDO.getMaxSerial());
|
serialNumberDO.setMaxSerial(serialNumberDO.getMaxSerial() + item.getSerialStep() * needAddQuantity);
|
serialNumberDao.updateByPrimaryKey(serialNumberDO);
|
}
|
}
|
WebUtil.setPersistence(persistence);
|
OsCodeSerialBuildBO serialBuildBO = new OsCodeSerialBuildBO();
|
serialBuildBO.setSerialUnit(serialAccordingString);
|
serialBuildBO.setSerialNoList(new ArrayList<String>());
|
serialBuildBO.setSerialCodeList(new ArrayList<String>());
|
for (Integer i = 0; i < needAddQuantity; i++) {
|
String serialNo = String.valueOf(Integer.parseInt(serialValue) + i * item.getSerialStep());
|
serialBuildBO.getSerialNoList().add(serialNo);
|
serialBuildBO.getSerialCodeList().add(fillCode(item,serialNo));
|
}
|
/* TODO 暂时取消,这个地方老出问题，需要再研究逻辑。
|
if (serialAccordingMap.containsKey(tempIndex) || serialAccordingMap.size() == 0) {
|
returnMap.put(tempIndex,serialBuildBO);
|
}*/
|
returnMap.put(tempIndex,serialBuildBO);
|
}
|
return returnMap;
|
}
|
|
/**
|
* 列表查询
|
*
|
* @param conditionMap 查询条件
|
* @param pageHelper 分页的对象
|
* @return 数据显示对象
|
*/
|
@Override
|
public DataGrid<OsCodeRuleVO> dataGrid(Map<String, String> conditionMap, PageHelper pageHelper) {
|
if (pageHelper == null) {
|
pageHelper = new PageHelper(-1);
|
}
|
List<OsCodeRuleDO> ruleDOS = codeRuleDao.selectByWrapper(conditionMap, pageHelper);
|
DataGrid<OsCodeRuleVO> dataGrid = new DataGrid<OsCodeRuleVO>();
|
if (!CollectionUtils.isEmpty(ruleDOS)) {
|
dataGrid.setData(codeRuleDO2VOs(ruleDOS));
|
dataGrid.setTotal(VciBaseUtil.getInt(codeRuleDao.countByWrapper(conditionMap)));
|
}
|
return dataGrid;
|
}
|
|
/**
|
* 数据对象批量转换为显示对象
|
*
|
* @param ruleDOCollection 规则的数据对象
|
* @return 规则的显示对象
|
*/
|
@Override
|
public List<OsCodeRuleVO> codeRuleDO2VOs(Collection<OsCodeRuleDO> ruleDOCollection) {
|
List<OsCodeRuleVO> ruleVOS = new ArrayList<OsCodeRuleVO>();
|
if (ruleDOCollection != null) {
|
for (OsCodeRuleDO ruleDO : ruleDOCollection) {
|
OsCodeRuleVO vo = codeRuleDO2VO(ruleDO);
|
if (vo != null) {
|
ruleVOS.add(vo);
|
}
|
}
|
}
|
return ruleVOS;
|
}
|
|
/**
|
* 规则的元素的数据对象转换为显示对象
|
*
|
* @param elementDOCollection 元素的数据对象
|
* @return 元素的显示对象
|
*/
|
@Override
|
public List<OsCodeRuleElementVO> codeRuleElementDO2VOs(Collection<OsCodeRuleElementDO> elementDOCollection) {
|
List<OsCodeRuleElementVO> ruleElementVOS = new ArrayList<OsCodeRuleElementVO>();
|
if (elementDOCollection != null) {
|
List<String> oidList = new ArrayList<String>();
|
for (OsCodeRuleElementDO elementDO : elementDOCollection) {
|
OsCodeRuleElementVO vo = codeRuleElementDO2VO(elementDO);
|
if (vo != null) {
|
ruleElementVOS.add(vo);
|
oidList.add(vo.getOid());
|
}
|
}
|
List<OsCodeEnumDO> existEnumDOs = codeEnumDao.selectByElementOidCollection(oidList);
|
Map<String,List<OsCodeEnumVO>> enumVOMap = new HashMap<String, List<OsCodeEnumVO>>();
|
for(OsCodeEnumDO enumDO : existEnumDOs){
|
OsCodeEnumVO enumVO = new OsCodeEnumVO();
|
BeanUtil.convert(enumDO,enumVO);
|
String pkCodeRuleElement = enumVO.getPkCodeRuleElement();
|
List<OsCodeEnumVO> enumVOS = enumVOMap.containsKey(pkCodeRuleElement) ? enumVOMap.get(pkCodeRuleElement) : new ArrayList<OsCodeEnumVO>();
|
enumVOS.add(enumVO);
|
enumVOMap.put(pkCodeRuleElement, enumVOS);
|
}
|
for(OsCodeRuleElementVO elementVO : ruleElementVOS){
|
elementVO.setEnumMapList(enumVOMap.get(elementVO.getOid()));
|
}
|
}
|
return ruleElementVOS;
|
}
|
|
/**
|
* 数据对象转换为显示对象
|
*
|
* @param ruleDO 规则的数据对象
|
* @return 规则的显示对象
|
*/
|
@Override
|
public OsCodeRuleVO codeRuleDO2VO(OsCodeRuleDO ruleDO) {
|
OsCodeRuleVO ruleVO = new OsCodeRuleVO();
|
if (ruleDO != null) {
|
BeanUtil.convert(ruleDO, ruleVO);
|
ruleVO.setLcStatusText(FrameworkDataLCStatus.getTextByValue(ruleVO.getLcStatus()));
|
ruleVO.setCodeProductTypeText(OsCodeProductTypeEnum.getTextByValue(ruleVO.getCodeProductType()));
|
}
|
return ruleVO;
|
}
|
|
|
/**
|
* 明细的数据对象转换为显示对象
|
*
|
* @param elementDO 明细的数据对象
|
* @return 显示对象
|
*/
|
@Override
|
public OsCodeRuleElementVO codeRuleElementDO2VO(OsCodeRuleElementDO elementDO) {
|
OsCodeRuleElementVO elementVO = new OsCodeRuleElementVO();
|
if (elementDO != null) {
|
BeanUtil.convert(elementDO, elementVO);
|
elementVO.setCodeElementTypeText(OsCodeElementTypeEnum.getTextByValue(elementVO.getCodeElementType()));
|
elementVO.setCodeFillTypeText(OsCodeFillTypeEnum.getTextByValue(elementVO.getCodeFillType()));
|
elementVO.setCodeDateValueTypeText(OsCodeDateValueTypeEnum.getTextByValue(elementVO.getCodeDateValueType()));
|
|
}
|
return elementVO;
|
}
|
|
/**
|
* 列表的明细查询
|
*
|
* @param pkRule 规则的主键
|
* @param conditionMap 查询条件
|
* @param pageHelper 分页的对象
|
* @return 数据显示对象
|
*/
|
@Override
|
public DataGrid<OsCodeRuleElementVO> dataGridElement(String pkRule, Map<String, String> conditionMap, PageHelper pageHelper) {
|
if (pageHelper == null) {
|
pageHelper = new PageHelper(-1);
|
}
|
if (conditionMap == null) {
|
conditionMap = new HashMap<String, String>();
|
}
|
if (StringUtils.isBlank(pkRule)) {
|
return new DataGrid<OsCodeRuleElementVO>();
|
}
|
conditionMap.put("pkCodeRule", pkRule);
|
List<OsCodeRuleElementDO> ruleDOS = codeRuleElementDao.selectByWrapper(conditionMap, pageHelper);
|
DataGrid<OsCodeRuleElementVO> dataGrid = new DataGrid<OsCodeRuleElementVO>();
|
if (!CollectionUtils.isEmpty(ruleDOS)) {
|
dataGrid.setData(codeRuleElementDO2VOs(ruleDOS));
|
dataGrid.setTotal(VciBaseUtil.getInt(codeRuleElementDao.countByWrapper(conditionMap)));
|
}
|
return dataGrid;
|
}
|
|
/**
|
* 添加规则
|
*
|
* @param ruleDTO 规则的数据传输对象，需要将明细也传递
|
* @return 显示对象
|
*/
|
@Override
|
public OsCodeRuleVO addRule(OsCodeRuleDTO ruleDTO) {
|
VciBaseUtil.alertNotNull(ruleDTO, "数据传输对象", ruleDTO.getElements(), "规则的元素");
|
OsCodeRuleDO ruleDO = new OsCodeRuleDO();
|
BeanUtil.convert(ruleDTO, ruleDO);
|
ruleDO.setOid(VciBaseUtil.getPk());
|
List<OsCodeRuleElementDO> elementDOS = new ArrayList<OsCodeRuleElementDO>();
|
List<OsCodeEnumDO> enumMapDOs = new ArrayList<OsCodeEnumDO>();
|
wrapperElementDOs(ruleDO.getOid(), ruleDTO.getElements(),elementDOS,enumMapDOs);
|
|
//这个不可能超过1000个
|
codeRuleElementDao.batchInsert(elementDOS);
|
if(!CollectionUtils.isEmpty(enumMapDOs)){
|
codeEnumDao.batchInsert(enumMapDOs);
|
}
|
codeRuleDao.insert(ruleDO);
|
return codeRuleDO2VO(ruleDO);
|
}
|
|
/**
|
* 封装元素的对象
|
*
|
* @param pkRule 规则的主键
|
* @param elementDTOS 元素的数据传输对象
|
* @return 元素的数据对象
|
*/
|
private List<OsCodeRuleElementDO> wrapperElementDOs(String pkRule, List<OsCodeRuleElementDTO> elementDTOS, List<OsCodeRuleElementDO> elementDOS, List<OsCodeEnumDO> enumMapDOs) {
|
if (elementDTOS != null) {
|
for (OsCodeRuleElementDTO elementDTO : elementDTOS) {
|
OsCodeRuleElementDO elementDO = new OsCodeRuleElementDO();
|
BeanUtil.convert(elementDTO, elementDO);
|
elementDO.setPkCodeRule(pkRule);
|
elementDO.setOid(VciBaseUtil.getPk());
|
//需要每个类型做处理
|
VciBaseUtil.alertNotNull(elementDO.getCodeElementType(), "元素类型");
|
OsCodeElementTypeEnum elementEn = OsCodeElementTypeEnum.forValue(elementDO.getCodeElementType());
|
if (elementEn == null) {
|
throw new VciBaseException("元素的类型不符合要求");
|
}
|
switch (elementEn) {
|
case INPUT:
|
//没有什么需要控制
|
break;
|
case STATIC:
|
VciBaseUtil.alertNotNull(elementDO.getStaticCode(), "常量值");
|
elementDO.setMaxLength(elementDO.getStaticCode().trim().length());
|
elementDO.setMinLength(elementDO.getStaticCode().trim().length());
|
elementDO.setCodeFillType(OsCodeFillTypeEnum.NONE.getValue());
|
elementDO.setCodeFillSeparator("");
|
break;
|
case DATE:
|
VciBaseUtil.alertNotNull(elementDO.getCodeDateFormat(), "日期格式", elementDO.getCodeDateValueType(), "日期的取值类型 ");
|
if (OsCodeDateValueTypeEnum.BUSINESS.getValue().endsWith(elementDO.getCodeDateValueType())) {
|
VciBaseUtil.alertNotNull(elementDO.getCodeDateUseField(), "日期值对应的属性名称");
|
}
|
break;
|
case FIELD:
|
case ENUM:
|
VciBaseUtil.alertNotNull(elementDO.getCodeUseField(), "所需属性名称",elementDO.getEnumId(),"枚举的编号",elementDTO.getEnumMapList(),"枚举的映射内容");
|
//处理枚举的内容
|
List<OsCodeEnumDTO> enumMaps = elementDTO.getEnumMapList();
|
for(OsCodeEnumDTO enumDTO : enumMaps){
|
VciBaseUtil.alertNotNull(enumDTO.getEnumItemKey(),"枚举映射中枚举的值",enumDTO.getCodeMapValue(),"枚举映射的枚举对应的映射值");
|
OsCodeEnumDO enumDO = new OsCodeEnumDO();
|
BeanUtil.convert(enumDTO,enumDO);
|
enumDO.setPkCodeRuleElement(elementDO.getOid());
|
enumMapDOs.add(enumDO);
|
}
|
break;
|
case EXPRESSION:
|
VciBaseUtil.alertNotNull(elementDO.getCodeExpression(), "公式表达式");
|
break;
|
case SERIAL:
|
VciBaseUtil.alertNotNull(elementDO.getSerialStart(), "流水起始值", elementDO.getSerialStep(), "流水步长", elementDO.getSerialPriority(), "流水优先级");
|
break;
|
}
|
elementDOS.add(elementDO);
|
}
|
}
|
return elementDOS;
|
}
|
|
/**
|
* 修改规则
|
*
|
* @param ruleDTO 规则的数据传输对象，需要将明细也传递
|
* @return 显示对象
|
*/
|
@Override
|
public OsCodeRuleVO editRule(OsCodeRuleDTO ruleDTO) {
|
VciBaseUtil.alertNotNull(ruleDTO, "数据传输对象", ruleDTO.getElements(), "规则的元素", ruleDTO.getOid(), "规则的主键");
|
OsCodeRuleDO ruleDO = selectByOid(ruleDTO.getOid());
|
BeanUtil.convert(ruleDTO,ruleDO);
|
List<OsCodeRuleElementDO> existElementDOs = codeRuleElementDao.selectByRuleOid(ruleDO.getOid());
|
//找enum的明细内容，也是要删除的
|
List<OsCodeEnumDO> existEnumDOs = codeEnumDao.selectByRuleOid(ruleDO.getOid());
|
|
List<OsCodeRuleElementDO> elementDOS = new ArrayList<OsCodeRuleElementDO>();
|
List<OsCodeEnumDO> enumMapDOs = new ArrayList<OsCodeEnumDO>();
|
|
wrapperElementDOs(ruleDO.getOid(), ruleDTO.getElements(),elementDOS,enumMapDOs);
|
|
if(!CollectionUtils.isEmpty(existElementDOs)) {
|
List<String> existElementOidList = new ArrayList<String>();
|
for(OsCodeRuleElementDO elementDO : existElementDOs){
|
existElementOidList.add(elementDO.getOid());
|
}
|
codeRuleElementDao.batchDeleteByOids(existElementOidList);
|
}
|
if(!CollectionUtils.isEmpty(existEnumDOs)){
|
List<String> existEnumOidList = new ArrayList<String>();
|
for(OsCodeEnumDO enumDO : existEnumDOs){
|
existEnumOidList.add(enumDO.getOid());
|
}
|
codeEnumDao.batchDeleteByOids(existEnumOidList);
|
}
|
//这个不可能超过1000个
|
codeRuleElementDao.batchInsert(elementDOS);
|
if(!CollectionUtils.isEmpty(enumMapDOs)){
|
codeEnumDao.batchInsert(enumMapDOs);
|
}
|
codeRuleDao.updateByPrimaryKey(ruleDO);
|
return codeRuleDO2VO(ruleDO);
|
}
|
|
/**
|
* 删除规则，有流水号的时候不能删除
|
*
|
* @param ruleDTO 规则的数据传输对象，必须有ts和oid
|
*/
|
@Override
|
public void deleteRule(OsCodeRuleDTO ruleDTO) {
|
VciBaseUtil.alertNotNull(ruleDTO, "数据传输对象");
|
OsCodeRuleDO ruleDO = selectByOid(ruleDTO.getOid());
|
String ruleOid = ruleDO.getOid();
|
if (serialNumberDao.countByRuleOid(ruleOid) > 0) {
|
throw new VciBaseException("编码规则已经产生了流水号，不能删除");
|
}
|
codeRuleDao.deleteByPrimaryKey(ruleOid);
|
List<OsCodeRuleElementDO> existElementDOs = codeRuleElementDao.selectByRuleOid(ruleOid);
|
List<OsCodeEnumDO> existEnumDOs = codeEnumDao.selectByRuleOid(ruleDO.getOid());
|
if(!CollectionUtils.isEmpty(existElementDOs)) {
|
List<String> existElementOidList = new ArrayList<String>();
|
for(OsCodeRuleElementDO elementDO : existElementDOs){
|
existElementOidList.add(elementDO.getOid());
|
}
|
codeRuleElementDao.batchDeleteByOids(existElementOidList);
|
}
|
if(!CollectionUtils.isEmpty(existEnumDOs)){
|
List<String> existEnumOidList = new ArrayList<String>();
|
for(OsCodeEnumDO enumDO : existEnumDOs){
|
existEnumOidList.add(enumDO.getOid());
|
}
|
codeEnumDao.batchDeleteByOids(existEnumOidList);
|
}
|
}
|
|
/**
|
* 停用规则
|
*
|
* @param ruleDTO 规则的数据传输对象，必须有ts和oid
|
*/
|
@Override
|
public void disableRule(OsCodeRuleDTO ruleDTO) {
|
VciBaseUtil.alertNotNull(ruleDTO, "数据传输对象");
|
OsCodeRuleDO ruleDO = selectByOid(ruleDTO.getOid());
|
ruleDO.setLcStatus(FrameWorkDefaultValueConstant.FRAMEWORK_DATA_DISABLED);
|
codeRuleDao.updateByPrimaryKey(ruleDO);
|
}
|
|
/**
|
* 启用规则
|
*
|
* @param ruleDTO 规则的数据传输对象，必须有ts和oid
|
*/
|
@Override
|
public void enableRule(OsCodeRuleDTO ruleDTO) {
|
VciBaseUtil.alertNotNull(ruleDTO, "数据传输对象");
|
OsCodeRuleDO ruleDO = selectByOid(ruleDTO.getOid());
|
ruleDO.setLcStatus(FrameWorkDefaultValueConstant.FRAMEWORK_DATA_ENABLED);
|
codeRuleDao.updateByPrimaryKey(ruleDO);
|
}
|
|
/**
|
* 使用规则标识查询
|
*
|
* @param ownbizBtm 业务类型
|
* @param useRuleFlag 规则标识
|
* @return 规则的对象
|
* @throws VciBaseException 参数为空，规则不存在的会抛出异常
|
*/
|
private OsCodeRuleDO selectByRuleFlag(String ownbizBtm, String useRuleFlag) throws VciBaseException {
|
VciBaseUtil.alertNotNull(ownbizBtm, "业务类型", useRuleFlag, "使用标识");
|
OsCodeRuleDO ruleDO = codeRuleDao.selectByRuleFlag(ownbizBtm, useRuleFlag);
|
if (ruleDO == null || StringUtils.isBlank(ruleDO.getOid())) {
|
throw new VciBaseException("{0}业务类型中不存在{1}标识的编码规则", new String[]{ownbizBtm, useRuleFlag});
|
}
|
return ruleDO;
|
}
|
|
/**
|
* 流水号生成
|
*
|
* @param serialItemMap 需要生成流水号的元素
|
* @param serialAccordingMap 流水依据的元素映射
|
* @param tempCode 已经生成的编码的内容
|
* @param breakReUseFlag 是否补码
|
* @throws VciBaseException 执行出错的时候会抛出异常
|
*/
|
private synchronized void wrapperSerial(Map<Integer, OsCodeRuleElementDO> serialItemMap, Map<Integer, String> serialAccordingMap, List<String> tempCode, String breakReUseFlag) throws VciBaseException {
|
Map<Integer, OsCodeSerialBuildBO> buildBOMap = batchWrapperSerial(serialItemMap, serialAccordingMap, breakReUseFlag, 1);
|
for(Integer serialIndex : buildBOMap.keySet()){
|
OsCodeSerialBuildBO buildBO = buildBOMap.get(serialIndex);
|
tempCode.set(serialIndex,buildBO.getSerialCodeList().get(0));
|
}
|
//批量和单个也得统一，weidy
|
}
|
|
/**
|
* 补位
|
*
|
* @param item 元素对象
|
* @param tempCode 生成的临时编码
|
* @return 补位后的字符串
|
*/
|
private String fillCode(OsCodeRuleElementDO item, String tempCode) {
|
if (tempCode == null) {
|
tempCode = "";
|
}
|
if (tempCode.trim().length() < item.getMaxLength()) {
|
int needFillLength = item.getMaxLength() - tempCode.length();
|
for (int i = 0; i < needFillLength; i++) {
|
String fillSepartor = item.getCodeFillSeparator();
|
if (VciBaseUtil.isNull(fillSepartor)) {
|
fillSepartor = "0";
|
}
|
OsCodeFillTypeEnum fillTypeEnum = OsCodeFillTypeEnum.forValue(item.getCodeFillType());
|
switch (fillTypeEnum) {
|
case LEFT:
|
tempCode = fillSepartor + tempCode;
|
break;
|
case RIGHT:
|
tempCode = tempCode + fillSepartor;
|
break;
|
default:
|
break;
|
}
|
}
|
return tempCode;
|
} else if (tempCode.length() > item.getMaxLength()) {//长度超长了要减去掉
|
tempCode = tempCode.substring(0, item.getMaxLength());
|
return tempCode;
|
} else {
|
return tempCode;
|
}
|
}
|
|
/**
|
* 规则的明细
|
*
|
* @param ruleOid 规则的主键
|
* @return 规则的明细内容
|
* @throws VciBaseException 参数错误会抛出异常
|
*/
|
private List<OsCodeRuleElementDO> listItemsByRuleOid(String ruleOid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(ruleOid, "规则的主键");
|
List<OsCodeRuleElementDO> codeRuleElementDOS = codeRuleElementDao.selectByRuleOid(ruleOid.trim());
|
return codeRuleElementDOS;
|
}
|
|
/**
|
* 使用主键获取编码规则对象
|
*
|
* @param oid 主键
|
* @return 编码规则对象
|
* @throws VciBaseException 参数错误，规则不存在时会抛出异常
|
*/
|
private OsCodeRuleDO selectByOid(String oid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(oid, "编码规则主键");
|
OsCodeRuleDO codeRuleDO = codeRuleDao.selectByPrimaryKey(oid.trim());
|
if (codeRuleDO == null || StringUtils.isBlank(codeRuleDO.getOid())) {
|
throw new VciBaseException(DATA_OID_NOT_EXIST);
|
}
|
return codeRuleDO;
|
}
|
|
/**
|
* 使用编号获取编码规则对象
|
*
|
* @param id 编号
|
* @return 编码规则对象
|
* @throws VciBaseException 参数错误，规则不存在时会抛出异常
|
*/
|
@Override
|
public OsCodeRuleDO selectById(String id) throws VciBaseException {
|
VciBaseUtil.alertNotNull(id, "编码规则编号");
|
OsCodeRuleDO codeRuleDO = codeRuleDao.selectById(id.trim());
|
if (codeRuleDO == null || StringUtils.isBlank(codeRuleDO.getId())) {
|
throw new VciBaseException(DATA_ID_NOT_EXIST);
|
}
|
return codeRuleDO;
|
}
|
}
|
