package com.vci.ubcs.code.service.impl;
|
|
import com.alibaba.cloud.commons.lang.StringUtils;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.github.yulichang.wrapper.MPJLambdaWrapper;
|
|
import com.vci.ubcs.code.dto.CodeBasicSecDTO;
|
import com.vci.ubcs.code.dto.CodeOrderDTO;
|
import com.vci.ubcs.code.dto.CodeOrderSecDTO;
|
import com.vci.ubcs.code.entity.*;
|
import com.vci.ubcs.code.enumpack.*;
|
import com.vci.ubcs.code.lifecycle.CodeRuleLC;
|
import com.vci.ubcs.code.mapper.CodeBasicSecMapper;
|
import com.vci.ubcs.code.mapper.CodeClassifyValueMapper;
|
import com.vci.ubcs.code.mapper.CodeFixedValueMapper;
|
import com.vci.ubcs.code.mapper.CodeSerialValueMapper;
|
import com.vci.ubcs.code.service.*;
|
import com.vci.ubcs.code.vo.CodeReferConfigVO;
|
import com.vci.ubcs.code.vo.pagemodel.*;
|
import com.vci.ubcs.code.wrapper.CodeBasicSecWrapper;
|
import com.vci.ubcs.omd.cache.EnumCache;
|
import com.vci.ubcs.omd.enums.EnumEnum;
|
import com.vci.ubcs.starter.enumpack.CodeTableNameEnum;
|
import com.vci.ubcs.starter.exception.VciBaseException;
|
import com.vci.ubcs.starter.revision.model.BaseModel;
|
import com.vci.ubcs.starter.revision.service.RevisionModelUtil;
|
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
|
import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
|
import com.vci.ubcs.starter.util.UBCSCondition;
|
import com.vci.ubcs.starter.util.UBCSSqlKeyword;
|
import com.vci.ubcs.starter.web.enumpck.OsCodeFillTypeEnum;
|
import com.vci.ubcs.starter.web.pagemodel.*;
|
import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
|
import com.vci.ubcs.starter.web.util.VciBaseUtil;
|
import com.vci.ubcs.starter.web.util.VciDateUtil;
|
import com.vci.ubcs.starter.web.util.WebUtil;
|
import com.vci.ubcs.system.entity.DictBiz;
|
import com.vci.ubcs.system.feign.IDictBizClient;
|
import org.springblade.core.log.exception.ServiceException;
|
import org.springblade.core.mp.support.Query;
|
import org.springblade.core.tool.api.R;
|
import org.springblade.core.tool.utils.BeanUtil;
|
import org.springblade.core.tool.utils.Func;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
import java.rmi.ServerException;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import static com.vci.ubcs.code.constant.FrameWorkLangCodeConstant.*;
|
import static com.vci.ubcs.code.constant.MdmEngineConstant.EMPTY_SERIAL_UNIT;
|
import static com.vci.ubcs.code.constant.MdmEngineConstant.SERIAL_UNIT_SPACE;
|
|
/**
|
* 码段基础信息服务接口
|
*
|
* @author weidy
|
* @date 2022-01-24
|
*/
|
@Service
|
public class CodeBasicSecServiceImpl extends ServiceImpl<CodeBasicSecMapper, CodeBasicSec> implements ICodeBasicSecService {
|
|
@Resource
|
private CodeBasicSecMapper codeBasicSecMapper;
|
|
/**
|
* 固定码段的码值数据操作层
|
*/
|
@Resource
|
private CodeFixedValueMapper fixedValueMapper;
|
|
/**
|
* 分类码段的码值数据操作层
|
*/
|
@Resource
|
private CodeClassifyValueMapper codeClassifyValueMapper;
|
|
@Resource
|
private RevisionModelUtil revisionModelUtil;
|
|
@Resource
|
@Lazy
|
private ICodeRuleService codeRuleService;
|
|
@Resource
|
private ICodeClassifyValueService codeClassifyValueService;
|
|
@Resource
|
private ICodeReferConfigService codeReferConfigService;
|
|
@Resource
|
private IDictBizClient iDictBizClient;
|
|
/**
|
* 固定码段的码值的服务
|
*/
|
@Resource
|
private ICodeFixedValueService fixedValueService;
|
|
/**
|
* 流水号的相关的信息
|
*/
|
@Resource
|
private CodeSerialValueMapper serialValueMapper;
|
|
/**
|
* 上层分类码段的属性名称
|
*/
|
private static final String PARENT_FIELD_NAME = "parentClassifySecOid";
|
|
/**
|
* 上级分类码值的属性名称
|
*/
|
private static final String PARENT_CLASSIFY_VALUE_FIELD_NAME = "parentClassifyValueOid";
|
|
/**
|
* 查询所有的码段基础信息
|
* @param conditionMap 查询条件
|
* @param query 分页对象
|
* @return 执行结果
|
* @throws VciBaseException 查询条件和分页出错的时候会抛出异常
|
*/
|
@Override
|
public IPage<CodeBasicSecVO> gridCodeBasicSec(Query query, Map<String,Object> conditionMap) throws ServiceException {
|
if(Func.isEmpty(Func.isEmpty(conditionMap.get(CodeTableNameEnum.PL_CODE_BASICSEC.getText()+".pkCodeRule")))){
|
return null;
|
}
|
// 联表查询 ,设置表别名，表别名默认就采用表名小写，配置高级查询的时候就需要根据这个来对where条件进行配置
|
MPJLambdaWrapper<CodeBasicSec> mpjLambdaWrapper = new MPJLambdaWrapper<>(CodeBasicSec.class, CodeTableNameEnum.PL_CODE_BASICSEC.getText())
|
.selectAll(CodeBasicSec.class)
|
.selectAs(CodeClassify::getName, CodeBasicSec::getReferCodeClassifyOidName)
|
.leftJoin(CodeClassify.class, CodeTableNameEnum.PL_CODE_CLASSIFY.getText(), CodeClassify::getOid, CodeBasicSec::getReferCodeClassifyOid)
|
.leftJoin(CodeBasicSec.class,CodeTableNameEnum.PL_CODE_BASICSEC.getText()+1,CodeBasicSec::getOid,CodeBasicSec::getParentClassifySecOid
|
,ext->ext.selectAs(CodeBasicSec::getName,CodeBasicSec::getParentClassifySecText));
|
// 添加where条件
|
UBCSSqlKeyword.buildConditionByAs(conditionMap,mpjLambdaWrapper,CodeTableNameEnum.PL_CODE_BASICSEC.getText());
|
IPage<CodeBasicSec> codeBasicSecIPage = codeBasicSecMapper.selectPage(UBCSCondition.getPage(query), mpjLambdaWrapper);
|
return CodeBasicSecWrapper.build().pageVO(codeBasicSecIPage);
|
}
|
|
/**
|
* 根据编码规则批量删除码段基本信息
|
* @param codeRuleOid 编码规则主键
|
* @return 执行结果
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean batchDeleteSecByCodeRuleOid(String codeRuleOid) throws ServiceException {
|
VciBaseUtil.alertNotNull(codeRuleOid,"编码规则主键");
|
// 1、通过pkcoderule作为条件，先查询要删除基础码段
|
List<CodeBasicSec> deleteList = this.codeBasicSecMapper.selectList(Wrappers.<CodeBasicSec>query().eq("pkcoderule", codeRuleOid));
|
if (CollectionUtils.isEmpty(deleteList)){
|
return true;
|
}
|
// 2、再删除基础码段
|
boolean deletFlag = codeBasicSecMapper.deleteBatchIds(deleteList.stream().map(CodeBasicSec::getOid).collect(Collectors.toSet())) > 0;
|
// 3、再根据删除固定码段，丛查询出来的基础码段中过滤出包含固定码段的记录
|
List<CodeBasicSec> fixedSecList = deleteList.stream().filter(sec -> {
|
return CodeSecTypeEnum.CODE_FIXED_SEC.getValue().equals(sec.getSecType());
|
}).collect(Collectors.toList());
|
if (!CollectionUtils.isEmpty(fixedSecList)){
|
// 将要作为删除条件的值放在一个集合里面
|
Set<String> fixedSecOidSet = fixedSecList.stream().map(CodeBasicSec::getOid).collect(Collectors.toSet());
|
// 通过外键进行查询
|
List<CodeFixedValue> fixedValues = fixedValueMapper.selectList(Wrappers.<CodeFixedValue>query().lambda().in(CodeFixedValue::getCodeFixedSecOid,fixedSecOidSet));
|
if(!fixedValues.isEmpty()){
|
// 根据查询出来的id执行固定码段执行删除
|
deletFlag = fixedValueMapper.deleteBatchIds(fixedValues.stream().map(CodeFixedValue::getOid).collect(Collectors.toSet()))>0;
|
}
|
}
|
// 4、再删除分类码段
|
List<CodeBasicSec> classifySecList = deleteList.stream().filter(sec -> {
|
return CodeSecTypeEnum.CODE_CLASSIFY_SEC.getValue().equals(sec.getSecType());
|
}).collect(Collectors.toList());
|
if (!CollectionUtils.isEmpty(classifySecList)){
|
// 将要作为删除条件的值放在一个集合里面
|
Set<String> classifySecOidSet = classifySecList.stream().map(CodeBasicSec::getOid).collect(Collectors.toSet());
|
// 通过外键进行查询
|
List<CodeClassifyValue> codeClassifyValues = codeClassifyValueMapper.selectList(Wrappers.<CodeClassifyValue>query().lambda().in(CodeClassifyValue::getCodeClassifySecOid,classifySecOidSet));
|
if(!codeClassifyValues.isEmpty()){
|
// 根据查询出来的主键id执行固定码段执行删除
|
deletFlag = codeClassifyValueMapper.deleteBatchIds(codeClassifyValues.stream().map(CodeClassifyValue::getOid).collect(Collectors.toSet()))>0;
|
}
|
}
|
return deletFlag;
|
}
|
|
/**
|
* 根据码段分类的类型判断属性是否是空的
|
*
|
* @param codeBasicSecDTO 码段基础信息数据传输对象
|
* @return 有空的则传key-属性名 value-字段含义，没有空的则传 key-success value-true
|
*/
|
@Override
|
public KeyValue checkAttrNullableBySecType(CodeBasicSecDTO codeBasicSecDTO) throws ServiceException {
|
VciBaseUtil.alertNotNull(codeBasicSecDTO.getSecType(), "码段分类");
|
String secType = codeBasicSecDTO.getSecType();
|
HashMap<String, String> attrMap = JSONObject.parseObject(JSONObject.toJSONString(codeBasicSecDTO), HashMap.class);
|
Map<String, String> notNullableAttr = getNotNullableAttr(secType);
|
if (notNullableAttr == null) {
|
throw new VciBaseException("码段分类填写出错，请查验后重试");
|
}
|
for (String key : notNullableAttr.keySet()) {
|
if (StringUtils.isBlank(WebUtil.getStringValueFromObject(attrMap.get(key)))) {
|
KeyValue kv = new KeyValue();
|
kv.setKey(key);
|
kv.setValue(notNullableAttr.get(key));
|
return kv;
|
}
|
}
|
KeyValue kv = new KeyValue();
|
kv.setKey("success");
|
kv.setValue("true");
|
return kv;
|
}
|
|
/**
|
* 增加码段基础信息
|
*
|
* @param codeBasicSecDTO 码段基础信息数据传输对象
|
* @return 执行结果
|
* @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean addSave(CodeBasicSecDTO codeBasicSecDTO) throws VciBaseException {
|
VciBaseUtil.alertNotNull(codeBasicSecDTO, "需要添加的数据对象",codeBasicSecDTO.getPkCodeRule(),"编码规则的主键");
|
CodeRuleVO ruleVO = codeRuleService.getObjectByOid(codeBasicSecDTO.getPkCodeRule());
|
if(!CodeRuleLC.EDITING.getValue().equalsIgnoreCase(ruleVO.getLcStatus())){
|
throw new VciBaseException("编码规则的状态不是【" + CodeRuleLC.EDITING.getText() + "】！不允许修改");
|
}
|
KeyValue attrKv = checkAttrNullableBySecType(codeBasicSecDTO);
|
if (! "success".equals(attrKv.getKey())){
|
throw new VciBaseException(attrKv.getValue() + "不能为空");
|
}
|
//将DTO转换为DO
|
CodeBasicSec codeBasicSecDO = new CodeBasicSec();
|
BeanUtilForVCI.copyPropertiesIgnoreCase(codeBasicSecDTO, codeBasicSecDO);
|
//text转换
|
codeBasicSecDO.setSecTypeText(EnumCache.getValue(EnumEnum.CODE_SEC_TYPE,codeBasicSecDTO.getSecType()));
|
codeBasicSecDO.setCodeLevelTypeText(EnumCache.getValue(EnumEnum.CODE_LEVEL_TYPE,codeBasicSecDTO.getCodeLevelType()));
|
codeBasicSecDO.setCodeSecLengthTypeText(EnumCache.getValue(EnumEnum.CODE_SEC_LENGTH,codeBasicSecDTO.getCodeSecLengthType()));
|
codeBasicSecDO.setValueCutTypeText(EnumCache.getValue(EnumEnum.CODE_CUT_TYPE,codeBasicSecDTO.getValueCutType()));
|
codeBasicSecDO.setCodeGetValueTypeText(EnumCache.getValue(EnumEnum.CODE_GET_VALUE_TYPE,codeBasicSecDTO.getCodeGetValueType()));
|
//填充一些默认值
|
DefaultAttrAssimtUtil.addDefaultAttrAssimt(codeBasicSecDO, MdmBtmTypeConstant.CODE_BASIC_SEC);
|
//排序号，默认等于当前已有的数量加1
|
Long total = codeBasicSecMapper.selectCount(Wrappers.<CodeBasicSec>query()
|
.lambda()
|
.eq(CodeBasicSec::getPkCodeRule,codeBasicSecDTO.getPkCodeRule()));
|
if(total == null){
|
total = 0L;
|
}
|
codeBasicSecDO.setOrderNum(total.intValue() + 1);
|
|
//补位的时候，要控制补位字符
|
if((OsCodeFillTypeEnum.LEFT.getValue().equalsIgnoreCase(codeBasicSecDO.getCodeFillType())
|
|| OsCodeFillTypeEnum.RIGHT.getValue().equalsIgnoreCase(codeBasicSecDO.getCodeFillType()))
|
&& StringUtils.isBlank(codeBasicSecDO.getCodeFillSeparator())){
|
throw new VciBaseException("当补位方式为左补位或者右补位的时候，补位字符不能为空");
|
}
|
CodeReferConfigVO codeReferConfigVO = null;
|
//引用码段的时候，需要判断参照的信息是否正确
|
if(CodeSecTypeEnum.CODE_REFER_SEC.getValue().equalsIgnoreCase(codeBasicSecDO.getSecType())){
|
if(StringUtils.isBlank(codeBasicSecDO.getReferConfig())){
|
throw new VciBaseException("引用码段的时候，需要填写参照配置的内容");
|
}
|
try{
|
//JSONObject.parseObject(codeBasicSecDO.getReferConfig(), UIFormReferVO.class);
|
codeReferConfigVO = JSONObject.parseObject(codeBasicSecDO.getReferConfig(), CodeReferConfigVO.class);
|
// 将参照配置进行持久化，给用户提供可可选择参照配置的方式
|
}catch (Throwable e){
|
throw new VciBaseException("引用码段的时候，参照配置的内容的格式不正确,",new String[0],e);
|
}
|
// 判断是否为引用码段，如果是应用码段的话，为了适配前端组件，这里要对表进行处理一下，按照以前的参照格式进行转换
|
codeBasicSecDO.setReferValueInfo(referConfigToUIUiTable(codeReferConfigVO));
|
if(Func.toBoolean(codeReferConfigVO.getIsPersistence())){
|
codeReferConfigService.insert(codeReferConfigVO);
|
}
|
}
|
boolean resBoolean = codeBasicSecMapper.insert(codeBasicSecDO) > 0;
|
//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
|
if(StringUtils.isNotBlank(codeBasicSecDO.getCodeFillSeparator())){
|
DictBiz dictBiz = new DictBiz();
|
dictBiz.setCode("codeFillSeparator");
|
dictBiz.setDictKey(codeBasicSecDO.getCodeFillSeparator());
|
dictBiz.setDictValue(codeBasicSecDO.getCodeFillSeparator());
|
//从原来的charService（可输可选）更改为调用omd中的接口来实现
|
iDictBizClient.getCheck(dictBiz);
|
//charService.save(MdmBtmTypeConstant.CODE_BASIC_SEC,"codefileseparator",codeBasicSecDO.getCodeFillSeparator(),sessionInfo);
|
}
|
return resBoolean;
|
}
|
|
/**
|
* 将referconfig转换为JSON格式的UIFormReferVO
|
* @param codeReferConfig
|
* @return
|
*/
|
private String referConfigToUIUiTable(CodeReferConfigVO codeReferConfig){
|
// 拷贝为以前的老对象
|
UIReferConfigFormVO uiFormReferVO = new UIReferConfigFormVO();
|
BeanUtil.copy(codeReferConfig,uiFormReferVO);
|
|
// 表格的自定义定义
|
UITableConfigVO uiTableConfigVO = new UITableConfigVO();
|
uiTableConfigVO.setPage(new UITablePageVO(codeReferConfig.getLimit(),1));
|
// 列表的列的信息转换
|
List<TableColVO> uiTableFieldVOs = new ArrayList<>();
|
// 快速查询列
|
List<TableColVO> queryColumns = new ArrayList<>();
|
if(!CollectionUtils.isEmpty(codeReferConfig.getCodeShowFieldConfigVOS())){
|
codeReferConfig.getCodeShowFieldConfigVOS().stream().forEach(showField ->{
|
TableColVO tableColVO = new TableColVO();
|
BeanUtil.copy(showField,tableColVO);
|
tableColVO.setSortField(showField.getAttrSortField());
|
uiTableFieldVOs.add(tableColVO);
|
if(Func.toBoolean(showField.getIsQuery())){
|
TableColVO tableQueryColumns = new TableColVO();
|
BeanUtil.copy(showField,tableQueryColumns);
|
tableColVO.setSortField(showField.getAttrSortField());
|
queryColumns.add(tableQueryColumns);
|
}
|
});
|
}
|
// 显示的列
|
uiTableConfigVO.setCols(uiTableFieldVOs);
|
// 快速查询列
|
uiTableConfigVO.setQueryColumns(queryColumns);
|
//set给表格配置属性
|
uiFormReferVO.setTableConfig(uiTableConfigVO);
|
//字段名不一致，需要手动set
|
uiFormReferVO.setMuti(Func.toBoolean(codeReferConfig.getIsMuti()));
|
uiFormReferVO.setInitSort(new UIFieldSortVO(codeReferConfig.getSortField(),codeReferConfig.getSortType()));
|
// 筛选条件
|
HashMap<String, String> whereMap = new HashMap<>();
|
if(!codeReferConfig.getCodeSrchCondConfigVOS().isEmpty()){
|
codeReferConfig.getCodeSrchCondConfigVOS().stream().forEach(srch->{
|
whereMap.put(srch.getFilterField()+srch.getFilterType(),srch.getFilterValue());
|
});
|
}
|
uiFormReferVO.setWhere(whereMap);
|
return JSONObject.toJSONString(uiFormReferVO);
|
}
|
|
/**
|
* 修改码段基础信息
|
*
|
* @param codeBasicSecDTO 码段基础信息数据传输对象
|
* @return 执行结果
|
* @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean editSave(CodeBasicSecDTO codeBasicSecDTO) throws ServerException {
|
VciBaseUtil.alertNotNull(codeBasicSecDTO, "需要添加的数据对象");
|
KeyValue attrKv = checkAttrNullableBySecType(codeBasicSecDTO);
|
if (!"success".equals(attrKv.getKey())){
|
throw new VciBaseException(attrKv.getValue() + "不能为空");
|
}
|
//将DTO转换为DO
|
CodeBasicSec codeBasicSecDO = selectByOid(codeBasicSecDTO.getOid());
|
DefaultAttrAssimtUtil.updateDefaultAttrAssimt(codeBasicSecDO);
|
boolean status = codeRuleService.checkEditDelStatus(codeRuleService.getObjectByOid(codeBasicSecDO.getPkCodeRule()).getLcStatus());
|
boolean resBoolean;
|
CodeReferConfigVO codeReferConfigVO = null;
|
if (!status){
|
//返回错误信息
|
throw new VciBaseException("编码规则不允许编辑或删除！");
|
} else {
|
//补位的时候，要控制补位字符
|
if((OsCodeFillTypeEnum.LEFT.getValue().equalsIgnoreCase(codeBasicSecDO.getCodeFillType())
|
|| OsCodeFillTypeEnum.RIGHT.getValue().equalsIgnoreCase(codeBasicSecDO.getCodeFillType()))
|
&& StringUtils.isBlank(codeBasicSecDO.getCodeFillSeparator())){
|
throw new VciBaseException("当补位方式为左补位或者右补位的时候，补位字符不能为空");
|
}
|
//引用码段的时候，需要判断参照的信息是否正确
|
if(CodeSecTypeEnum.CODE_REFER_SEC.getValue().equalsIgnoreCase(codeBasicSecDO.getSecType())){
|
if(StringUtils.isBlank(codeBasicSecDTO.getReferConfig())){
|
throw new VciBaseException("引用码段的时候，需要填写参照配置的内容");
|
}
|
try{
|
// JSONObject.parseObject(codeBasicSecDO.getReferConfig(), UIFormReferVO.class);
|
codeReferConfigVO = JSONObject.parseObject(codeBasicSecDTO.getReferConfig(), CodeReferConfigVO.class);
|
}catch (Throwable e){
|
throw new VciBaseException("引用码段的时候，参照配置的内容的格式不正确,",new String[0],e);
|
}
|
// 判断是否为引用码段，如果是引用码段的话，为了适配前端组件，这里要对表进行处理一下，按照以前的参照格式进行转换
|
codeBasicSecDO.setReferValueInfo(referConfigToUIUiTable(codeReferConfigVO));
|
if(codeReferConfigVO.getIsPersistence()=="true"){
|
codeReferConfigService.insert(codeReferConfigVO);
|
}
|
}
|
// revisionModelUtil.copyFromDTOIgnore(codeBasicSecDTO, codeBasicSecDO);//此处的拷贝会把referValueInfo的值给覆盖掉，需要重新赋值
|
BaseModel tempModel = new BaseModel();
|
BeanUtilForVCI.copyPropertiesIgnoreCase(codeBasicSecDO, tempModel);
|
BeanUtil.copyProperties(codeBasicSecDTO, codeBasicSecDO,"referValueInfo");
|
BeanUtilForVCI.copyPropertiesIgnoreCase(tempModel, codeBasicSecDO);
|
codeBasicSecDO.setId(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getValueFromField("id", codeBasicSecDTO)));
|
codeBasicSecDO.setName(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getValueFromField("name", codeBasicSecDTO)));
|
codeBasicSecDO.setDescription(VciBaseUtil.getStringValueFromObject(VciBaseUtil.getValueFromField("description", codeBasicSecDTO)));
|
|
resBoolean = codeBasicSecMapper.updateById(codeBasicSecDO)>0;
|
// 从分类码段或固定码段改为其他码段时，判断用户是否选择了清空码值
|
if(codeBasicSecDTO.getIsClearValue()){
|
// 分类码值清空
|
if(codeBasicSecDTO.getSecType().equals(CodeSecTypeEnum.CODE_CLASSIFY_SEC.getValue())){
|
codeClassifyValueService.deleteClassifyValueBySecOid(codeBasicSecDTO.getOid());
|
}else {
|
//固定码值清空
|
fixedValueService.deleteFixedValueBySecOid(codeBasicSecDTO.getOid());
|
}
|
}
|
//SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
|
if(StringUtils.isNotBlank(codeBasicSecDO.getCodeFillSeparator())){
|
DictBiz dictBiz = new DictBiz();
|
dictBiz.setCode("codeFillSeparator");
|
dictBiz.setDictKey(codeBasicSecDO.getCodeFillSeparator());
|
dictBiz.setDictValue(codeBasicSecDO.getCodeFillSeparator());
|
//从原来的charService（可输可选）更改为调用omd中的接口来实现
|
iDictBizClient.getCheck(dictBiz);
|
//charService.save(MdmBtmTypeConstant.CODE_BASIC_SEC,"codefileseparator",codeBasicSecDO.getCodeFillSeparator(),sessionInfo);
|
}
|
}
|
return resBoolean;
|
}
|
|
/**
|
* 根据码段类型获取不可为空的字段
|
*
|
* @param secType 码段类型
|
* @return 不可为空的字段集合
|
*/
|
private Map<String, String> getNotNullableAttr(String secType) throws ServiceException {
|
Map<String, String> attrMap = new HashMap<>();
|
if (CodeSecTypeEnum.CODE_ATTR_SEC.getValue().equalsIgnoreCase(secType)) {
|
attrMap.put("name", "属性码段名称");
|
} else if (CodeSecTypeEnum.CODE_DATE_SEC.getValue().equalsIgnoreCase(secType)) {
|
attrMap.put("name", "日期码段名称");
|
attrMap.put("codeDateFormatStr", "日期格式");
|
} else if (CodeSecTypeEnum.CODE_FIXED_SEC.getValue().equalsIgnoreCase(secType)) {
|
attrMap.put("name", "固定码段名称");
|
attrMap.put("codeSecLengthType", "码段长度类型");
|
attrMap.put("codeSecLength", "码段的长度");
|
} else if (CodeSecTypeEnum.CODE_LEVEL_SEC.getValue().equalsIgnoreCase(secType)) {
|
attrMap.put("name", "层级码段名称");
|
attrMap.put("codeLevelType", "层级类型");
|
attrMap.put("valueCutType", "字符截取类型");
|
} else if (CodeSecTypeEnum.CODE_REFER_SEC.getValue().equalsIgnoreCase(secType)) {
|
attrMap.put("name", "引用码段名称");
|
} else if (CodeSecTypeEnum.CODE_SERIAL_SEC.getValue().equalsIgnoreCase(secType)) {
|
attrMap.put("name", "流水码段名称");
|
attrMap.put("codeSecLength", "码段的长度");
|
attrMap.put("codeFillType", "编码补位方式");
|
attrMap.put("codeFillLength", "填充长度");
|
attrMap.put("codeFillLimit", "流水上限");
|
attrMap.put("codeFillFlag", "流水是否补码");
|
} else if (CodeSecTypeEnum.CODE_VARIABLE_SEC.getValue().equalsIgnoreCase(secType)) {
|
attrMap.put("name", "可变码段名称");
|
attrMap.put("codeSecLength", "码段的长度");
|
attrMap.put("codeFillType", "编码补位方式");
|
} else if (CodeSecTypeEnum.CODE_CLASSIFY_SEC.getValue().equalsIgnoreCase(secType)) {
|
attrMap.put("name", "分类码段名称");
|
attrMap.put("codeSecLengthType", "码段长度类型");
|
attrMap.put("codeSecLength", "码段的长度");
|
} else {
|
attrMap = null;
|
}
|
return attrMap;
|
}
|
|
/**
|
* 删除码段基础信息
|
* @param codeBasicSecDTO 码段基础信息数据传输对象，oid和ts需要传输
|
* @return 删除结果反馈：：success：成功，fail：失败
|
* @throws VciBaseException 参数为空，被引用时抛出异常
|
*/
|
@Override
|
public R deleteCodeBasicSec(CodeBasicSecDTO codeBasicSecDTO) throws VciBaseException {
|
VciBaseUtil.alertNotNull(codeBasicSecDTO, "码段基础信息数据对象", codeBasicSecDTO.getOid(), "码段基础信息的主键");
|
return this.deleteCodeBasicSecByPrimaryKey(codeBasicSecDTO.getOid());
|
}
|
|
/**
|
* 主键删除码段基础信息
|
*
|
* @param oid 码段基础信息主键
|
* @return 删除结果反馈：：success：成功，fail：失败
|
* @throws VciBaseException 参数为空，被引用时抛出异常
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R deleteCodeBasicSecByPrimaryKey(String oid) throws VciBaseException {
|
CodeBasicSec codeBasicSecDO = selectByOid(oid);
|
boolean isLinked = checkIsLinked(codeBasicSecDO.getPkCodeRule(), oid);
|
if (isLinked) {
|
return R.fail("编码规则已被引用，不允许编辑或删除");
|
}
|
//执行删除操作
|
boolean eftDeleteBasic = codeBasicSecMapper.deleteById(oid) > 0;
|
if (CodeSecTypeEnum.CODE_FIXED_SEC.getValue().equals(codeBasicSecDO.getSecType())){
|
List<CodeFixedValue> fixedValueDOS = fixedValueMapper.selectList(Wrappers.<CodeFixedValue>query()
|
.lambda().eq(CodeFixedValue::getCodeFixedSecOid,codeBasicSecDO.getOid())
|
);
|
if(!CollectionUtils.isEmpty(fixedValueDOS)){
|
fixedValueMapper.deleteBatchIds(fixedValueDOS.stream().map(CodeFixedValue::getOid).collect(Collectors.toSet()));
|
}
|
}
|
if (CodeSecTypeEnum.CODE_CLASSIFY_SEC.getValue().equals(codeBasicSecDO.getSecType())){
|
List<CodeClassifyValue> classifyValueDOS = codeClassifyValueMapper.selectList(Wrappers.<CodeClassifyValue>query()
|
.lambda().eq(CodeClassifyValue::getCodeClassifySecOid,codeBasicSecDO.getOid())
|
);
|
if(!CollectionUtils.isEmpty(classifyValueDOS)) {
|
codeClassifyValueMapper.deleteBatchIds(classifyValueDOS.stream().map(CodeClassifyValue::getOid).collect(Collectors.toSet()));
|
}
|
}
|
|
return eftDeleteBasic ? R.success(DELETE_SUCCESS) : R.fail(DELETE_FAIL);
|
}
|
|
/**
|
* 主键获取码段基础信息
|
*
|
* @param oid 主键
|
* @return 码段基础信息显示对象
|
* @throws VciBaseException 参数为空，数据不存在时会抛出异常
|
*/
|
@Override
|
public CodeBasicSecVO getObjectByOid(String oid) throws VciBaseException {
|
return CodeBasicSecWrapper.build().entityVO(selectByOid(oid));
|
}
|
|
/**
|
* 主键批量获取码段基础信息
|
*
|
* @param oidCollections 主键集合，但是受性能影响，建议一次查询不超过10000个
|
* @return 码段基础信息显示对象
|
* @throws VciBaseException 查询出现异常时会抛出
|
*/
|
@Override
|
public Collection<CodeBasicSecVO> listCodeBasicSecByOids(Collection<String> oidCollections) throws VciBaseException {
|
VciBaseUtil.alertNotNull(oidCollections, "数据对象主键集合");
|
List<CodeBasicSec> codeBasicSecDOList = listCodeBasicSecDOByOidCollections(oidCollections);
|
return CodeBasicSecWrapper.build().listVO(codeBasicSecDOList);
|
}
|
|
/**
|
* 参照码段基础信息列表
|
*
|
* @param conditionMap 查询条件
|
* @param query 分页和排序
|
* @return 码段基础信息显示对象列表，生效的内容
|
* @throws VciBaseException 查询条件和分页出错的时候会抛出异常
|
*/
|
@Override
|
public IPage<CodeBasicSecVO> refDataGridCodeBasicSec(Query query ,Map<String,Object> conditionMap) throws VciBaseException {
|
return gridCodeBasicSec(query,conditionMap);
|
}
|
|
/**
|
* 参照分类的码段
|
* @param conditionMap 查询条件
|
* @param query 分页和排序
|
* @return 码段的内容
|
*/
|
@Override
|
public IPage<CodeBasicSecVO> refDataGridClassifySec(Query query ,Map<String,Object> conditionMap) throws VciBaseException {
|
if(Func.isEmpty(conditionMap.get("pkCodeRule"))){
|
return null;
|
}
|
conditionMap.put("secType",(CodeSecTypeEnum.CODE_CLASSIFY_SEC.getValue()));
|
return refDataGridCodeBasicSec(query.setAscs("orderNum"),conditionMap);
|
}
|
|
/**
|
* 克隆码段信息
|
*
|
* @param oidList 源码段信息主键集合
|
* @param pkCodeRule 目标编码规则
|
* @return 克隆结果反馈：：success：成功，fail：失败
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R cloneCodeBasicSec(List<String> oidList, String pkCodeRule) throws ServiceException, ServerException {
|
boolean isLinked = checkIsLinked(pkCodeRule,null);
|
if (isLinked) {
|
return R.fail("编码规则已被引用，不允许编辑或删除");
|
}
|
List<CodeBasicSec> createList = new ArrayList<>();
|
List<CodeBasicSec> basicSecDOS = codeBasicSecMapper.selectBatchIds(oidList);
|
/* 需要注意的是克隆过来的码段需要对orderNum进行排序，否则会出现排序乱跳的情况
|
实现方式是查询出该规则下根据orderNum排序后的最后一个码段 */
|
LambdaQueryWrapper<CodeBasicSec> lastBasicWrapper = Wrappers.<CodeBasicSec>query()
|
.lambda().orderByDesc(CodeBasicSec::getOrderNum)
|
.eq(CodeBasicSec::getPkCodeRule,pkCodeRule)
|
.last("limit 1");
|
CodeBasicSec lastCodeBasicSec = codeBasicSecMapper.selectOne(lastBasicWrapper);
|
// 排序号从这儿开始排
|
int orderNum = Func.isEmpty(lastCodeBasicSec) || Func.isEmpty(lastCodeBasicSec.getOrderNum()) ? -1 : lastCodeBasicSec.getOrderNum();
|
if(basicSecDOS.isEmpty()){
|
return R.fail("克隆的码段信息不存在！");
|
}
|
List<CodeBasicSec> codeClassifySec = new ArrayList<>();
|
Map<String,List<CodeFixedValue>> codeFixedValueMaps = new HashMap<>();
|
for (CodeBasicSec sec : basicSecDOS) {
|
CodeBasicSec newSecDO = new CodeBasicSec();
|
BeanUtilForVCI.copyPropertiesIgnoreCase(sec,newSecDO);
|
String oldBasicOid = newSecDO.getOid();
|
newSecDO.setId(newSecDO.getId());
|
newSecDO.setName(newSecDO.getName());
|
orderNum++;
|
newSecDO.setOrderNum(orderNum);
|
newSecDO.setPkCodeRule(pkCodeRule);
|
// 判断是否是分类码段,业务逻辑稍微复杂一点所以需要先提出来单独处理
|
if(newSecDO.getSecType().equals(CodeSecTypeEnum.CODE_CLASSIFY_SEC.getValue())){
|
// 存储旧的码段oid和新的码段的oid的关联关系
|
codeClassifySec.add(newSecDO);
|
continue;
|
}
|
// 更改创建时间，修改时间等默认值
|
DefaultAttrAssimtUtil.addDefaultAttrAssimt(newSecDO,MdmBtmTypeConstant.CODE_BASIC_SEC);
|
//固定码段
|
if(newSecDO.getSecType().equals(CodeSecTypeEnum.CODE_FIXED_SEC.getValue())){
|
// 固定码段存储好oid和码值的关联关系
|
codeFixedValueMaps.put(newSecDO.getOid(),fixedValueService.list(Wrappers.<CodeFixedValue>query()
|
.lambda().eq(CodeFixedValue::getCodeFixedSecOid, oldBasicOid)
|
));
|
}
|
createList.add(newSecDO);
|
}
|
// 处理分类码段的oid，因为oid关联parentClassifyOid，与码值codeClassifyOid，码值又需要通过旧的码段oid来查询，所以不能直接改变oid
|
changeParentOidAssnOid(codeClassifySec);
|
// 将处理过的分类码段也添加进要做新增处理的码段集合中
|
createList.addAll(codeClassifySec);
|
boolean resBoolean = true;
|
if(!createList.isEmpty()){
|
resBoolean = saveBatch(createList);
|
}
|
// 最终要存入码值表中的，码值对象
|
List<CodeFixedValue> codeFixedDOValues = new ArrayList<>();
|
// 构造码值对象，与码段主键关联关系，以及改变固定码值的oid
|
codeFixedValueMaps.forEach((key, value) -> {
|
value.stream().forEach(item -> {
|
item.setOid("");
|
item.setCodeFixedSecOid(key);
|
DefaultAttrAssimtUtil.updateDefaultAttrAssimt(item);
|
codeFixedDOValues.add(item);
|
});
|
});
|
boolean resFixed = true;
|
if(!codeFixedValueMaps.isEmpty()){
|
// 克隆固定码值
|
resFixed = fixedValueService.saveBatch(codeFixedDOValues);
|
}
|
return (resBoolean&&resFixed) ? R.data(resBoolean,"克隆码段信息成功"):R.fail("克隆码段信息失败！");
|
}
|
|
/**
|
* 改变码段中父分类码段和子分类码段之间的关联oid为新的oid,并且不破坏分类码值的关联关系
|
* @param basicSecs
|
* @return
|
* @throws ServerException
|
*/
|
@Override
|
public boolean changeParentOidAssnOid(List<CodeBasicSec> basicSecs) throws ServerException {
|
Map<String, List<CodeClassifyValue>> codeClassValues = new HashMap<>();
|
List<CodeClassifyValue> codeClassifyDOValues = new ArrayList<>();
|
HashMap<String, String> oidMap = new HashMap<>();
|
boolean resClone = false;
|
try {
|
// 遍历对象数组，为每个对象生成新的oid，并将原始oid和新oid的映射关系存储到Map中
|
for (CodeBasicSec obj : basicSecs) {
|
String originalOid = obj.getOid();
|
String newOid = VciBaseUtil.getPk();
|
oidMap.put(originalOid, newOid);
|
}
|
// 遍历对象数组，更新每个对象的oid和codeClassifySecOid属性值
|
for (CodeBasicSec obj : basicSecs) {
|
String originalOid = obj.getOid();
|
String newOid = oidMap.get(originalOid);
|
// 新的oid关联要克隆码值
|
codeClassValues.put(newOid,codeClassifyValueService.list(Wrappers.<CodeClassifyValue>query()
|
.lambda().eq(CodeClassifyValue::getCodeClassifySecOid, originalOid)));
|
obj.setOid(newOid);
|
String originalParentClassifyValueOid = obj.getParentClassifySecOid();
|
String newParentClassifyValueOid = oidMap.get(originalParentClassifyValueOid);
|
obj.setParentClassifySecOid(newParentClassifyValueOid);
|
}
|
codeClassValues.forEach((key, value) -> {
|
value.stream().forEach(item -> {
|
DefaultAttrAssimtUtil.updateDefaultAttrAssimt(item);
|
item.setCodeClassifySecOid(key);
|
codeClassifyDOValues.add(item);
|
});
|
});
|
resClone = codeClassifyValueService.cloneCodeClassifyVaue(codeClassifyDOValues);
|
}catch (Exception e){
|
throw new ServerException("父分类码段和子分类码段clone转换oid时出错："+e.getCause());
|
}
|
return resClone;
|
}
|
|
/**
|
* 查询目标分类码段所在的树结构
|
*
|
* @param oid 目标分类码段主键
|
* @return 分类码段树结构
|
*/
|
/*@Override
|
public List<Tree> gridCodeClassifySecTree(String oid) {
|
VciParentQueryOption queryOption = new VciParentQueryOption(PARENT_FIELD_NAME);
|
queryOption.setfOid(oid);
|
queryOption.setLinkTypeFlag(false);
|
queryOption.setHasSelf(true);
|
VciQueryWrapperForDO wrapper = new VciQueryWrapperForDO(CodeBasicSec.class);
|
wrapper.childQueryParent(queryOption);
|
List<CodeBasicSec> doList = codeBasicSecMapper.selectByWrapper(wrapper);
|
List<String> secOid = new ArrayList<>();
|
doList.forEach(o -> secOid.add(o.getOid()));
|
List<CodeClassifyValueVO> valueVOs = (List<CodeClassifyValueVO>) codeClassifyValueService.listCodeClassifyValueByOids(secOid);
|
TreeQueryObject treeQueryObject = new TreeQueryObject();
|
treeQueryObject.setMultipleSelect(false);
|
treeQueryObject.setShowCheckBox(false);
|
treeQueryObject.setQueryAllLevel(false);
|
treeQueryObject.setValueField("oid");
|
treeQueryObject.setTextField("name");
|
treeQueryObject.setQueryAllRev(false);
|
TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_CLASSIFY_VALUE_FIELD_NAME);
|
treeWrapperOptions.copyFromTreeQuery(treeQueryObject);
|
return revisionModelUtil.doList2Trees(valueVOs,treeWrapperOptions,(CodeClassifyValueVO s) ->{
|
//可以在这里处理树节点的显示
|
return s.getId() + " " + s.getName() + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
|
.getLcStatus()) ? (" 【停用】 ") : "");
|
});
|
}*/
|
|
/**
|
* 上移
|
*
|
* @param oid 主键
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean upOrderNum(String oid) throws ServiceException{
|
CodeBasicSec secDO = selectByOid(oid);
|
if(secDO.getOrderNum() > 1){
|
//等于1的时候不能上移了
|
//找比自己小的
|
List<CodeBasicSec> lastSecDOs = codeBasicSecMapper.selectList(Wrappers.<CodeBasicSec>query()
|
.lambda().eq(CodeBasicSec::getPkCodeRule,secDO.getPkCodeRule())
|
.eq(CodeBasicSec::getOrderNum,String.valueOf(secDO.getOrderNum()-1))
|
);
|
if(!CollectionUtils.isEmpty(lastSecDOs)){
|
CodeBasicSec lastSec = lastSecDOs.get(0);
|
codeBasicSecMapper.update(null, Wrappers.<CodeBasicSec>update()
|
.lambda().set(CodeBasicSec::getOrderNum, lastSec.getOrderNum() + 1)
|
.eq(CodeBasicSec::getOid, lastSec.getOid())
|
);
|
}
|
codeBasicSecMapper.update(null, Wrappers.<CodeBasicSec>update()
|
.lambda().set(CodeBasicSec::getOrderNum, secDO.getOrderNum() - 1)
|
.eq(CodeBasicSec::getOid, secDO.getOid())
|
);
|
}
|
return true;
|
}
|
|
/**
|
* 下移
|
*
|
* @param oid 主键
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean downOrderNum(String oid) throws ServiceException {
|
CodeBasicSec secDO = selectByOid(oid);
|
Long total = codeBasicSecMapper.selectCount(Wrappers.<CodeBasicSec>query()
|
.lambda().eq(CodeBasicSec::getPkCodeRule,secDO.getPkCodeRule())
|
);
|
if(secDO.getOrderNum() < total){
|
//小于总数的时候才下移
|
List<CodeBasicSec> lastSecDOs = codeBasicSecMapper.selectList(Wrappers.<CodeBasicSec>query()
|
.lambda().eq(CodeBasicSec::getOrderNum,secDO.getOrderNum()+1)
|
.eq(CodeBasicSec::getPkCodeRule,secDO.getPkCodeRule())
|
);
|
if(!CollectionUtils.isEmpty(lastSecDOs)){
|
CodeBasicSec lastSec = lastSecDOs.get(0);
|
codeBasicSecMapper.update(null, Wrappers.<CodeBasicSec>update()
|
.lambda().set(CodeBasicSec::getOrderNum, lastSec.getOrderNum() - 1)
|
.eq(CodeBasicSec::getOid, lastSec.getOid())
|
);
|
}
|
codeBasicSecMapper.update(null, Wrappers.<CodeBasicSec>update()
|
.lambda().set(CodeBasicSec::getOrderNum, secDO.getOrderNum() + 1)
|
.eq(CodeBasicSec::getOid, secDO.getOid())
|
);
|
}
|
return true;
|
}
|
|
/**
|
* 树形结构查询oid
|
* @param codeClassifySecOid
|
* @return
|
*/
|
@Override
|
public List<String> getOidByCodeclassifysecOid(String codeClassifySecOid)throws ServiceException {
|
return codeBasicSecMapper.getOidByCodeclassifysecOid(codeClassifySecOid.trim());
|
}
|
|
/**
|
* 校验是否被引用
|
*
|
* @param codeRuleOid 编码规则主键
|
* @param codeBasicSecOid 编码基础信息主键
|
* @return true表示已被引用，false表示未被引用
|
* @throws VciBaseException 被引用的时候会抛出异常
|
*/
|
private boolean checkIsLinked(String codeRuleOid, String codeBasicSecOid) throws VciBaseException {
|
boolean flag = true;
|
if (StringUtils.isNotBlank(codeRuleOid)) {
|
boolean status = codeRuleService.checkEditDelStatus(codeRuleService.getObjectByOid(codeRuleOid).getLcStatus());
|
if (!status){
|
return true;
|
}
|
boolean alreadyInUse = codeRuleService.isAlreadyInUse(codeRuleOid);
|
if (!alreadyInUse){
|
flag = false;
|
}
|
} else {
|
boolean status = codeRuleService.checkEditDelStatus(codeRuleService.getObjectByOid(codeBasicSecMapper.selectById(codeBasicSecOid).getPkCodeRule()).getLcStatus());
|
if (!status){
|
return true;
|
}
|
boolean alreadyInUse = codeRuleService.isAlreadyInUse(codeBasicSecMapper.selectById(codeBasicSecOid).getPkCodeRule());
|
if (!alreadyInUse){
|
flag = false;
|
}
|
}
|
return flag;
|
}
|
|
/**
|
* 使用主键集合查询数据对象
|
*
|
* @param oidCollections 主键的集合
|
* @return 数据对象列表
|
*/
|
private List<CodeBasicSec> listCodeBasicSecDOByOidCollections(Collection<String> oidCollections) {
|
List<CodeBasicSec> codeBasicSecDOList = new ArrayList<>();
|
if (!CollectionUtils.isEmpty(oidCollections)) {
|
Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
|
for (Collection<String> oids : oidCollectionsList) {
|
List<CodeBasicSec> tempDOList = codeBasicSecMapper.selectBatchIds(oids);
|
if (!CollectionUtils.isEmpty(tempDOList)) {
|
codeBasicSecDOList.addAll(tempDOList);
|
}
|
}
|
}
|
return codeBasicSecDOList;
|
}
|
|
/**
|
* 主键查询数据对象
|
*
|
* @param oid 主键
|
* @return 数据对象
|
* @throws VciBaseException 参数为空，并且数据不存在的时候会抛出异常
|
*/
|
private CodeBasicSec selectByOid(String oid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(oid, "主键");
|
CodeBasicSec codeBasicSecDO = codeBasicSecMapper.selectById(oid.trim());
|
if (codeBasicSecDO == null || StringUtils.isBlank(codeBasicSecDO.getOid())) {
|
throw new VciBaseException(DATA_OID_NOT_EXIST);
|
}
|
return codeBasicSecDO;
|
}
|
|
/**
|
* 使用规则的主键获取对应的码段内容
|
*
|
* @param ruleOid 规则的内容
|
* @return 码段的内容
|
*/
|
@Override
|
public List<CodeBasicSecVO> listCodeBasicSecByRuleOid(String ruleOid)throws ServiceException {
|
if(StringUtils.isBlank(ruleOid)){
|
return new ArrayList<>();
|
}
|
LambdaQueryWrapper<CodeBasicSec> wrapper = Wrappers.<CodeBasicSec>query().lambda()
|
.eq(CodeBasicSec::getPkCodeRule, ruleOid)
|
.orderByAsc(CodeBasicSec::getOrderNum);
|
List<CodeBasicSec> secDOList = baseMapper.selectList(wrapper);//
|
return codeBasicSecDO2VOs(secDOList,true);
|
}
|
|
/**
|
* 批量数据对象转换为显示对象
|
*
|
* @param codeBasicSecDOs 数据对象列表
|
* @param hasFixedValue 是否有固定值
|
* @return 显示对象
|
* @throws VciBaseException 参数为空或者不存在的时候会抛出异常
|
*/
|
@Override
|
public List<CodeBasicSecVO> codeBasicSecDO2VOs(Collection<CodeBasicSec> codeBasicSecDOs, boolean hasFixedValue) throws VciBaseException {
|
List<CodeBasicSecVO> voList = new ArrayList<CodeBasicSecVO>();
|
if (!CollectionUtils.isEmpty(codeBasicSecDOs)) {
|
for (CodeBasicSec s : codeBasicSecDOs) {
|
CodeBasicSecVO vo = codeBasicSecDO2VO(s);
|
if (vo != null) {
|
voList.add(vo);
|
}
|
}
|
}
|
if(hasFixedValue && !CollectionUtils.isEmpty(voList)){
|
List<CodeBasicSecVO> fixedSecVOList = voList.stream().filter(s -> CodeSecTypeEnum.CODE_FIXED_SEC.getValue().equalsIgnoreCase(s.getSecType())).collect(Collectors.toList());
|
if(!CollectionUtils.isEmpty(fixedSecVOList)){
|
//查询固定码的码值
|
Map<String, List<CodeFixedValueVO>> secValueMap = fixedValueService.listCodeFixedValueBySecOids(fixedSecVOList.stream().map(CodeBasicSecVO::getOid).collect(Collectors.toList()));
|
voList.stream().forEach(vo->{
|
vo.setFixedValueVOList(secValueMap.getOrDefault(vo.getOid(),null));
|
});
|
}
|
}
|
return voList;
|
}
|
|
/**
|
* 批量数据对象转换为显示对象
|
*
|
* @param codeBasicSecDOs 数据对象列表
|
* @return 显示对象
|
* @throws VciBaseException 参数为空或者不存在的时候会抛出异常
|
*/
|
@Override
|
public List<CodeBasicSecVO> codeBasicSecDO2VOs(Collection<CodeBasicSec> codeBasicSecDOs) throws VciBaseException {
|
List<CodeBasicSecVO> voList = new ArrayList<CodeBasicSecVO>();
|
if (!CollectionUtils.isEmpty(codeBasicSecDOs)) {
|
for (CodeBasicSec s : codeBasicSecDOs) {
|
CodeBasicSecVO vo = codeBasicSecDO2VO(s);
|
if (vo != null) {
|
voList.add(vo);
|
}
|
}
|
}
|
return voList;
|
}
|
|
/**
|
* 数据对象转换为显示对象
|
*
|
* @param codeBasicSecDO 数据对象
|
* @return 显示对象
|
* @throws VciBaseException 拷贝属性出错的时候会抛出异常
|
*/
|
@Override
|
public CodeBasicSecVO codeBasicSecDO2VO(CodeBasicSec codeBasicSecDO) throws VciBaseException {
|
CodeBasicSecVO codeBasicSecVO = new CodeBasicSecVO();
|
if (codeBasicSecDO != null) {
|
BeanUtilForVCI.copyPropertiesIgnoreCase(codeBasicSecDO, codeBasicSecVO);
|
if(StringUtils.isNotBlank(codeBasicSecDO.getSecType())){
|
codeBasicSecVO.setSecTypeText(EnumCache.getValue(EnumEnum.CODE_SEC_TYPE,codeBasicSecDO.getSecType()));
|
}
|
if(StringUtils.isNotBlank(codeBasicSecDO.getCodeLevelType())){
|
codeBasicSecVO.setCodeLevelTypeText(EnumCache.getValue(EnumEnum.CODE_LEVEL_TYPE,codeBasicSecDO.getCodeLevelType()));
|
}
|
if(StringUtils.isNotBlank(codeBasicSecDO.getCodeSecLengthType())){
|
codeBasicSecVO.setCodeSecLengthTypeText(EnumCache.getValue(EnumEnum.CODE_SEC_LENGTH,codeBasicSecDO.getCodeSecLengthType()));
|
}
|
if(StringUtils.isNotBlank(codeBasicSecDO.getValueCutType())){
|
codeBasicSecVO.setValueCutTypeText(EnumCache.getValue(EnumEnum.CODE_CUT_TYPE,codeBasicSecDO.getValueCutType()));
|
}
|
if(StringUtils.isNotBlank(codeBasicSecDO.getCodeGetValueType())){
|
codeBasicSecVO.setCodeGetValueTypeText(EnumCache.getValue(EnumEnum.CODE_GET_VALUE_TYPE,codeBasicSecDO.getCodeGetValueType()));
|
}
|
// 如果是分类码段需要查询所属分类的中文名称
|
if(codeBasicSecDO.getSecType().equals("codeclassifysec") && Func.isNotEmpty(codeBasicSecDO.getParentClassifySecOid())){
|
CodeBasicSec codeBasicSec = codeBasicSecMapper.selectOne(Wrappers.<CodeBasicSec>query().lambda()
|
.eq(CodeBasicSec::getOid, codeBasicSecDO.getParentClassifySecOid())
|
.eq(CodeBasicSec::getSecType, codeBasicSecDO.getSecType()));
|
if(Func.isNotEmpty(codeBasicSec)){
|
codeBasicSecVO.setParentClassifySecOid(codeBasicSec.getOid());
|
codeBasicSecVO.setParentClassifySecText(codeBasicSec.getName());
|
}
|
}
|
//如果有lcstatus的类的话
|
if (true) {
|
//vo.setLcStatusText({lcStatusFullClassName}.getTextByValue(vo.getLcStatus()));
|
}
|
}
|
return codeBasicSecVO;
|
}
|
|
/**
|
* 根据编码规则主键获取编码下的流水依赖码段
|
*
|
* @param oid 编码规则主键
|
* @return
|
* @throws VciBaseException
|
*/
|
@Override
|
public CodeRuleVO getSerialNumberDepend(String oid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(oid,"编码规则主键");
|
CodeRuleVO codeRuleVO = codeRuleService.getObjectByOid(oid);
|
if (codeRuleVO != null) {
|
//如果有lcstatus的类的话
|
codeRuleVO.setLcStatusText(CodeRuleLC.getTextByValue(codeRuleVO.getLcStatus()));
|
|
LambdaQueryWrapper<CodeBasicSec> wrapper = Wrappers.<CodeBasicSec>query().lambda()
|
.eq(CodeBasicSec::getPkCodeRule, codeRuleVO.getOid())
|
.eq(CodeBasicSec::getSecType,CodeSecTypeEnum.CODE_SERIAL_SEC.getValue());
|
CodeBasicSec codeBasicSec = this.getOne(wrapper);
|
if(codeBasicSec != null && VciBaseUtil.isNotNull(codeBasicSec.getOid())){
|
wrapper = Wrappers.<CodeBasicSec>query().lambda()
|
.eq(CodeBasicSec::getPkCodeRule,codeRuleVO.getOid())
|
.eq(CodeBasicSec::getSerialDependFlag,"true")
|
.orderByAsc(CodeBasicSec::getOrderNum);
|
//.orderByAsc(CodeBasicSec::getSerialDependOrder);
|
List<CodeBasicSec> codeBasicSecList = this.list(wrapper);
|
if(!CollectionUtils.isEmpty(codeBasicSecList)){
|
List<CodeBasicSecVO> codeBasicSecVOS = codeBasicSecDO2VOs(codeBasicSecList);
|
//查询固定码的码值
|
Map<String, List<CodeFixedValueVO>> secValueMap = fixedValueService.listCodeFixedValueBySecOids(codeBasicSecList.stream().map(CodeBasicSec::getOid).collect(Collectors.toList()));
|
codeBasicSecVOS.stream().forEach(vo->{
|
vo.setFixedValueVOList(secValueMap.getOrDefault(vo.getOid(),null));
|
});
|
codeRuleVO.setSecVOList(codeBasicSecVOS);
|
}
|
}else{
|
throw new VciBaseException(codeRuleVO.getName()+"编码规则下无流水码段，无法设置最大流水号！");
|
}
|
}
|
return codeRuleVO;
|
}
|
|
/**
|
* 设置最大流水号
|
*
|
* @param codeOrderDTO 编码申请传输对象
|
* @return
|
* @throws VciBaseException
|
*/
|
@Override
|
public String setMaxSerialNumberForCodeRule(CodeOrderDTO codeOrderDTO) throws VciBaseException {
|
VciBaseUtil.alertNotNull(codeOrderDTO.getCodeRuleOid(),"编码规则主键",codeOrderDTO.getMaxSecNum(),"最大流水号");
|
List<CodeOrderSecDTO> codeOrderSecDTOList = codeOrderDTO.getSecDTOList();
|
if(CollectionUtils.isEmpty(codeOrderSecDTOList)){
|
throw new VciBaseException("最大流水号的流水依赖不能为空！");
|
}
|
|
String codeRuleOid = codeOrderDTO.getCodeRuleOid();
|
int maxSecNum = codeOrderDTO.getMaxSecNum();
|
|
Map<String/**码段主键*/,CodeOrderSecDTO/**码段相关信息*/> codeOrderSecDTOMap = codeOrderSecDTOList.stream().collect(Collectors.toMap(s -> s.getSecOid(), t -> t));
|
List<String> codeBasicSecOidList = codeOrderSecDTOList.stream().map(s->s.getSecOid()).collect(Collectors.toList());//流水依赖码段的主键集合
|
|
//获取流水依赖码段
|
LambdaQueryWrapper<CodeBasicSec> wrapper = Wrappers.<CodeBasicSec>query().lambda()
|
.eq(CodeBasicSec::getPkCodeRule,codeRuleOid)
|
.in(CodeBasicSec::getOid,codeBasicSecOidList)
|
.eq(CodeBasicSec::getSerialDependFlag,"true")
|
//TODO: SerialDependOrder本来是用来流水排序的，但是现在的逻辑是按照orderuNum排序的
|
.orderByAsc(CodeBasicSec::getOrderNum); //.orderByAsc(CodeBasicSec::getSerialDependOrder);
|
List<CodeBasicSec> codeBasicSecList = this.list(wrapper);
|
|
//按流水依赖顺序，处理流水依赖码段的值
|
List<String> serialDependValueList = new ArrayList<>();
|
codeBasicSecList.stream().forEach(s->{
|
CodeOrderSecDTO codeOrderSecDTO = codeOrderSecDTOMap.get(s.getOid());
|
String serialDependValue = codeOrderSecDTO.getSecValue();
|
if(s.getSecType().equals(CodeSecTypeEnum.CODE_DATE_SEC.getValue())){
|
try {
|
Date date = VciDateUtil.str2Date(codeOrderSecDTO.getSecValue(),s.getCodeDateFormatStr());
|
serialDependValue = VciDateUtil.date2Str(date,s.getCodeDateFormatStr());
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
}
|
}
|
serialDependValueList.add(serialDependValue);
|
});
|
|
//获取流水码段
|
wrapper = Wrappers.<CodeBasicSec>query().lambda()
|
.eq(CodeBasicSec::getPkCodeRule,codeRuleOid)
|
.eq(CodeBasicSec::getSecType,CodeSecTypeEnum.CODE_SERIAL_SEC.getValue())
|
.orderByAsc(CodeBasicSec::getSerialDependOrder);
|
CodeBasicSec codeBasicSec = this.getOne(wrapper);
|
|
//根据编码规则和流水依赖，获取最大流水号
|
String serialUnitString = serialDependValueList.size() == 0 ? EMPTY_SERIAL_UNIT : serialDependValueList.stream().collect(Collectors.joining(SERIAL_UNIT_SPACE));
|
LambdaQueryWrapper<CodeSerialValue> codeSerialWrapper = new LambdaQueryWrapper<>();
|
codeSerialWrapper.eq(CodeSerialValue::getCodeRuleOid, codeRuleOid);
|
codeSerialWrapper.eq(CodeSerialValue::getSerialUnit, serialUnitString);
|
codeSerialWrapper.eq(CodeSerialValue::getCodeSecOid,codeBasicSec.getOid());
|
codeSerialWrapper.orderByDesc(CodeSerialValue::getCreateTime);
|
List<CodeSerialValue> codeSerialValueList = serialValueMapper.selectList(codeSerialWrapper);
|
|
//如果最大流水号不为空，说明已有最好流水号，更新最大流水号
|
if(!CollectionUtils.isEmpty(codeSerialValueList)){
|
CodeSerialValue codeSerialValue = codeSerialValueList.get(0);
|
int maxSerial = Double.valueOf(codeSerialValue.getMaxSerial()).intValue();
|
//已有的最大流水号，小于设置的最大流水号，更新最大流水号
|
if(maxSerial < maxSecNum){
|
codeSerialValue.setMaxSerial(String.valueOf(maxSecNum));
|
serialValueMapper.updateById(codeSerialValue);
|
}else{
|
maxSecNum = maxSerial;
|
}
|
}else{
|
//如果最大流水号不为空，说明无最好流水号，新增最大流水号
|
CodeSerialValue codeSerialValue = new CodeSerialValue();
|
DefaultAttrAssimtUtil.addDefaultAttrAssimt(codeSerialValue, MdmBtmTypeConstant.CODE_SERIAL_VALUE);
|
codeSerialValue.setCodeRuleOid(codeRuleOid);
|
codeSerialValue.setSerialUnit(serialUnitString);
|
codeSerialValue.setCodeSecOid(codeBasicSec.getOid());
|
codeSerialValue.setMaxSerial(String.valueOf(maxSecNum));
|
serialValueMapper.insert(codeSerialValue);
|
}
|
return String.valueOf(maxSecNum);
|
}
|
|
/***
|
* 根据流水依赖获取最大流水号
|
* @param codeOrderDTO 编码申请传输对象
|
* @return
|
*/
|
@Override
|
public Double getMaxSerialNumberForCodeRule(CodeOrderDTO codeOrderDTO) {
|
Double maxSerialNumber=0.0;
|
VciBaseUtil.alertNotNull(codeOrderDTO.getCodeRuleOid(),"编码规则主键");
|
List<CodeOrderSecDTO> codeOrderSecDTOList=codeOrderDTO.getSecDTOList();
|
if(CollectionUtils.isEmpty(codeOrderSecDTOList)){
|
throw new VciBaseException("最大流水号的流水依赖不能为空！");
|
}
|
String codeRuleOid = codeOrderDTO.getCodeRuleOid();
|
Map<String/**码段主键*/,CodeOrderSecDTO/**码段相关信息*/> codeOrderSecDTOMap = codeOrderSecDTOList.stream().collect(Collectors.toMap(s -> s.getSecOid(), t -> t));
|
List<String> codeBasicSecOidList = codeOrderSecDTOList.stream().map(s->s.getSecOid()).collect(Collectors.toList());//流水依赖码段的主键集合
|
//获取流水依赖码段
|
LambdaQueryWrapper<CodeBasicSec> wrapper = Wrappers.<CodeBasicSec>query().lambda()
|
.eq(CodeBasicSec::getPkCodeRule,codeRuleOid)
|
.in(CodeBasicSec::getOid,codeBasicSecOidList)
|
.eq(CodeBasicSec::getSerialDependFlag,"true")
|
.orderByAsc(CodeBasicSec::getOrderNum); //.orderByAsc(CodeBasicSec::getSerialDependOrder);
|
|
List<CodeBasicSec> codeBasicSecList = this.list(wrapper);
|
//按流水依赖顺序，处理流水依赖码段的值
|
List<String> serialDependValueList = new ArrayList<>();
|
codeBasicSecList.stream().forEach(s->{
|
CodeOrderSecDTO codeOrderSecDTO = codeOrderSecDTOMap.get(s.getOid());
|
String serialDependValue = codeOrderSecDTO.getSecValue();
|
if(s.getSecType().equals(CodeSecTypeEnum.CODE_DATE_SEC.getValue())){
|
try {
|
Date date = VciDateUtil.str2Date(codeOrderSecDTO.getSecValue(),s.getCodeDateFormatStr());
|
serialDependValue = VciDateUtil.date2Str(date,s.getCodeDateFormatStr());
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
}
|
}
|
serialDependValueList.add(serialDependValue);
|
});
|
|
//获取流水码段
|
wrapper = Wrappers.<CodeBasicSec>query().lambda()
|
.eq(CodeBasicSec::getPkCodeRule,codeRuleOid)
|
.eq(CodeBasicSec::getSecType,CodeSecTypeEnum.CODE_SERIAL_SEC.getValue())
|
.orderByAsc(CodeBasicSec::getSerialDependOrder);
|
CodeBasicSec codeBasicSec = this.getOne(wrapper);
|
//根据编码规则和流水依赖，获取最大流水号
|
String serialUnitString = serialDependValueList.size() == 0 ? EMPTY_SERIAL_UNIT : serialDependValueList.stream().collect(Collectors.joining(SERIAL_UNIT_SPACE));
|
LambdaQueryWrapper<CodeSerialValue> codeSerialWrapper = new LambdaQueryWrapper<>();
|
codeSerialWrapper.eq(CodeSerialValue::getCodeRuleOid, codeRuleOid);
|
codeSerialWrapper.eq(CodeSerialValue::getSerialUnit, serialUnitString);
|
codeSerialWrapper.eq(CodeSerialValue::getCodeSecOid,codeBasicSec.getOid());
|
codeSerialWrapper.orderByDesc(CodeSerialValue::getCreateTime);
|
List<CodeSerialValue> codeSerialValueList = serialValueMapper.selectList(codeSerialWrapper);
|
if(!CollectionUtils.isEmpty(codeSerialValueList)){
|
maxSerialNumber=StringUtils.isBlank(codeSerialValueList.get(0).getMaxSerial())?0:Double.parseDouble(codeSerialValueList.get(0).getMaxSerial());
|
}
|
return maxSerialNumber;
|
}
|
}
|
