package jnpf.limsService.impl;
|
|
import cn.hutool.core.util.IdUtil;
|
import jnpf.base.ActionResult;
|
import jnpf.base.ActionResultCode;
|
import jnpf.base.UserInfo;
|
import jnpf.eln.RecordFreezeApi;
|
import jnpf.eln.RecordFreezeCheckBatch;
|
import jnpf.eln.RecordFreezeCheckRequest;
|
import jnpf.eln.RecordFreezeCheckResult;
|
import jnpf.eln.RecordFreezeIssue;
|
import jnpf.eln.RecordFreezeReleaseRequest;
|
import jnpf.exception.DataException;
|
import jnpf.limsEntity.JianyanStatus;
|
import jnpf.limsEntity.LimsJianyanXiangEntity;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Component;
|
import org.springframework.transaction.support.TransactionSynchronization;
|
import org.springframework.transaction.support.TransactionSynchronizationManager;
|
import org.springframework.util.StringUtils;
|
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.HashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
|
/**
|
* LIMS 的唯一 ELN 提交门禁。先完成本地权限/状态预检，再向 ELN 申请冻结；
|
* 任何一项未就绪均在本地 UPDATE 前抛出，保证 Controller 事务零写入。
|
*/
|
@Slf4j
|
@Component
|
public class LimsElnRecordFreezeGate {
|
private final RecordFreezeApi recordFreezeApi;
|
|
public LimsElnRecordFreezeGate(RecordFreezeApi recordFreezeApi) {
|
this.recordFreezeApi = recordFreezeApi;
|
}
|
|
public Map<String, SubmissionValues> prepareAndReleaseAfterCompletion(String tenantId, UserInfo user,
|
List<String> testWorkItemIds,
|
Map<String, LimsJianyanXiangEntity> rows) {
|
String actualTenantId = StringUtils.hasText(tenantId) ? tenantId.trim() : "0";
|
List<String> ids = uniqueIds(testWorkItemIds);
|
List<String> localIssues = new ArrayList<>();
|
if (ids.size() != testWorkItemIds.size()) localIssues.add("提交检验项存在重复或无效 id");
|
localIssues.addAll(precheckLocal(ids, rows, user == null ? null : user.getUserId()));
|
RecordFreezeCheckRequest request = new RecordFreezeCheckRequest();
|
request.setTenantId(actualTenantId);
|
request.setUserId(user.getUserId());
|
request.setOperationCode(IdUtil.getSnowflakeNextIdStr());
|
request.setTestWorkItemIds(ids);
|
RecordFreezeCheckBatch batch;
|
try {
|
batch = preparedBatch(request);
|
} catch (DataException e) {
|
releaseBestEffort(actualTenantId, request.getOperationCode(), ids);
|
throw e;
|
} catch (RuntimeException e) {
|
// 响应丢失时无法确认权威复算是否已提交；释放确定性 fence 并拒绝本次提交，
|
// 避免同操作码自动重试产生重复计算日志和记录版本递增。
|
releaseBestEffort(actualTenantId, request.getOperationCode(), ids);
|
throw new DataException("ELN 冻结校验服务调用失败，已拒绝提交");
|
}
|
registerRelease(actualTenantId, request.getOperationCode(), ids);
|
return validateBatch(ids, batch, localIssues);
|
}
|
|
private static List<String> precheckLocal(List<String> ids, Map<String, LimsJianyanXiangEntity> rows, String userId) {
|
List<String> issues = new ArrayList<>();
|
for (String id : ids) {
|
LimsJianyanXiangEntity row = rows.get(id);
|
if (row == null) {
|
issues.add(id + ": 检验项不存在");
|
continue;
|
}
|
String status = row.getJianyanZhuangtai();
|
if (!JianyanStatus.PENDING_TEST.getCode().equals(status)
|
&& !JianyanStatus.CANCELLED.getCode().equals(status)
|
&& !JianyanStatus.AUDIT_REJECTED.getCode().equals(status)) {
|
issues.add(id + ": 检验项状态不允许提交");
|
}
|
boolean external = "yes".equalsIgnoreCase(row.getShifouWaijian());
|
String expectedUser = external ? row.getWaijianLururen() : row.getJianchaRen();
|
if (!StringUtils.hasText(expectedUser) || !expectedUser.equals(userId)) {
|
issues.add(id + ": 当前用户不是检验结果录入负责人");
|
}
|
}
|
return issues;
|
}
|
|
private static Map<String, SubmissionValues> validateBatch(List<String> requestedIds,
|
RecordFreezeCheckBatch batch,
|
List<String> localIssues) {
|
if (batch == null || batch.getItems() == null) throw new DataException("ELN 冻结校验响应无效，已拒绝提交");
|
Map<String, RecordFreezeCheckResult> byId = new HashMap<>();
|
List<String> issues = new ArrayList<>(localIssues);
|
for (RecordFreezeCheckResult item : batch.getItems()) {
|
if (item == null || !StringUtils.hasText(item.getTestWorkItemId()) || byId.put(item.getTestWorkItemId(), item) != null) {
|
throw new DataException("ELN 冻结校验响应包含重复或无效检验项，已拒绝提交");
|
}
|
}
|
if (byId.size() != requestedIds.size() || !byId.keySet().containsAll(requestedIds)) {
|
throw new DataException("ELN 冻结校验响应缺少检验项，已拒绝提交");
|
}
|
for (String id : requestedIds) {
|
RecordFreezeCheckResult item = byId.get(id);
|
if (RecordFreezeCheckResult.NOT_APPLICABLE.equals(item.getStatus())) continue;
|
if (!RecordFreezeCheckResult.READY.equals(item.getStatus()) || !StringUtils.hasText(item.getReleaseToken())) {
|
if (item.getDiagnostics() == null || item.getDiagnostics().isEmpty()) {
|
issues.add(id + ": ELN 记录未准备就绪");
|
} else {
|
for (RecordFreezeIssue issue : item.getDiagnostics()) {
|
issues.add(id + ": " + (issue == null || !StringUtils.hasText(issue.getMessage())
|
? "ELN 记录未准备就绪" : issue.getMessage()));
|
}
|
}
|
}
|
}
|
if (!issues.isEmpty()) throw new DataException("ELN 可冻结校验失败：" + String.join("；", issues));
|
Map<String, SubmissionValues> values = new HashMap<>();
|
for (String id : requestedIds) {
|
RecordFreezeCheckResult item = byId.get(id);
|
if (RecordFreezeCheckResult.NOT_APPLICABLE.equals(item.getStatus())) continue;
|
if (!StringUtils.hasText(item.getTestResult()) || !StringUtils.hasText(item.getTestConclusion())) {
|
throw new DataException("ELN 可冻结校验响应缺少已校验的检验结果或结论，已拒绝提交");
|
}
|
values.put(id, new SubmissionValues(item.getTestResult().trim(),
|
item.getTestConclusion().trim()));
|
}
|
return values;
|
}
|
|
private void registerRelease(String tenantId, String operationCode, List<String> testWorkItemIds) {
|
RecordFreezeReleaseRequest request = new RecordFreezeReleaseRequest();
|
request.setTenantId(tenantId);
|
request.setOperationCode(operationCode);
|
request.setTestWorkItemIds(testWorkItemIds);
|
if (!TransactionSynchronizationManager.isSynchronizationActive()) {
|
release(request);
|
throw new DataException("LIMS 提交事务未激活，已释放 ELN 冻结");
|
}
|
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
|
@Override
|
public void afterCompletion(int status) {
|
release(request);
|
}
|
});
|
}
|
|
private void release(RecordFreezeReleaseRequest request) {
|
try {
|
ActionResult<Boolean> response = recordFreezeApi.release(request);
|
if (response == null || !ActionResultCode.SUCCESS.getCode().equals(response.getCode())
|
|| !Boolean.TRUE.equals(response.getData())) {
|
log.error("[submit-result] ELN 冻结释放失败 operation={}", request.getOperationCode());
|
}
|
} catch (RuntimeException e) {
|
log.error("[submit-result] ELN 冻结释放异常 operation={}", request.getOperationCode(), e);
|
}
|
}
|
|
private RecordFreezeCheckBatch preparedBatch(RecordFreezeCheckRequest request) {
|
ActionResult<RecordFreezeCheckBatch> response = recordFreezeApi.prepare(request);
|
if (response == null) throw new IllegalStateException("ELN 冻结校验服务无响应");
|
if (!ActionResultCode.SUCCESS.getCode().equals(response.getCode()) || response.getData() == null) {
|
throw new DataException(StringUtils.hasText(response.getMsg())
|
? response.getMsg() : "ELN 冻结校验服务不可用，已拒绝提交");
|
}
|
return response.getData();
|
}
|
|
private void releaseBestEffort(String tenantId, String operationCode, List<String> testWorkItemIds) {
|
RecordFreezeReleaseRequest request = new RecordFreezeReleaseRequest();
|
request.setTenantId(tenantId);
|
request.setOperationCode(operationCode);
|
request.setTestWorkItemIds(testWorkItemIds);
|
release(request);
|
}
|
|
private static List<String> uniqueIds(Collection<String> ids) {
|
if (ids == null) return Collections.emptyList();
|
Set<String> unique = new LinkedHashSet<>();
|
for (String id : ids) if (StringUtils.hasText(id)) unique.add(id.trim());
|
return new ArrayList<>(unique);
|
}
|
|
/** 仅 READY 的 ELN 项携带；LIMS 无需了解 ELN 字段目录。 */
|
public static final class SubmissionValues {
|
private final String testResult;
|
private final String testConclusion;
|
|
private SubmissionValues(String testResult, String testConclusion) {
|
this.testResult = testResult;
|
this.testConclusion = testConclusion;
|
}
|
|
public String getTestResult() {
|
return testResult;
|
}
|
|
public String getTestConclusion() {
|
return testConclusion;
|
}
|
}
|
}
|
