package com.battery.business.service.impl;
|
|
import java.math.BigDecimal;
|
import java.nio.charset.StandardCharsets;
|
import java.security.MessageDigest;
|
import java.time.Instant;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.UUID;
|
import com.alibaba.fastjson2.JSON;
|
import com.battery.business.domain.DataRevisionItem;
|
import com.battery.business.domain.TTest;
|
import com.battery.business.domain.TTestDataRevisionAction;
|
import com.battery.business.mapper.TTestMapper;
|
import com.battery.business.service.ITestConsoleDataService;
|
import com.ruoyi.common.exception.ServiceException;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
/** 在测试行锁内保存修改前完整事实，再编辑、导入或物理删除三类记录。 */
|
@Service
|
public class TestConsoleDataServiceImpl implements ITestConsoleDataService
|
{
|
private final TTestMapper mapper;
|
public TestConsoleDataServiceImpl(TTestMapper mapper) { this.mapper = mapper; }
|
|
/** 查询只追加的修订动作。 */
|
@Override public List<TTestDataRevisionAction> selectActions(TTestDataRevisionAction query)
|
{
|
if (query == null) query = new TTestDataRevisionAction();
|
if (query.getDataType() != null && !Set.of("REALTIME", "STEP", "CYCLE").contains(query.getDataType())) throw new ServiceException("数据类型无效");
|
if (query.getOperationType() != null && !Set.of("EDIT", "IMPORT", "DELETE").contains(query.getOperationType())) throw new ServiceException("操作类型无效");
|
return mapper.selectDataRevisionActions(query);
|
}
|
|
/** 查询修订动作详情及修改前内容。 */
|
@Override public TTestDataRevisionAction selectActionById(Long actionId)
|
{ return mapper.selectDataRevisionActionById(actionId); }
|
|
/** 一次提交与接收、测试整体删除互斥；任一目标无效时整次动作回滚。 */
|
@Override @Transactional(rollbackFor = Exception.class)
|
public Long submitAction(TTestDataRevisionAction action, List<DataRevisionItem> items)
|
{
|
if (action == null || action.getTestId() == null) throw new ServiceException("测试ID不能为空");
|
if (action.getDataType() == null || !Set.of("REALTIME", "STEP", "CYCLE").contains(action.getDataType())) throw new ServiceException("数据类型无效");
|
if (action.getOperationType() == null || !Set.of("EDIT", "IMPORT", "DELETE").contains(action.getOperationType())) throw new ServiceException("操作类型无效");
|
if (action.getReason() == null || action.getReason().isBlank()) throw new ServiceException("数据操作原因不能为空");
|
if (action.getScopeSummary() == null || action.getScopeSummary().isBlank()) throw new ServiceException("数据操作范围不能为空");
|
TTest test = mapper.selectTestByIdForUpdate(action.getTestId());
|
if (test == null) throw new ServiceException("测试不存在");
|
action.setCreatedAtUtc(new Date());
|
action.setReason(action.getReason().trim());
|
List<Map<String, Object>> before = new ArrayList<>();
|
List<Map<String, Object>> changes = new ArrayList<>();
|
List<Runnable> mutations = new ArrayList<>();
|
if ("IMPORT".equals(action.getOperationType()))
|
{
|
if (!"COMPLETED".equals(test.getTestStatus())) throw new ServiceException("测试完成后才可以导入数据");
|
List<Map> rows;
|
try { rows = JSON.parseArray(action.getChangesSummary(), Map.class); }
|
catch (RuntimeException ex) { throw new ServiceException("导入数据格式无效"); }
|
if (rows == null || rows.isEmpty()) throw new ServiceException("导入数据不能为空");
|
Set<String> identities = new HashSet<>();
|
for (Map<String, Object> row : rows)
|
{
|
String recordNo = row.get("recordNo") == null ? "" : row.get("recordNo").toString();
|
if (recordNo.isBlank() || !identities.add(recordNo)) throw new ServiceException("导入记录编号为空或重复");
|
Map<String, Object> values = importedRecord(action, row);
|
mutations.add(() -> mapper.insertImportedDataRecord(action.getDataType(), values));
|
changes.add(new LinkedHashMap<>(row));
|
}
|
action.setIdentitySummary(JSON.toJSONString(identities));
|
}
|
else
|
{
|
List<String> identities;
|
try { identities = JSON.parseArray(action.getIdentitySummary(), String.class); }
|
catch (RuntimeException ex) { throw new ServiceException("身份摘要格式无效"); }
|
if (identities == null || identities.isEmpty() || new HashSet<>(identities).size() != identities.size())
|
throw new ServiceException("请选择不重复的数据记录");
|
Map<String, DataRevisionItem> edits = new LinkedHashMap<>();
|
for (DataRevisionItem item : items == null ? List.<DataRevisionItem>of() : items)
|
if (item == null || edits.put(item.getStableIdentity(), item) != null) throw new ServiceException("修改目标无效或重复");
|
if ("EDIT".equals(action.getOperationType()) && !edits.keySet().equals(new HashSet<>(identities)))
|
throw new ServiceException("修改目标与身份摘要不一致");
|
for (String identity : identities)
|
{
|
long id = recordId(action.getDataType(), identity);
|
Map<String, Object> row = mapper.selectDataRecord(action.getTestId(), action.getDataType(), id);
|
if (row == null || row.isEmpty()) throw new ServiceException("数据不存在或不属于当前测试");
|
before.add(new LinkedHashMap<>(row));
|
if ("DELETE".equals(action.getOperationType())) mutations.add(() -> mapper.deleteDataRecord(action.getTestId(), action.getDataType(), id));
|
else
|
{
|
Map<String, Object> fields;
|
try { fields = JSON.parseObject(edits.get(identity).getFieldValues(), Map.class); }
|
catch (RuntimeException ex) { throw new ServiceException("修改字段格式无效"); }
|
Map<String, Object> values = editableValues(action.getDataType(), fields);
|
mergeStepExtension(action.getDataType(), row.get("extension_measurements_json"), fields, values);
|
mutations.add(() -> mapper.updateDataRecord(action.getTestId(), action.getDataType(), id, values));
|
Map<String, Object> displayBefore = new LinkedHashMap<>();
|
columns(action.getDataType()).forEach((field, column) -> displayBefore.put(field, row.get(column)));
|
if ("STEP".equals(action.getDataType()) && row.get("extension_measurements_json") != null)
|
{
|
Map<String, Object> extensionBefore = JSON.parseObject(row.get("extension_measurements_json").toString());
|
STEP_EXTENSION_FIELDS.forEach(field -> displayBefore.put(field, extensionBefore.get(field)));
|
}
|
changes.add(Map.of("identity", identity, "before", displayBefore, "after", fields));
|
}
|
}
|
}
|
// 修改前内容从数据库读取，不信任浏览器提交的 before；事务失败不会留下孤立修订。
|
action.setBeforeContentJson(JSON.toJSONString(before));
|
action.setChangesSummary(JSON.toJSONString("DELETE".equals(action.getOperationType()) ? before : changes));
|
mapper.insertDataRevisionAction(action);
|
mutations.forEach(Runnable::run);
|
return action.getActionId();
|
}
|
|
private long recordId(String type, String identity)
|
{
|
String prefix = switch (type) { case "REALTIME" -> "realtime:"; case "STEP" -> "step:"; default -> "cycle:"; };
|
try {
|
if (identity == null || !identity.startsWith(prefix)) throw new NumberFormatException();
|
long id = Long.parseLong(identity.substring(prefix.length()));
|
if (id < 1) throw new NumberFormatException();
|
return id;
|
} catch (NumberFormatException ex) { throw new ServiceException("数据稳定身份无效"); }
|
}
|
|
private Map<String, String> columns(String type)
|
{
|
return switch (type) {
|
case "REALTIME" -> Map.of("voltage", "voltage_v", "current", "current_a", "capacity", "capacity_ah", "energy", "energy_wh",
|
"temperature", "temperature", "positivePotential", "positive_potential", "negativePotential", "negative_potential");
|
case "STEP" -> Map.of("endVoltage", "voltage_v", "capacity", "capacity_ah", "energy", "energy_wh");
|
default -> Map.of("chargeCapacity", "charge_capacity_ah", "dischargeCapacity", "discharge_capacity_ah",
|
"chargeEnergy", "charge_energy_wh", "dischargeEnergy", "discharge_energy_wh", "efficiency", "efficiency");
|
};
|
}
|
|
private Map<String, Object> editableValues(String type, Map<String, Object> fields)
|
{
|
if (fields == null || fields.isEmpty()) throw new ServiceException("修改内容不能为空");
|
Map<String, Object> values = new LinkedHashMap<>();
|
Map<String, String> columns = columns(type);
|
fields.forEach((key, value) -> {
|
if ("STEP".equals(type) && STEP_EXTENSION_FIELDS.contains(key)) return;
|
String column = columns.get(key);
|
if (column == null) throw new ServiceException("字段不可修改: " + key);
|
try { values.put(column, value == null ? null : new BigDecimal(value.toString())); }
|
catch (RuntimeException ex) { throw new ServiceException("测量值必须为数值或空值: " + key); }
|
});
|
return values;
|
}
|
|
private static final Set<String> STEP_EXTENSION_FIELDS = Set.of("stepDuration", "startVoltage", "chargePeakVoltage", "dischargeValleyVoltage");
|
|
private void mergeStepExtension(String type, Object previous, Map<String, Object> fields, Map<String, Object> values)
|
{
|
if (!"STEP".equals(type) || fields.keySet().stream().noneMatch(STEP_EXTENSION_FIELDS::contains)) return;
|
Map<String, Object> extension = previous == null ? new LinkedHashMap<>() : JSON.parseObject(previous.toString());
|
for (String field : STEP_EXTENSION_FIELDS)
|
{
|
if (!fields.containsKey(field)) continue;
|
Object value = fields.get(field);
|
try { extension.put(field, value == null ? null : new BigDecimal(value.toString())); }
|
catch (RuntimeException ex) { throw new ServiceException("测量值必须为数值或空值: " + field); }
|
}
|
values.put("extension_measurements_json", JSON.toJSONString(extension));
|
}
|
|
private Map<String, Object> importedRecord(TTestDataRevisionAction action, Map<String, Object> row)
|
{
|
Map<String, Object> binding = mapper.selectImportBinding(action.getTestId(), String.valueOf(row.get("batteryNo")));
|
if (binding == null) throw new ServiceException("导入电池号不属于当前测试");
|
Map<String, Object> values = new LinkedHashMap<>(binding);
|
values.put("test_id", action.getTestId());
|
values.put("source_identity", "IMPORT");
|
values.put("source_record_id", String.valueOf(row.get("recordNo")));
|
Date time;
|
try {
|
Object raw = row.get("recordedAt");
|
if (raw == null) raw = row.get("deviceTime");
|
if (!(raw instanceof Number number)) throw new IllegalArgumentException();
|
time = new Date(number.longValue());
|
} catch (RuntimeException ex) { throw new ServiceException("导入设备时间必须为毫秒时间戳"); }
|
values.put("server_received_at_utc", action.getCreatedAtUtc());
|
values.put("cycle_no", row.get("cycleNo"));
|
Map<String, Object> metrics = new LinkedHashMap<>();
|
columns(action.getDataType()).keySet().forEach(key -> { if (row.containsKey(key)) metrics.put(key, row.get(key)); });
|
if (!metrics.isEmpty()) values.putAll(editableValues(action.getDataType(), metrics));
|
mergeStepExtension(action.getDataType(), null, row, values);
|
if (!"CYCLE".equals(action.getDataType())) { values.put("step_no", row.get("stepNo")); values.put("step_name", row.get("stepName")); }
|
if ("REALTIME".equals(action.getDataType()))
|
{
|
values.put("cabinet_sequence_id", row.get("sequenceId"));
|
values.put("capture_slot_utc", time);
|
values.put("cabinet_device_time_utc", time);
|
values.put("cabinet_device_time_raw", time.toInstant().toString());
|
values.put("cabinet_adapter_timezone_id", "UTC");
|
}
|
else
|
{
|
values.put("dedupe_key", "import:" + UUID.randomUUID());
|
values.put("device_time_utc", time);
|
values.put("device_time_raw", time.toInstant().toString());
|
values.put("adapter_timezone_id", "UTC");
|
}
|
try { values.put("content_sha256", MessageDigest.getInstance("SHA-256").digest(JSON.toJSONBytes(row))); }
|
catch (Exception ex) { throw new IllegalStateException(ex); }
|
return values;
|
}
|
}
|
