package com.qianwen.core.coderule.builder;
|
|
import cn.hutool.core.convert.Convert;
|
import java.math.BigDecimal;
|
import java.text.ParseException;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.commons.lang3.time.DateUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import com.qianwen.core.coderule.constant.CodeRuleConstant;
|
import com.qianwen.core.coderule.constant.enums.ElementTypeEnum;
|
import com.qianwen.core.coderule.constant.enums.SourcePropertyEnum;
|
import com.qianwen.core.coderule.dto.DropDownDTO;
|
import com.qianwen.core.coderule.dto.RefObjectTypeInfoDTO;
|
import com.qianwen.core.coderule.handler.DictHandler;
|
import com.qianwen.core.coderule.handler.MasterlinkCodeRuleModelHandler;
|
import com.qianwen.core.coderule.handler.MasterlinkDictHandler;
|
import com.qianwen.core.coderule.handler.MasterlinkMetaObjectTypeFieldEnumHandler;
|
import com.qianwen.core.coderule.handler.MasterlinkObjectTypeHandler;
|
import com.qianwen.core.coderule.handler.ObjectTypeHandler;
|
import com.qianwen.core.coderule.model.CodeRuleContext;
|
import com.qianwen.core.coderule.model.CodeRuleEntryModel;
|
import com.qianwen.core.coderule.model.CodeRuleModel;
|
import com.qianwen.core.coderule.util.CodeRuleHelper;
|
import com.qianwen.core.sequence.builder.SequenceBuilderFactory;
|
import com.qianwen.core.sequence.sequence.Sequence;
|
import com.qianwen.core.tool.utils.ConvertUtil;
|
import com.qianwen.core.tool.utils.DateUtil;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.core.tool.utils.StringUtil;
|
import org.springframework.jdbc.core.JdbcTemplate;
|
|
|
public class DefaultConcreateContextBuilder implements CodeRuleContextBuilder {
|
private static final Logger log = LoggerFactory.getLogger(DefaultConcreateContextBuilder.class);
|
private static String[] parsePatterns = {"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm"};
|
private JdbcTemplate jdbcTemplate;
|
private CodeRuleContext context = new CodeRuleContext();
|
|
public DefaultConcreateContextBuilder(JdbcTemplate jdbcTemplate) {
|
this.jdbcTemplate = jdbcTemplate;
|
}
|
|
@Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
|
public CodeRuleContextBuilder codeRuleModel(Long codeRuleId) {
|
MasterlinkCodeRuleModelHandler codeRuleModelHandler = new MasterlinkCodeRuleModelHandler(this.jdbcTemplate);
|
this.context.setCodeRuleModel(codeRuleModelHandler.getCodeRuleById(codeRuleId));
|
return this;
|
}
|
|
@Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
|
public CodeRuleContextBuilder objectData(Object object) {
|
this.context.setObjectData(CodeRuleHelper.getDeclaredFieldsInfoByAnnotation(object));
|
return this;
|
}
|
|
@Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
|
public CodeRuleContextBuilder constant() {
|
List<CodeRuleEntryModel> constants = execute(ElementTypeEnum.CONSTANT.getType());
|
if (Func.isNotEmpty(constants)) {
|
Map<Integer, String> map = new HashMap<>();
|
for (CodeRuleEntryModel constant : constants) {
|
map.put(constant.getSeq(), handleValueByOtherSetting(constant, constant.getElementValue()));
|
}
|
this.context.getEntryData().putAll(map);
|
}
|
return this;
|
}
|
|
@Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
|
public CodeRuleContextBuilder date() {
|
List<CodeRuleEntryModel> dates = execute(ElementTypeEnum.DATE.getType());
|
if (Func.isNotEmpty(dates)) {
|
Map<Integer, String> map = new HashMap<>();
|
for (CodeRuleEntryModel date : dates) {
|
String format = Func.isNotEmpty(date.getFormat()) ? date.getFormat() : "yyyyMMdd";
|
Object value = this.context.getObjectData().get(date.getElementSource());
|
String result = "";
|
if (value == null) {
|
value = Long.valueOf(new Date().getTime());
|
}
|
if (Func.isNotEmpty(value)) {
|
if (value instanceof Long) {
|
result = DateUtil.format((Date) ConvertUtil.convert(value, Date.class), format);
|
} else {
|
try {
|
result = DateUtil.format(DateUtils.parseDate(value.toString(), parsePatterns), format);
|
} catch (ParseException e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
map.put(date.getSeq(), handleValueByOtherSetting(date, result));
|
}
|
this.context.getEntryData().putAll(map);
|
}
|
return this;
|
}
|
|
@Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
|
public CodeRuleContextBuilder number() {
|
List<CodeRuleEntryModel> numbers = execute(ElementTypeEnum.NUMBER.getType());
|
if (Func.isNotEmpty(numbers)) {
|
Map<Integer, String> map = new HashMap<>();
|
for (CodeRuleEntryModel number : numbers) {
|
Object value = this.context.getObjectData().get(number.getElementSource());
|
String result = "";
|
if (Func.isNotEmpty(value)) {
|
result = CodeRuleHelper.getRealData((BigDecimal) ConvertUtil.convert(value, BigDecimal.class));
|
}
|
map.put(number.getSeq(), handleValueByOtherSetting(number, result));
|
}
|
this.context.getEntryData().putAll(map);
|
}
|
return this;
|
}
|
|
@Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
|
public CodeRuleContextBuilder dropdown(String objectId) {
|
List<CodeRuleEntryModel> dropdowns = execute(ElementTypeEnum.DROPDOWN.getType());
|
if (Func.isNotEmpty(dropdowns)) {
|
Map<Integer, String> map = new HashMap<>();
|
for (CodeRuleEntryModel dropdown : dropdowns) {
|
Object value = this.context.getObjectData().get(dropdown.getElementSource());
|
String result = value.toString();
|
if (Func.isNotEmpty(value)) {
|
Boolean isCode = true;
|
if (Func.isNotEmpty(dropdown.getSourceProperty())) {
|
isCode = Boolean.valueOf(dropdown.getSourceProperty().equals(SourcePropertyEnum.CODE.getType()));
|
}
|
if (!isCode.booleanValue()) {
|
DictHandler dictHandler = new MasterlinkDictHandler(this.jdbcTemplate);
|
MasterlinkMetaObjectTypeFieldEnumHandler metaObjectTypeFieldEnumHandler = new MasterlinkMetaObjectTypeFieldEnumHandler(this.jdbcTemplate);
|
String dictCodeForField = metaObjectTypeFieldEnumHandler.getDictCodeForField(objectId, dropdown.getElementSource());
|
if (Func.isNotEmpty(dictCodeForField)) {
|
DropDownDTO dropDownDTO = dictHandler.getDictInfo(dictCodeForField, value.toString());
|
if (Func.isNotEmpty(dropDownDTO)) {
|
result = dropDownDTO.getDictValue();
|
}
|
}
|
}
|
}
|
map.put(dropdown.getSeq(), handleValueByOtherSetting(dropdown, result));
|
}
|
this.context.getEntryData().putAll(map);
|
}
|
return this;
|
}
|
|
@Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
|
public CodeRuleContextBuilder baseData(String objectId) {
|
List<CodeRuleEntryModel> baseDatas = execute(ElementTypeEnum.BASE_DATA.getType());
|
if (Func.isNotEmpty(baseDatas)) {
|
ObjectTypeHandler objectTypeHandler = new MasterlinkObjectTypeHandler(this.jdbcTemplate);
|
Map<Integer, String> map = new HashMap<>();
|
for (CodeRuleEntryModel baseData : baseDatas) {
|
Object value = this.context.getObjectData().get(baseData.getElementSource());
|
String result = "";
|
if (Func.isNotEmpty(value)) {
|
RefObjectTypeInfoDTO refObjectTypeInfo = objectTypeHandler.getRefObjectTypeInfo(objectId, baseData.getElementSource(), value.toString());
|
Boolean isCode = Boolean.valueOf(baseData.getSourceProperty().equals(SourcePropertyEnum.CODE.getType()));
|
if (Func.isNotEmpty(refObjectTypeInfo)) {
|
result = isCode.booleanValue() ? refObjectTypeInfo.getCode() : refObjectTypeInfo.getName();
|
}
|
}
|
map.put(baseData.getSeq(), handleValueByOtherSetting(baseData, result));
|
}
|
this.context.getEntryData().putAll(map);
|
}
|
return this;
|
}
|
|
@Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
|
public CodeRuleContextBuilder baseDataProperty() {
|
List<CodeRuleEntryModel> baseDataProperties = execute(ElementTypeEnum.BASE_DATA_PROPERTY.getType());
|
if (Func.isNotEmpty(baseDataProperties)) {
|
Map<Integer, String> map = new HashMap<>();
|
for (CodeRuleEntryModel baseDataProperty : baseDataProperties) {
|
Object value = this.context.getObjectData().getOrDefault(baseDataProperty.getElementSource(), "");
|
map.put(baseDataProperty.getSeq(), handleValueByOtherSetting(baseDataProperty, checkCops(value.toString(), baseDataProperty.getFormat())));
|
}
|
this.context.getEntryData().putAll(map);
|
}
|
return this;
|
}
|
|
@Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
|
public CodeRuleContextBuilder sequence(String objectId) {
|
List<CodeRuleEntryModel> sequences = execute(ElementTypeEnum.SEQUENCE.getType());
|
if (Func.isEmpty(sequences)) {
|
return this;
|
}
|
CodeRuleEntryModel sequenceEntry = sequences.iterator().next();
|
String bizName = objectId.concat(getCodeDependOn());
|
Integer start = sequenceEntry.getSeed();
|
Integer step = sequenceEntry.getIncrementStep();
|
if (Func.isNotEmpty(start)) {
|
start = Integer.valueOf(start.intValue() - 1);
|
}
|
Sequence sequence = SequenceBuilderFactory.getSeqBuilder(bizName, step, start);
|
Map<Integer, String> map = new HashMap<>();
|
map.put(sequenceEntry.getSeq(), handleValueByOtherSetting(sequenceEntry, Convert.toStr(Long.valueOf(sequence.nextValue()))));
|
this.context.getEntryData().putAll(map);
|
return this;
|
}
|
|
@Override // com.qianwen.core.coderule.builder.CodeRuleContextBuilder
|
public CodeRuleContext createCodeRuleContext() {
|
return this.context;
|
}
|
|
private List<CodeRuleEntryModel> execute(Integer elementType) {
|
List<CodeRuleEntryModel> result = null;
|
CodeRuleModel codeRuleModel = this.context.getCodeRuleModel();
|
if (Func.isNotEmpty(codeRuleModel) && Func.isNotEmpty(codeRuleModel.getCodeRuleEntryModelList())) {
|
result = (List) codeRuleModel.getCodeRuleEntryModelList().stream().filter(x -> {
|
return x.getElementType().equals(elementType);
|
}).collect(Collectors.toList());
|
}
|
return result;
|
}
|
|
private String getCodeDependOn() {
|
StringBuilder codeDependOn = new StringBuilder();
|
CodeRuleModel codeRuleModel = this.context.getCodeRuleModel();
|
codeDependOn.append(codeRuleModel.getId());
|
if (Func.isNotEmpty(codeRuleModel) && Func.isNotEmpty(codeRuleModel.getCodeRuleEntryModelList())) {
|
List<CodeRuleEntryModel> collect = (List) codeRuleModel.getCodeRuleEntryModelList().stream().filter(x -> {
|
return x.getCodeOnlyBy().equals(true);
|
}).filter(x2 -> {
|
return !x2.getElementType().equals(ElementTypeEnum.SEQUENCE.getType());
|
}).sorted(Comparator.comparing((v0) -> {
|
return v0.getSeq();
|
})).collect(Collectors.toList());
|
if (Func.isNotEmpty(collect)) {
|
for (CodeRuleEntryModel codeRuleEntryModel : collect) {
|
String s = this.context.getEntryData().get(codeRuleEntryModel.getSeq());
|
if (Func.isNotEmpty(s)) {
|
codeDependOn.append(s);
|
}
|
}
|
}
|
}
|
return codeDependOn.toString();
|
}
|
|
private String handleValueByOtherSetting(CodeRuleEntryModel codeRuleEntryModel, String value) {
|
String result = value;
|
if (Func.isEmpty(value)) {
|
String reChar = codeRuleEntryModel.getReChar();
|
if (Func.isNotEmpty(reChar)) {
|
result = reChar;
|
}
|
}
|
Integer length = codeRuleEntryModel.getLength();
|
if (!length.equals(0)) {
|
if (result.length() >= length.intValue()) {
|
result = codeRuleEntryModel.getCutStyle().booleanValue() ? StringUtil.sub(result, 0, length.intValue()) : result.substring(result.length() - length.intValue());
|
} else {
|
result = codeRuleEntryModel.getAddStyle().booleanValue() ? StringUtils.rightPad(result, length.intValue(), codeRuleEntryModel.getAddChar()) : StringUtils.leftPad(result, length.intValue(), codeRuleEntryModel.getAddChar());
|
}
|
}
|
if (Func.isNotEmpty(codeRuleEntryModel.getSeparatorChar())) {
|
result = result + codeRuleEntryModel.getSeparatorChar();
|
}
|
return result;
|
}
|
|
private String checkCops(String value, String format) {
|
if (Func.isNotEmpty(format)) {
|
if (format.equals(CodeRuleConstant.CAPS_TYPE_CODE_U)) {
|
value = value.toUpperCase();
|
} else {
|
value = value.toLowerCase();
|
}
|
}
|
return value;
|
}
|
}
|
