package jnpf.limsService.provider;
|
|
import com.fasterxml.jackson.databind.PropertyNamingStrategies;
|
import com.fasterxml.jackson.databind.annotation.JsonNaming;
|
import jnpf.exception.DataException;
|
import lombok.Data;
|
import lombok.Value;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.stream.Collectors;
|
|
/** Business-facing data-item management; dataset and revision choreography stays behind this interface. */
|
public class LimsElnDataItemManager {
|
private final LimsElnSourceCatalog properties;
|
private final LimsElnDatasetCatalog paths;
|
private final LimsElnSourceMetadata metadata;
|
|
public LimsElnDataItemManager(LimsElnSourceCatalog properties, LimsElnDatasetCatalog paths,
|
LimsElnSourceMetadata metadata) {
|
this.properties = properties;
|
this.paths = paths;
|
this.metadata = metadata;
|
}
|
|
public List<DataItem> items() {
|
Map<String, LimsElnDatasetCatalog.Version> pathVersions = new LinkedHashMap<>();
|
for (LimsElnDatasetCatalog.Version version : paths.versions()) {
|
pathVersions.put(pathKey(version.getCode(), version.getRevision()), version);
|
}
|
Map<String, LimsElnDatasetCatalog.Draft> pathDefinitions = new LinkedHashMap<>();
|
Map<String, String> objectNames = objectNameMap();
|
Map<String, List<LimsElnSourceMetadata.Candidate>> fieldsByObject = new LinkedHashMap<>();
|
Map<String, Boolean> enabledStates = properties.enabledStates();
|
List<DataItem> result = new ArrayList<>();
|
for (LimsElnSourceCatalog.Version version : properties.versions()) {
|
LimsElnSourceCatalog.Definition definition = properties.definition(version);
|
LimsElnDatasetCatalog.Version path = pathVersions.get(
|
pathKey(definition.getDatasetCode(), definition.getDatasetRevision()));
|
if (path == null) throw new DataException("Source path version not found");
|
LimsElnDatasetCatalog.Draft pathDefinition = pathDefinitions.computeIfAbsent(
|
path.getId(), ignored -> paths.definition(path));
|
result.add(item(version, definition, path, pathDefinition, objectNames, fieldsByObject,
|
enabledStates.getOrDefault(version.getPropertyCode(), false)));
|
}
|
return result;
|
}
|
|
public List<SourcePath> sourcePaths() {
|
Map<String, String> objectNames = objectNameMap();
|
Map<String, List<LimsElnSourceMetadata.Candidate>> fieldsByObject = new LinkedHashMap<>();
|
List<SourcePath> result = new ArrayList<>();
|
for (LimsElnDatasetCatalog.Version version : paths.versions()) {
|
result.add(sourcePath(version, paths.definition(version), objectNames, fieldsByObject));
|
}
|
return result;
|
}
|
|
public SourcePath createSourcePath(SourcePathDraft command) {
|
if (command == null || command.getRootObjectId() == null || command.getTargetObjectId() == null
|
|| command.getOutputFieldId() == null || command.getSampleId() == null) {
|
throw new DataException("Source path and preview sample are required");
|
}
|
boolean related = !Objects.equals(command.getRootObjectId(), command.getTargetObjectId());
|
if (related && (command.getFromFieldId() == null || command.getTargetFieldId() == null)) {
|
throw new DataException("Source path relation is required");
|
}
|
LimsElnDatasetCatalog.Selection output = new LimsElnDatasetCatalog.Selection();
|
output.setFieldId(command.getOutputFieldId());
|
output.setStep(related ? 1 : 0);
|
|
LimsElnDatasetCatalog.Draft draft = new LimsElnDatasetCatalog.Draft();
|
draft.setCode(command.getCode());
|
draft.setDisplayName(command.getDisplayName());
|
draft.setRootObjectId(command.getRootObjectId());
|
draft.setFields(Collections.singletonMap(command.getOutputKey(), output));
|
if (related) {
|
LimsElnDatasetCatalog.Relation relation = new LimsElnDatasetCatalog.Relation();
|
relation.setFromStep(0);
|
relation.setFromFieldId(command.getFromFieldId());
|
relation.setObjectId(command.getTargetObjectId());
|
relation.setTargetFieldId(command.getTargetFieldId());
|
draft.setRelations(Collections.singletonList(relation));
|
}
|
return sourcePath(paths.createPublished(draft, command.getSampleId()));
|
}
|
|
public DataItem create(DataItemDraft command) {
|
SourceSelection source = source(command);
|
return item(properties.createDraft(draft(command, source)));
|
}
|
|
public DataItem save(String id, DataItemDraft command) {
|
if (command == null || command.getExpectedEditVersion() == null) {
|
throw new DataException("Expected edit version is required");
|
}
|
LimsElnSourceCatalog.Version current = properties.detail(id);
|
if (!current.getPropertyCode().equals(command.getPropertyCode())) {
|
throw new DataException("Source property code is immutable");
|
}
|
if (current.getEditVersion() != command.getExpectedEditVersion()) {
|
throw new LimsElnReadonlyResolver.SourceFailure("SOURCE_CONFLICT", "Source version has changed");
|
}
|
SourceSelection source = source(command);
|
LimsElnSourceCatalog.Draft draft = draft(command, source);
|
return item("PUBLISHED".equals(current.getStatus())
|
? properties.newVersion(id, draft)
|
: properties.updateDraft(id, command.getExpectedEditVersion(), draft));
|
}
|
|
public Preview preview(String id, String sampleId) {
|
LimsElnSourceCatalog.Preview result = properties.preview(id, sampleId);
|
Object value = result.getValues() == null || result.getValues().isEmpty() ? null : result.getValues().get(0);
|
return new Preview(value);
|
}
|
|
public DataItem publish(String id, int expectedEditVersion, String sampleId) {
|
return item(properties.publish(id, expectedEditVersion, sampleId));
|
}
|
|
private LimsElnSourceCatalog.Draft draft(DataItemDraft command, SourceSelection source) {
|
if (command == null) throw new DataException("Data item is required");
|
LimsElnSourceCatalog.Definition definition = new LimsElnSourceCatalog.Definition();
|
definition.setDatasetCode(source.path.getCode());
|
definition.setDatasetRevision(source.path.getRevision());
|
definition.setFieldId(command.getOutputKey());
|
return new LimsElnSourceCatalog.Draft(command.getPropertyCode(), command.getDisplayName(),
|
source.dataType, definition);
|
}
|
|
private SourceSelection source(DataItemDraft command) {
|
if (command == null || command.getSourcePathId() == null || command.getOutputKey() == null) {
|
throw new DataException("Source path and return content are required");
|
}
|
LimsElnDatasetCatalog.Version path = paths.detail(command.getSourcePathId());
|
if (!"PUBLISHED".equals(path.getStatus())) throw new DataException("Published source path required");
|
LimsElnDatasetCatalog.Draft definition = paths.definition(path);
|
LimsElnDatasetCatalog.Selection selection = definition.getFields().get(command.getOutputKey());
|
if (selection == null) throw new DataException("Source path return content not found");
|
LimsElnSourceMetadata.Candidate field = candidate(definition, selection);
|
String dataType = "DATE_ONLY".equals(selection.getFormat()) ? "DATE" : field.getDataType();
|
return new SourceSelection(path, dataType);
|
}
|
|
private DataItem item(LimsElnSourceCatalog.Version version) {
|
LimsElnSourceCatalog.Definition definition = properties.definition(version);
|
LimsElnDatasetCatalog.Version path = paths.version(definition.getDatasetCode(), definition.getDatasetRevision());
|
LimsElnDatasetCatalog.Draft pathDefinition = paths.definition(path);
|
return item(version, definition, path, pathDefinition, objectNameMap(), new LinkedHashMap<>(),
|
properties.enabled(version.getPropertyCode()));
|
}
|
|
private DataItem item(LimsElnSourceCatalog.Version version, LimsElnSourceCatalog.Definition definition,
|
LimsElnDatasetCatalog.Version path, LimsElnDatasetCatalog.Draft pathDefinition,
|
Map<String, String> objectNames,
|
Map<String, List<LimsElnSourceMetadata.Candidate>> fieldsByObject, boolean enabled) {
|
LimsElnDatasetCatalog.Selection selection = pathDefinition.getFields().get(definition.getFieldId());
|
if (selection == null) throw new DataException("Source path return content not found");
|
PathDescription description = describe(pathDefinition, definition.getFieldId(), objectNames, fieldsByObject);
|
return new DataItem(version.getId(), version.getPropertyCode(), version.getDisplayName(), version.getDataType(),
|
version.getStatus(), enabled, version.getRevision(),
|
version.getEditVersion(), path.getId(), definition.getFieldId(), description.path,
|
description.outputName, returnContent(selection), scope(pathDefinition), version.getPublishedAt(),
|
version.getPublishedBy());
|
}
|
|
private SourcePath sourcePath(LimsElnDatasetCatalog.Version version) {
|
LimsElnDatasetCatalog.Draft definition = paths.definition(version);
|
return sourcePath(version, definition, objectNameMap(), new LinkedHashMap<>());
|
}
|
|
private SourcePath sourcePath(LimsElnDatasetCatalog.Version version,
|
LimsElnDatasetCatalog.Draft definition, Map<String, String> objectNames,
|
Map<String, List<LimsElnSourceMetadata.Candidate>> fieldsByObject) {
|
List<PathOutput> outputs = definition.getFields().keySet().stream().map(key -> {
|
LimsElnDatasetCatalog.Selection selection = definition.getFields().get(key);
|
PathDescription description = describe(definition, key, objectNames, fieldsByObject);
|
LimsElnSourceMetadata.Candidate candidate = candidate(definition, selection, fieldsByObject);
|
String type = "DATE_ONLY".equals(selection.getFormat()) ? "DATE" : candidate.getDataType();
|
return new PathOutput(key, description.outputName, type, returnContent(selection), description.path);
|
}).collect(Collectors.toList());
|
String pathLabel = outputs.isEmpty() ? objectNames(definition, objectNames).stream().collect(Collectors.joining(" > "))
|
: outputs.get(0).getPath();
|
return new SourcePath(version.getId(), version.getCode(), version.getDisplayName(), version.getStatus(),
|
version.getRevision(), version.getEditVersion(), pathLabel, scope(definition), outputs,
|
version.getPublishedAt(), version.getPublishedBy());
|
}
|
|
private PathDescription describe(LimsElnDatasetCatalog.Draft definition, String outputKey,
|
Map<String, String> objectNames,
|
Map<String, List<LimsElnSourceMetadata.Candidate>> fieldsByObject) {
|
LimsElnDatasetCatalog.Selection selection = definition.getFields().get(outputKey);
|
if (selection == null) throw new DataException("Source path return content not found");
|
List<String> objects = objectNames(definition, objectNames);
|
if (selection.getStep() < 0 || selection.getStep() >= objects.size()) {
|
throw new DataException("Invalid source path output");
|
}
|
LimsElnSourceMetadata.Candidate field = candidate(definition, selection, fieldsByObject);
|
List<String> segments = new ArrayList<>(objects.subList(0, selection.getStep() + 1));
|
segments.add(field.getDisplayName());
|
return new PathDescription(String.join(" > ", segments), field.getDisplayName());
|
}
|
|
private Map<String, String> objectNameMap() {
|
return metadata.objects().stream().collect(Collectors.toMap(
|
LimsElnSourceMetadata.BusinessObject::getId,
|
LimsElnSourceMetadata.BusinessObject::getDisplayName,
|
(left, right) -> left,
|
LinkedHashMap::new));
|
}
|
|
private List<String> objectNames(LimsElnDatasetCatalog.Draft definition, Map<String, String> names) {
|
List<String> result = new ArrayList<>();
|
result.add(names.getOrDefault(definition.getRootObjectId(), definition.getRootObjectId()));
|
for (LimsElnDatasetCatalog.Relation relation : definition.getRelations()) {
|
result.add(names.getOrDefault(relation.getObjectId(), relation.getObjectId()));
|
}
|
return result;
|
}
|
|
private LimsElnSourceMetadata.Candidate candidate(LimsElnDatasetCatalog.Draft definition,
|
LimsElnDatasetCatalog.Selection selection) {
|
return candidate(definition, selection, new LinkedHashMap<>());
|
}
|
|
private LimsElnSourceMetadata.Candidate candidate(LimsElnDatasetCatalog.Draft definition,
|
LimsElnDatasetCatalog.Selection selection,
|
Map<String, List<LimsElnSourceMetadata.Candidate>> fieldsByObject) {
|
List<String> objectIds = new ArrayList<>();
|
objectIds.add(definition.getRootObjectId());
|
objectIds.addAll(definition.getRelations().stream().map(LimsElnDatasetCatalog.Relation::getObjectId)
|
.collect(Collectors.toList()));
|
if (selection.getStep() < 0 || selection.getStep() >= objectIds.size()) {
|
throw new DataException("Invalid source path output");
|
}
|
String objectId = objectIds.get(selection.getStep());
|
return fieldsByObject.computeIfAbsent(objectId, metadata::fields).stream()
|
.filter(item -> item.getId().equals(selection.getFieldId())).findFirst()
|
.orElseThrow(() -> new DataException("Source path field is no longer available"));
|
}
|
|
private static String returnContent(LimsElnDatasetCatalog.Selection selection) {
|
return "DISPLAY_NAME".equals(selection.getValueMode()) ? "显示名称" : "原值";
|
}
|
|
private static String scope(LimsElnDatasetCatalog.Draft definition) {
|
return definition.getConditions() == null || definition.getConditions().isEmpty()
|
? "全部检验项" : "指定范围（" + definition.getConditions().size() + " 条规则）";
|
}
|
|
private static String pathKey(String code, Integer revision) {
|
return code + "\u0000" + revision;
|
}
|
|
@Data
|
@JsonNaming(PropertyNamingStrategies.LowerCamelCaseStrategy.class)
|
public static class DataItemDraft {
|
private String propertyCode;
|
private String displayName;
|
private String sourcePathId;
|
private String outputKey;
|
private Integer expectedEditVersion;
|
}
|
|
@Data
|
@JsonNaming(PropertyNamingStrategies.LowerCamelCaseStrategy.class)
|
public static class SourcePathDraft {
|
private String code;
|
private String displayName;
|
private String rootObjectId;
|
private String targetObjectId;
|
private String fromFieldId;
|
private String targetFieldId;
|
private String outputKey;
|
private String outputFieldId;
|
private String sampleId;
|
}
|
|
@Value
|
@JsonNaming(PropertyNamingStrategies.LowerCamelCaseStrategy.class)
|
public static class Preview { Object value; }
|
|
@Value
|
@JsonNaming(PropertyNamingStrategies.LowerCamelCaseStrategy.class)
|
public static class DataItem {
|
String id;
|
String propertyCode;
|
String displayName;
|
String dataType;
|
String status;
|
boolean enabled;
|
int revision;
|
int editVersion;
|
String sourcePathId;
|
String outputKey;
|
String sourcePath;
|
String outputName;
|
String returnContent;
|
String scope;
|
String publishedAt;
|
String publishedBy;
|
}
|
|
@Value
|
@JsonNaming(PropertyNamingStrategies.LowerCamelCaseStrategy.class)
|
public static class SourcePath {
|
String id;
|
String code;
|
String displayName;
|
String status;
|
int revision;
|
int editVersion;
|
String path;
|
String scope;
|
List<PathOutput> outputs;
|
String publishedAt;
|
String publishedBy;
|
}
|
|
@Value
|
@JsonNaming(PropertyNamingStrategies.LowerCamelCaseStrategy.class)
|
public static class PathOutput {
|
String key;
|
String displayName;
|
String dataType;
|
String returnContent;
|
String path;
|
}
|
|
@Value
|
private static class SourceSelection {
|
LimsElnDatasetCatalog.Version path;
|
String dataType;
|
}
|
|
@Value
|
private static class PathDescription {
|
String path;
|
String outputName;
|
}
|
}
|
