package jnpf.elnService.impl;
|
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import jnpf.elnEntity.runtime.ElnRecordEntity;
|
import jnpf.elnEntity.runtime.ElnRecordFieldValueEntity;
|
import jnpf.elnEntity.runtime.ElnRecordRevisionEntity;
|
import jnpf.elnEntity.runtime.ElnRecordRepeatRowEntity;
|
import jnpf.elnEntity.runtime.ElnRecordRepeatValueEntity;
|
import jnpf.elnEntity.field.ElnFieldVersionEntity;
|
import jnpf.elnEntity.template.ElnTemplateBindingEntity;
|
import jnpf.elnEntity.template.ElnTemplateVos;
|
import jnpf.elnMapper.ElnRecordFieldValueMapper;
|
import jnpf.elnMapper.ElnRecordMapper;
|
import jnpf.elnMapper.ElnRecordRevisionMapper;
|
import jnpf.elnMapper.ElnRecordRepeatRowMapper;
|
import jnpf.elnMapper.ElnRecordRepeatValueMapper;
|
import jnpf.elnMapper.ElnFieldVersionMapper;
|
import jnpf.elnMapper.ElnTemplateBindingMapper;
|
import jnpf.elnService.ElnRecordFillDataService;
|
import jnpf.elnService.ElnRecordFillTicketService;
|
import jnpf.elnService.field.ElnTestResultFields;
|
import jnpf.elnService.template.ElnTemplateCheckboxGroupService;
|
import jnpf.elnService.template.ElnTemplateRepeatGroupService;
|
import jnpf.elnService.template.ElnTemplateStepService;
|
import jnpf.database.util.TenantDataSourceUtil;
|
import jnpf.exception.DataException;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.StringUtils;
|
|
import java.math.BigDecimal;
|
import java.text.SimpleDateFormat;
|
import java.util.Date;
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
@Service
|
public class ElnRecordFillDataServiceImpl implements ElnRecordFillDataService {
|
|
private final ElnRecordMapper recordMapper;
|
private final ElnRecordRevisionMapper revisionMapper;
|
private final ElnRecordFieldValueMapper valueMapper;
|
private final ElnFieldVersionMapper fieldVersionMapper;
|
private final ElnTemplateBindingMapper bindingMapper;
|
private final ElnRecordRepeatRowMapper repeatRowMapper;
|
private final ElnRecordRepeatValueMapper repeatValueMapper;
|
private final ElnTemplateRepeatGroupService repeatGroupService;
|
private final ElnTemplateStepService stepService;
|
private final ElnTemplateCheckboxGroupService checkboxGroupService;
|
|
@Autowired
|
public ElnRecordFillDataServiceImpl(ElnRecordMapper recordMapper,
|
ElnRecordRevisionMapper revisionMapper,
|
ElnRecordFieldValueMapper valueMapper,
|
ElnFieldVersionMapper fieldVersionMapper,
|
ElnTemplateBindingMapper bindingMapper,
|
ElnRecordRepeatRowMapper repeatRowMapper,
|
ElnRecordRepeatValueMapper repeatValueMapper,
|
ElnTemplateRepeatGroupService repeatGroupService,
|
ElnTemplateCheckboxGroupService checkboxGroupService,
|
ElnTemplateStepService stepService) {
|
this(recordMapper, revisionMapper, valueMapper, fieldVersionMapper, bindingMapper,
|
repeatRowMapper, repeatValueMapper, repeatGroupService, checkboxGroupService,
|
stepService,
|
new TenantRoute() {
|
@Override public void switchTo(String tenantId) { TenantDataSourceUtil.switchTenant(tenantId); }
|
@Override public void clear() { TenantDataSourceUtil.clearLocalTenantInfo(); }
|
});
|
}
|
|
ElnRecordFillDataServiceImpl(ElnRecordMapper recordMapper,
|
ElnRecordRevisionMapper revisionMapper,
|
ElnRecordFieldValueMapper valueMapper,
|
ElnFieldVersionMapper fieldVersionMapper,
|
TenantRoute tenantRoute) {
|
this(recordMapper, revisionMapper, valueMapper, fieldVersionMapper, null,
|
null, null, null, null, null, tenantRoute);
|
}
|
|
ElnRecordFillDataServiceImpl(ElnRecordMapper recordMapper,
|
ElnRecordRevisionMapper revisionMapper,
|
ElnRecordFieldValueMapper valueMapper,
|
ElnFieldVersionMapper fieldVersionMapper,
|
ElnRecordRepeatRowMapper repeatRowMapper,
|
ElnRecordRepeatValueMapper repeatValueMapper,
|
TenantRoute tenantRoute) {
|
this(recordMapper, revisionMapper, valueMapper, fieldVersionMapper, null,
|
repeatRowMapper, repeatValueMapper, null, null, null, tenantRoute);
|
}
|
|
ElnRecordFillDataServiceImpl(ElnRecordMapper recordMapper,
|
ElnRecordRevisionMapper revisionMapper,
|
ElnRecordFieldValueMapper valueMapper,
|
ElnFieldVersionMapper fieldVersionMapper,
|
ElnRecordRepeatRowMapper repeatRowMapper,
|
ElnRecordRepeatValueMapper repeatValueMapper,
|
ElnTemplateRepeatGroupService repeatGroupService,
|
TenantRoute tenantRoute) {
|
this(recordMapper, revisionMapper, valueMapper, fieldVersionMapper, null,
|
repeatRowMapper, repeatValueMapper, repeatGroupService, null, null, tenantRoute);
|
}
|
|
ElnRecordFillDataServiceImpl(ElnRecordMapper recordMapper,
|
ElnRecordRevisionMapper revisionMapper,
|
ElnRecordFieldValueMapper valueMapper,
|
ElnFieldVersionMapper fieldVersionMapper,
|
ElnRecordRepeatRowMapper repeatRowMapper,
|
ElnRecordRepeatValueMapper repeatValueMapper,
|
ElnTemplateRepeatGroupService repeatGroupService,
|
ElnTemplateStepService stepService,
|
TenantRoute tenantRoute) {
|
this(recordMapper, revisionMapper, valueMapper, fieldVersionMapper, null,
|
repeatRowMapper, repeatValueMapper, repeatGroupService, null,
|
stepService, tenantRoute);
|
}
|
|
ElnRecordFillDataServiceImpl(ElnRecordMapper recordMapper,
|
ElnRecordRevisionMapper revisionMapper,
|
ElnRecordFieldValueMapper valueMapper,
|
ElnFieldVersionMapper fieldVersionMapper,
|
ElnTemplateBindingMapper bindingMapper,
|
ElnRecordRepeatRowMapper repeatRowMapper,
|
ElnRecordRepeatValueMapper repeatValueMapper,
|
ElnTemplateRepeatGroupService repeatGroupService,
|
ElnTemplateStepService stepService,
|
TenantRoute tenantRoute) {
|
this(recordMapper, revisionMapper, valueMapper, fieldVersionMapper, bindingMapper,
|
repeatRowMapper, repeatValueMapper, repeatGroupService, null,
|
stepService, tenantRoute);
|
}
|
|
ElnRecordFillDataServiceImpl(ElnRecordMapper recordMapper,
|
ElnRecordRevisionMapper revisionMapper,
|
ElnRecordFieldValueMapper valueMapper,
|
ElnFieldVersionMapper fieldVersionMapper,
|
ElnTemplateBindingMapper bindingMapper,
|
ElnRecordRepeatRowMapper repeatRowMapper,
|
ElnRecordRepeatValueMapper repeatValueMapper,
|
ElnTemplateRepeatGroupService repeatGroupService,
|
ElnTemplateCheckboxGroupService checkboxGroupService,
|
ElnTemplateStepService stepService,
|
TenantRoute tenantRoute) {
|
this.recordMapper = recordMapper;
|
this.revisionMapper = revisionMapper;
|
this.valueMapper = valueMapper;
|
this.fieldVersionMapper = fieldVersionMapper;
|
this.bindingMapper = bindingMapper;
|
this.repeatRowMapper = repeatRowMapper;
|
this.repeatValueMapper = repeatValueMapper;
|
this.repeatGroupService = repeatGroupService;
|
this.stepService = stepService;
|
this.checkboxGroupService = checkboxGroupService;
|
this.tenantRoute = tenantRoute;
|
}
|
|
private final TenantRoute tenantRoute;
|
|
@Override
|
public Map<String, Object> fields(ElnRecordFillTicketService.FillTicketContext ticket) {
|
@SuppressWarnings("unchecked")
|
Map<String, Object> fields = (Map<String, Object>) data(ticket).get("fields");
|
return fields;
|
}
|
|
@Override
|
public Map<String, Object> data(ElnRecordFillTicketService.FillTicketContext ticket) {
|
if (!ElnRecordFillTicketService.BIZ_MODULE.equals(ticket.getBizModule())) {
|
Map<String, Object> empty = new LinkedHashMap<>();
|
empty.put("fields", new LinkedHashMap<>());
|
empty.put("repeatGroups", new ArrayList<>());
|
return empty;
|
}
|
return inTenant(ticket.getTenantId(), () -> dataInTenant(ticket));
|
}
|
|
private Map<String, Object> dataInTenant(ElnRecordFillTicketService.FillTicketContext ticket) {
|
ElnRecordEntity record = recordMapper.selectOne(Wrappers.<ElnRecordEntity>lambdaQuery()
|
.eq(ElnRecordEntity::getFTenantId, ticket.getTenantId())
|
.eq(ElnRecordEntity::getId, ticket.getBizDataId())
|
.and(query -> query.isNull(ElnRecordEntity::getFDeleteMark)
|
.or().eq(ElnRecordEntity::getFDeleteMark, 0)).last("limit 1"));
|
if (record == null || record.getDangqianXiudingId() == null) {
|
throw new DataException("电子记录不存在或当前修订无效");
|
}
|
ElnRecordRevisionEntity revision = revisionMapper.selectOne(
|
Wrappers.<ElnRecordRevisionEntity>lambdaQuery()
|
.eq(ElnRecordRevisionEntity::getFTenantId, ticket.getTenantId())
|
.eq(ElnRecordRevisionEntity::getId, record.getDangqianXiudingId())
|
.eq(ElnRecordRevisionEntity::getDianziJiluId, record.getId())
|
.eq(ElnRecordRevisionEntity::getJiluWendang, ticket.getFileId())
|
.and(query -> query.isNull(ElnRecordRevisionEntity::getFDeleteMark)
|
.or().eq(ElnRecordRevisionEntity::getFDeleteMark, 0)).last("limit 1"));
|
if (revision == null) {
|
throw new DataException("电子记录文档与当前修订不匹配");
|
}
|
Map<String, ElnTemplateBindingEntity> bindings = activeBindings(
|
ticket.getTenantId(), record.getMubanId());
|
Map<String, ElnTemplateVos.CheckboxGroup> checkboxGroups = checkboxGroupRules(
|
ticket.getTenantId(), record.getMubanId());
|
List<ElnRecordFieldValueEntity> values = valueMapper.selectList(
|
Wrappers.<ElnRecordFieldValueEntity>lambdaQuery()
|
.eq(ElnRecordFieldValueEntity::getFTenantId, ticket.getTenantId())
|
.eq(ElnRecordFieldValueEntity::getDianziJiluId, record.getId())
|
.eq(ElnRecordFieldValueEntity::getXiudingId, revision.getId())
|
.and(query -> query.isNull(ElnRecordFieldValueEntity::getFDeleteMark)
|
.or().eq(ElnRecordFieldValueEntity::getFDeleteMark, 0))
|
.orderByAsc(ElnRecordFieldValueEntity::getId));
|
Map<String, Object> fields = new LinkedHashMap<>();
|
for (ElnRecordFieldValueEntity value : values) {
|
if (value == null || value.getZiduanBianma() == null) {
|
continue;
|
}
|
Map<String, Object> field = new LinkedHashMap<>();
|
ElnFieldVersionEntity version = fixedVersion(
|
ticket.getTenantId(), value.getZiduanBanbenId());
|
String type = typeOf(version);
|
field.put("type", type);
|
field.put("value", displayValue(value, type, version.getShujuLeixing()));
|
field.put("required", Integer.valueOf(1).equals(version.getShifouBitian()));
|
appendValueSource(field, value.getZhiLaiyuan());
|
if ("LIMS_TASK".equals(value.getZhiLaiyuan()) && value.getYuanShuxingBanben() != null) {
|
field.put("readOnly", true);
|
if (value.getZhiWenben() == null && value.getZhiShuzhi() == null && value.getZhiRiqi() == null) {
|
field.put("value", null);
|
}
|
}
|
appendCheckboxGroup(field, bindings.get(value.getMubanBangdingId()),
|
"PRIMARY", type, checkboxGroups);
|
appendFormulaState(field, value.getJisuanZhuangtai(), value.getJisuanXiaoxi());
|
for (String tag : ElnTestResultFields.docxTags(value.getZiduanBianma())) {
|
fields.put(tag, field);
|
}
|
}
|
List<Map<String, Object>> repeatGroups = appendRepeatFields(
|
fields, bindings, checkboxGroups, ticket, record, revision);
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("fields", fields);
|
result.put("repeatGroups", repeatGroups);
|
if (stepService != null) {
|
result.put("stepStructure", stepService.fillStructure(
|
ticket.getTenantId(), record.getMubanId()));
|
}
|
return result;
|
}
|
|
private List<Map<String, Object>> appendRepeatFields(Map<String, Object> result,
|
Map<String, ElnTemplateBindingEntity> bindings,
|
Map<String, ElnTemplateVos.CheckboxGroup> checkboxGroups,
|
ElnRecordFillTicketService.FillTicketContext ticket,
|
ElnRecordEntity record, ElnRecordRevisionEntity revision) {
|
if (repeatRowMapper == null && repeatValueMapper == null) return new ArrayList<>();
|
if (repeatRowMapper == null || repeatValueMapper == null) {
|
throw new DataException("重复行读取服务配置不完整");
|
}
|
List<ElnRecordRepeatRowEntity> rows = repeatRowMapper.selectList(
|
Wrappers.<ElnRecordRepeatRowEntity>lambdaQuery()
|
.eq(ElnRecordRepeatRowEntity::getFTenantId, ticket.getTenantId())
|
.eq(ElnRecordRepeatRowEntity::getDianziJiluId, record.getId())
|
.eq(ElnRecordRepeatRowEntity::getXiudingId, revision.getId())
|
.in(ElnRecordRepeatRowEntity::getOperationStatus,
|
"PREPARED", "ACTIVE", "DELETE_PREPARED")
|
.and(q -> q.isNull(ElnRecordRepeatRowEntity::getFDeleteMark)
|
.or().eq(ElnRecordRepeatRowEntity::getFDeleteMark, 0)));
|
rows.sort(Comparator.comparing(ElnRecordRepeatRowEntity::getRepeatGroupCode)
|
.thenComparing(ElnRecordRepeatRowEntity::getRowOrder));
|
Map<String, ElnRecordRepeatRowEntity> rowsByIdentity = new LinkedHashMap<>();
|
for (ElnRecordRepeatRowEntity row : rows) {
|
if (row == null || !record.getMubanId().equals(row.getMubanId())
|
|| rowsByIdentity.put(repeatRowKey(
|
row.getRepeatGroupCode(), row.getRowId()), row) != null) {
|
throw new DataException("电子记录重复行身份无效");
|
}
|
}
|
List<ElnRecordRepeatValueEntity> values = repeatValueMapper.selectList(
|
Wrappers.<ElnRecordRepeatValueEntity>lambdaQuery()
|
.eq(ElnRecordRepeatValueEntity::getFTenantId, ticket.getTenantId())
|
.eq(ElnRecordRepeatValueEntity::getDianziJiluId, record.getId())
|
.eq(ElnRecordRepeatValueEntity::getXiudingId, revision.getId())
|
.and(q -> q.isNull(ElnRecordRepeatValueEntity::getFDeleteMark)
|
.or().eq(ElnRecordRepeatValueEntity::getFDeleteMark, 0)));
|
Map<String, List<ElnRecordRepeatValueEntity>> valuesByRow = new LinkedHashMap<>();
|
for (ElnRecordRepeatValueEntity value : values) {
|
String rowKey = repeatRowKey(value.getRepeatGroupCode(), value.getRepeatRowId());
|
ElnRecordRepeatRowEntity row = rowsByIdentity.get(rowKey);
|
if (row == null
|
|| !record.getMubanId().equals(value.getMubanId())) {
|
throw new DataException("电子记录重复字段值与运行时行不一致");
|
}
|
valuesByRow.computeIfAbsent(rowKey, ignored -> new ArrayList<>()).add(value);
|
}
|
for (ElnRecordRepeatRowEntity row : rows) {
|
String rowKey = repeatRowKey(row.getRepeatGroupCode(), row.getRowId());
|
List<ElnRecordRepeatValueEntity> rowValues = valuesByRow.getOrDefault(
|
rowKey, new ArrayList<>());
|
rowValues.sort(Comparator.comparing(ElnRecordRepeatValueEntity::getZiduanBianma));
|
for (ElnRecordRepeatValueEntity value : rowValues) {
|
ElnFieldVersionEntity version = fixedVersion(
|
ticket.getTenantId(), value.getZiduanBanbenId());
|
String type = typeOf(version);
|
Map<String, Object> field = new LinkedHashMap<>();
|
field.put("type", type);
|
field.put("value", displayValue(value.getZhiWenben(), value.getZhiShuzhi(),
|
value.getZhiRiqi(), type, version.getShujuLeixing()));
|
field.put("required", Integer.valueOf(1).equals(version.getShifouBitian()));
|
appendValueSource(field, value.getZhiLaiyuan());
|
appendCheckboxGroup(field, bindings.get(value.getMubanBangdingId()),
|
"REPEAT", type, checkboxGroups);
|
appendFormulaState(field, value.getJisuanZhuangtai(), value.getJisuanXiaoxi());
|
String tag = "eln.repeat." + row.getRepeatGroupCode() + "."
|
+ row.getRowId() + "." + value.getZiduanBianma();
|
if (result.put(tag, field) != null) {
|
throw new DataException("电子记录重复字段 Tag 冲突");
|
}
|
}
|
}
|
return repeatGroupMetadata(ticket, record, rows, bindings);
|
}
|
|
private List<Map<String, Object>> repeatGroupMetadata(
|
ElnRecordFillTicketService.FillTicketContext ticket,
|
ElnRecordEntity record, List<ElnRecordRepeatRowEntity> rows,
|
Map<String, ElnTemplateBindingEntity> bindings) {
|
Map<String, ElnTemplateVos.RepeatGroup> configured = new LinkedHashMap<>();
|
if (repeatGroupService != null) {
|
for (ElnTemplateVos.RepeatGroup group : repeatGroupService.list(
|
ticket.getTenantId(), record.getMubanId())) {
|
if (group == null || !StringUtils.hasText(group.getGroupCode())
|
|| configured.put(group.getGroupCode(), group) != null) {
|
throw new DataException("电子记录重复组配置无效");
|
}
|
}
|
}
|
for (ElnRecordRepeatRowEntity row : rows) {
|
if (!configured.containsKey(row.getRepeatGroupCode())) {
|
if (repeatGroupService != null) {
|
throw new DataException("电子记录重复行缺少模板组配置");
|
}
|
ElnTemplateVos.RepeatGroup derived = new ElnTemplateVos.RepeatGroup();
|
derived.setGroupCode(row.getRepeatGroupCode());
|
configured.put(row.getRepeatGroupCode(), derived);
|
}
|
}
|
List<Map<String, Object>> result = new ArrayList<>();
|
for (ElnTemplateVos.RepeatGroup group : configured.values()) {
|
List<Map<String, Object>> rowMetadata = new ArrayList<>();
|
for (ElnRecordRepeatRowEntity row : rows) {
|
if (!group.getGroupCode().equals(row.getRepeatGroupCode())) continue;
|
Map<String, Object> item = new LinkedHashMap<>();
|
item.put("groupCode", row.getRepeatGroupCode());
|
item.put("rowId", row.getRowId());
|
item.put("rowOrder", row.getRowOrder());
|
item.put("status", row.getOperationStatus());
|
item.put("deleteOperationCode", row.getDeleteOperationCode());
|
item.put("deleteReason", row.getDeleteReason());
|
rowMetadata.add(item);
|
}
|
Map<String, Object> metadata = new LinkedHashMap<>();
|
metadata.put("groupCode", group.getGroupCode());
|
metadata.put("minRows", group.getMinRows());
|
metadata.put("maxRows", group.getMaxRows());
|
metadata.put("stepId", group.getStepId());
|
metadata.put("checkboxGroups", repeatCheckboxGroups(
|
group.getGroupCode(), bindings));
|
metadata.put("activeRowCount", rowMetadata.size());
|
metadata.put("rows", rowMetadata);
|
result.add(metadata);
|
}
|
return result;
|
}
|
|
private static Map<String, String> repeatCheckboxGroups(String groupCode,
|
Map<String, ElnTemplateBindingEntity> bindings) {
|
Map<String, String> result = new LinkedHashMap<>();
|
for (ElnTemplateBindingEntity binding : bindings.values()) {
|
if (binding == null
|
|| !"REPEAT".equals(binding.getKongjianJuese())
|
|| !"CHECKBOX".equals(binding.getKongjianLeixing())
|
|| !groupCode.equals(binding.getRepeatGroupCode())
|
|| !StringUtils.hasText(binding.getZiduanBianma())
|
|| !StringUtils.hasText(binding.getCheckboxGroupCode())) {
|
continue;
|
}
|
String previous = result.put(
|
binding.getZiduanBianma(), binding.getCheckboxGroupCode());
|
if (previous != null
|
&& !previous.equals(binding.getCheckboxGroupCode())) {
|
throw new DataException("电子记录重复列选择组配置冲突");
|
}
|
}
|
return result;
|
}
|
|
private static String repeatRowKey(String groupCode, String rowId) {
|
return groupCode + "\n" + rowId;
|
}
|
|
private Map<String, ElnTemplateBindingEntity> activeBindings(
|
String tenantId, String templateId) {
|
Map<String, ElnTemplateBindingEntity> result = new LinkedHashMap<>();
|
if (bindingMapper == null) return result;
|
List<ElnTemplateBindingEntity> bindings = bindingMapper.selectList(
|
Wrappers.<ElnTemplateBindingEntity>lambdaQuery()
|
.eq(ElnTemplateBindingEntity::getFTenantId, tenantId)
|
.eq(ElnTemplateBindingEntity::getMubanId, templateId)
|
.eq(ElnTemplateBindingEntity::getBangdingZhuangtai, "ACTIVE")
|
.and(query -> query.isNull(ElnTemplateBindingEntity::getFDeleteMark)
|
.or().eq(ElnTemplateBindingEntity::getFDeleteMark, 0)));
|
for (ElnTemplateBindingEntity binding : bindings) {
|
if (binding == null || result.put(binding.getId(), binding) != null) {
|
throw new DataException("电子记录活动字段绑定重复");
|
}
|
}
|
return result;
|
}
|
|
private static void appendCheckboxGroup(Map<String, Object> field,
|
ElnTemplateBindingEntity binding, String expectedRole, String type,
|
Map<String, ElnTemplateVos.CheckboxGroup> checkboxGroups) {
|
if (binding != null
|
&& expectedRole.equals(binding.getKongjianJuese())
|
&& "CHECKBOX".equals(binding.getKongjianLeixing())
|
&& "checkbox".equals(type)
|
&& !Boolean.TRUE.equals(field.get("readOnly"))
|
&& StringUtils.hasText(binding.getCheckboxGroupCode())) {
|
String groupCode = binding.getCheckboxGroupCode();
|
ElnTemplateVos.CheckboxGroup rule = checkboxGroups.get(groupCode);
|
field.put("checkboxGroupCode", groupCode);
|
field.put("checkboxGroupMinSelected",
|
rule == null ? Integer.valueOf(0) : rule.getMinSelected());
|
field.put("checkboxGroupMaxSelected",
|
rule == null ? Integer.valueOf(1) : rule.getMaxSelected());
|
}
|
}
|
|
private Map<String, ElnTemplateVos.CheckboxGroup> checkboxGroupRules(
|
String tenantId, String templateId) {
|
Map<String, ElnTemplateVos.CheckboxGroup> result = new LinkedHashMap<>();
|
if (checkboxGroupService == null) return result;
|
for (ElnTemplateVos.CheckboxGroup group
|
: checkboxGroupService.list(tenantId, templateId)) {
|
if (group == null || !StringUtils.hasText(group.getGroupCode())
|
|| !validCheckboxGroupRule(group)
|
|| result.put(group.getGroupCode(), group) != null) {
|
throw new DataException("电子记录选择组数量规则无效");
|
}
|
}
|
return result;
|
}
|
|
private static boolean validCheckboxGroupRule(ElnTemplateVos.CheckboxGroup group) {
|
Integer minSelected = group.getMinSelected();
|
Integer maxSelected = group.getMaxSelected();
|
return minSelected != null && minSelected >= 0
|
&& (maxSelected == null
|
|| (maxSelected >= 1 && minSelected <= maxSelected));
|
}
|
|
private static void appendValueSource(Map<String, Object> field, String valueSource) {
|
if (StringUtils.hasText(valueSource)) field.put("valueSource", valueSource);
|
field.put("readOnly", "CROSS_TEMPLATE".equals(valueSource));
|
}
|
|
private static void appendFormulaState(Map<String, Object> field,
|
String status, String message) {
|
if (StringUtils.hasText(status)) field.put("formulaStatus", status);
|
if (StringUtils.hasText(message)) field.put("formulaMessage", message);
|
}
|
|
private ElnFieldVersionEntity fixedVersion(String tenantId, String versionId) {
|
ElnFieldVersionEntity version = fieldVersionMapper.selectOne(
|
Wrappers.<ElnFieldVersionEntity>lambdaQuery()
|
.eq(ElnFieldVersionEntity::getFTenantId, tenantId)
|
.eq(ElnFieldVersionEntity::getId, versionId).last("limit 1"));
|
if (version == null) throw new DataException("电子记录固定字段版本不存在");
|
return version;
|
}
|
|
private <T> T inTenant(String tenantId, TenantAction<T> action) {
|
if (!StringUtils.hasText(tenantId)) {
|
throw new DataException("电子记录租户不能为空");
|
}
|
try {
|
tenantRoute.switchTo(tenantId.trim());
|
return action.get();
|
} finally {
|
tenantRoute.clear();
|
}
|
}
|
|
@FunctionalInterface
|
interface TenantAction<T> { T get(); }
|
|
interface TenantRoute {
|
void switchTo(String tenantId);
|
void clear();
|
}
|
|
private static String typeOf(ElnFieldVersionEntity version) {
|
if (version.getShujuLeixing() == null) return "text";
|
String type = version.getShujuLeixing().toUpperCase();
|
if ("TEXTAREA".equals(type) || "MULTILINE".equals(type)) return "multiline";
|
if ("SELECT".equals(type) || "DROPDOWN".equals(type)) return "select";
|
if ("CHECKBOX".equals(type) || "BOOLEAN".equals(type)) return "checkbox";
|
if ("DATE".equals(type) || "DATETIME".equals(type)) return "date";
|
return "text";
|
}
|
|
private static Object displayValue(ElnRecordFieldValueEntity value, String type, String fieldType) {
|
return displayValue(value.getZhiWenben(), value.getZhiShuzhi(), value.getZhiRiqi(),
|
type, fieldType);
|
}
|
|
private static Object displayValue(String text, BigDecimal number, Date date,
|
String type, String fieldType) {
|
if (number != null) return number.toPlainString();
|
if (date != null) return new SimpleDateFormat("DATETIME".equalsIgnoreCase(fieldType)
|
? "yyyy-MM-dd HH:mm:ss" : "yyyy-MM-dd").format(date);
|
if ("checkbox".equals(type)) {
|
return Boolean.valueOf(text);
|
}
|
return text;
|
}
|
}
|
