package jnpf.limsService.impl;
|
|
import com.baomidou.mybatisplus.annotation.TableField;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import jnpf.audit.sdk.annotation.AuditLog;
|
import jnpf.exception.DataException;
|
import jnpf.limsEntity.LimsQingyandanEntity;
|
import jnpf.limsEntity.LimsQingyandanYichangShenqingEntity;
|
import jnpf.limsEntity.LimsQingyandanYichangShenqingZiduanEntity;
|
import jnpf.limsMapper.LimsQingyandanMapper;
|
import jnpf.limsMapper.LimsQingyandanYichangShenqingMapper;
|
import jnpf.limsMapper.LimsQingyandanYichangShenqingZiduanMapper;
|
import jnpf.limsService.LimsQingyandanYichangService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.StringUtils;
|
|
import java.lang.reflect.Field;
|
import java.math.BigDecimal;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.util.Collections;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Locale;
|
import java.util.Map;
|
import java.util.Set;
|
|
/**
|
* 请验单异常申请处理服务实现。
|
*/
|
@Service
|
public class LimsQingyandanYichangServiceImpl implements LimsQingyandanYichangService {
|
|
private static final String[] DATE_PATTERNS = {
|
"yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd'T'HH:mm:ss", "yyyy-MM-dd"
|
};
|
|
private static final Set<String> IMMUTABLE_COLUMNS;
|
private static final Map<String, QingyandanField> QINGYANDAN_FIELDS;
|
|
static {
|
Set<String> immutableColumns = new HashSet<>();
|
Collections.addAll(immutableColumns,
|
"f_id", "f_tenant_id", "f_flow_id", "f_flow_task_id", "f_flow_state",
|
"f_version", "f_delete_mark", "f_delete_time", "f_delete_user_id",
|
"f_creator_user_id", "f_creator_time", "f_last_modify_user_id",
|
"f_last_modify_time");
|
IMMUTABLE_COLUMNS = Collections.unmodifiableSet(immutableColumns);
|
QINGYANDAN_FIELDS = buildQingyandanFields();
|
}
|
|
@Autowired
|
private LimsQingyandanYichangShenqingMapper shenqingMapper;
|
|
@Autowired
|
private LimsQingyandanYichangShenqingZiduanMapper ziduanMapper;
|
|
@Autowired
|
private LimsQingyandanMapper qingyandanMapper;
|
|
/**
|
* 查询异常申请及其变更字段，并在同一事务中更新关联请验单。
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
@AuditLog(action = "UPDATE", label = "处理请验单异常申请", bizType = "QINGYANDAN",
|
bizCodeExpr = "#result > 0 ? #flowId : ''", targetTable = "lims_qingyandan",
|
targetIdExpr = "T(jnpf.limsService.support.LimsAuditTargetIds).qingyandanByExceptionFlow(#flowId, #flowTaskId)",
|
diff = true, entityClass = LimsQingyandanEntity.class)
|
public int chuli(String flowId, String flowTaskId) {
|
String resolvedFlowId = requireText(flowId, "流程ID(flow_id)不能为空");
|
String resolvedFlowTaskId = requireText(flowTaskId, "流程任务ID(flow_task_id)不能为空");
|
|
LimsQingyandanYichangShenqingEntity shenqing = getShenqing(
|
resolvedFlowId, resolvedFlowTaskId);
|
if (!StringUtils.hasText(shenqing.getQingyandanId())) {
|
throw new DataException("异常申请未关联请验单");
|
}
|
|
LambdaQueryWrapper<LimsQingyandanYichangShenqingZiduanEntity> ziduanQuery =
|
new LambdaQueryWrapper<>();
|
ziduanQuery.eq(LimsQingyandanYichangShenqingZiduanEntity::getForeignId, shenqing.getId());
|
List<LimsQingyandanYichangShenqingZiduanEntity> ziduanList =
|
ziduanMapper.selectList(ziduanQuery);
|
if (ziduanList.isEmpty()) {
|
throw new DataException("异常申请没有需要变更的字段");
|
}
|
|
Map<String, Object> changes = resolveChanges(ziduanList);
|
UpdateWrapper<LimsQingyandanEntity> update = new UpdateWrapper<>();
|
update.eq("f_id", shenqing.getQingyandanId().trim());
|
changes.forEach(update::set);
|
int updated = qingyandanMapper.update(null, update);
|
if (updated != 1) {
|
throw new DataException(updated == 0 ? "关联的请验单不存在" : "关联到多条请验单，已取消更新");
|
}
|
return changes.size();
|
}
|
|
private LimsQingyandanYichangShenqingEntity getShenqing(String flowId, String flowTaskId) {
|
LambdaQueryWrapper<LimsQingyandanYichangShenqingEntity> query = new LambdaQueryWrapper<>();
|
query.eq(LimsQingyandanYichangShenqingEntity::getFlowId, flowId)
|
.eq(LimsQingyandanYichangShenqingEntity::getFlowTaskId, flowTaskId);
|
List<LimsQingyandanYichangShenqingEntity> rows = shenqingMapper.selectList(query);
|
if (rows.isEmpty()) {
|
throw new DataException("未找到对应的请验单异常申请");
|
}
|
if (rows.size() > 1) {
|
throw new DataException("同一流程任务关联了多条请验单异常申请");
|
}
|
return rows.get(0);
|
}
|
|
private Map<String, Object> resolveChanges(
|
List<LimsQingyandanYichangShenqingZiduanEntity> ziduanList) {
|
Map<String, Object> changes = new LinkedHashMap<>();
|
for (int i = 0; i < ziduanList.size(); i++) {
|
LimsQingyandanYichangShenqingZiduanEntity ziduan = ziduanList.get(i);
|
if (ziduan == null || !StringUtils.hasText(ziduan.getKebianZiduan())) {
|
throw new DataException("第" + (i + 1) + "条变更的可变字段不能为空");
|
}
|
String requestedField = normalize(ziduan.getKebianZiduan());
|
QingyandanField field = QINGYANDAN_FIELDS.get(requestedField);
|
if (field == null) {
|
throw new DataException("不支持变更请验单字段：" + ziduan.getKebianZiduan());
|
}
|
Object value = convertValue(ziduan.getBiangenghouShuju(), field, i);
|
changes.put(field.column, value);
|
}
|
return changes;
|
}
|
|
private Object convertValue(String value, QingyandanField field, int index) {
|
if (field.type == String.class) {
|
return value;
|
}
|
if (!StringUtils.hasText(value)) {
|
return null;
|
}
|
String trimmed = value.trim();
|
try {
|
if (field.type == Integer.class || field.type == int.class) {
|
return Integer.valueOf(trimmed);
|
}
|
if (field.type == Long.class || field.type == long.class) {
|
return Long.valueOf(trimmed);
|
}
|
if (field.type == BigDecimal.class) {
|
return new BigDecimal(trimmed);
|
}
|
if (field.type == Date.class) {
|
return parseDate(trimmed);
|
}
|
} catch (IllegalArgumentException | ParseException e) {
|
throw new DataException("第" + (index + 1) + "条变更字段[" + field.column
|
+ "]的值格式不正确：" + value);
|
}
|
throw new DataException("不支持字段[" + field.column + "]的数据类型："
|
+ field.type.getSimpleName());
|
}
|
|
private Date parseDate(String value) throws ParseException {
|
if (value.matches("^-?\\d+$")) {
|
return new Date(Long.parseLong(value));
|
}
|
for (String pattern : DATE_PATTERNS) {
|
SimpleDateFormat format = new SimpleDateFormat(pattern, Locale.ROOT);
|
format.setLenient(false);
|
try {
|
return format.parse(value);
|
} catch (ParseException ignored) {
|
// Continue with the next supported format.
|
}
|
}
|
throw new ParseException(value, 0);
|
}
|
|
private static Map<String, QingyandanField> buildQingyandanFields() {
|
Map<String, QingyandanField> fields = new HashMap<>();
|
for (Field javaField : LimsQingyandanEntity.class.getDeclaredFields()) {
|
TableField tableField = javaField.getAnnotation(TableField.class);
|
if (tableField == null || !tableField.exist() || !StringUtils.hasText(tableField.value())) {
|
continue;
|
}
|
String column = normalize(tableField.value());
|
if (IMMUTABLE_COLUMNS.contains(column)) {
|
continue;
|
}
|
QingyandanField metadata = new QingyandanField(column, javaField.getType());
|
fields.put(column, metadata);
|
fields.put(normalize(javaField.getName()), metadata);
|
}
|
return Collections.unmodifiableMap(fields);
|
}
|
|
private static String requireText(String value, String message) {
|
if (!StringUtils.hasText(value)) {
|
throw new DataException(message);
|
}
|
return value.trim();
|
}
|
|
private static String normalize(String value) {
|
return value == null ? "" : value.trim().toLowerCase(Locale.ROOT);
|
}
|
|
private static final class QingyandanField {
|
private final String column;
|
private final Class<?> type;
|
|
private QingyandanField(String column, Class<?> type) {
|
this.column = column;
|
this.type = type;
|
}
|
}
|
}
|
