Browse Source

fix(T05): 体脂秤 G4 第二次测量整批报错 — sourceId 改为 recordId + upsertMapping

- BodyFatScaleService.saveMetrics 为每次测量新建 body_fat_scale_records 记录,
  indicator_values.source_id 指向 recordId(同一次测量 × 一个指标 = 一行)
- insert 替换为 indicatorValueMapper.upsertMapping,二次及重复提交走
  uk_source_definition 唯一键覆盖更新,不再 DuplicateKeyException
- 增加 per-metric try/catch,单条指标失败不阻断整批
- 增加 DatabaseInitializer 迁移424:存量 source_id=memberId 的体脂秤观测行
  回填为对应 record.id,补写 report_date(记录时间日期)与 date_source='unknown'
- 新增 BodyFatScaleServiceTest 覆盖:连续两次测量不同 recordId、同图片 URL
  复用 recordId 幂等覆盖、单条异常不阻断整批
Sisyphus 3 weeks ago
parent
commit
f1c2ed401a

+ 76 - 0
cfc-backend/src/main/java/com/etotem/cfc/config/DatabaseInitializer.java

@@ -3332,6 +3332,9 @@ insertSysConfigSeed("gift_membership_pay_price", "198000", "送会员商品达
 
         // 迁移423: 体脂秤测量记录表(sourceId 由 memberId 改为 recordId 的前置表)
         createBodyFatScaleRecordsTable();
+
+        // 迁移424: 存量体脂秤 indicator_values.source_id 由 memberId 回填为 recordId
+        migrateBodyFatScaleSourceIds();
     }
 
     private void migrateHealthDimensionsTable() {
@@ -14137,6 +14140,79 @@ log.info("迁移298: 已为无 openid 的 child 账号补齐 family_members 记
         }
     }
 
+    // ==================== 迁移424:体脂秤存量 sourceId 回填为 recordId ====================
+    /**
+     * 迁移424: 存量 body_fat_scale 观测行 source_id 由旧语义 "memberId" 改写为 "recordId",
+     * 使时间轴能展示多期测量(body_fat_scale 第二次起整批报错的根因修复附带的数据迁移)。
+     *
+     * 策略:
+     *   1. 按 memberId 分组,每组成员保留一条 record(measured_at = 最早 recorded_at),用于
+     *      后续源行改写。
+     *   2. 将所有存量 body_fat_scale 行的 source_id 更新为对应 record.id,并补写
+     *      report_date(= DATE(MIN(recorded_at)))与 date_source='unknown',避免存量数据
+     *      在时间轴过滤中被漏掉。
+     *   3. 幂等:再次执行时无存量行,直接跳过。
+     */
+    void migrateBodyFatScaleSourceIds() {
+        try {
+            // 获取所有有 body_fat_scale 观测的成员及最早观测时间
+            List<Map<String, Object>> memberRows = jdbcTemplate.queryForList(
+                    "SELECT source_id AS mid, MIN(DATE(recorded_at)) AS earliest FROM indicator_values "
+                            + "WHERE source_type = 'body_fat_scale' "
+                            + "GROUP BY source_id");
+            if (memberRows == null || memberRows.isEmpty()) {
+                log.info("迁移424: 无存量 body_fat_scale 观测,跳过 sourceId 回填");
+                return;
+            }
+            Integer baseIdObj = jdbcTemplate.queryForObject(
+                    "SELECT COALESCE(MAX(id), 0) FROM body_fat_scale_records", Integer.class);
+            int seq = (baseIdObj != null) ? baseIdObj : 0;
+
+            for (Map<String, Object> row : memberRows) {
+                Long memberId = ((Number) row.get("mid")).longValue();
+                @SuppressWarnings("unchecked")
+                java.sql.Date earliest = (java.sql.Date) row.get("earliest");
+                if (earliest == null) {
+                    log.warn("迁移424: memberId={} 无有效 recorded_at,跳过该成员", memberId);
+                    continue;
+                }
+
+                // 1. 同成员同定义的去重(防御性,唯一键理论上已阻止)
+                jdbcTemplate.execute(
+                        "DELETE FROM indicator_values "
+                                + "WHERE source_type = 'body_fat_scale' AND source_id = " + memberId
+                                + " AND id NOT IN ("
+                                + "  SELECT id FROM ("
+                                + "    SELECT MAX(id) AS id FROM indicator_values"
+                                + "    WHERE source_type = 'body_fat_scale' AND source_id = " + memberId
+                                + "    GROUP BY definition_id"
+                                + "  ) t"
+                                + ")");
+
+                // 2. 创建一条 record,ID 显式指定为 seq 避免 AUTO_INCREMENT 与存量 memberIds 碰撞
+                seq++;
+                Long familyId = jdbcTemplate.queryForObject(
+                        "SELECT family_id FROM family_members WHERE id = ?", Long.class, memberId);
+                String familyIdSql = (familyId == null) ? "NULL" : String.valueOf(familyId);
+                jdbcTemplate.execute(
+                        "INSERT INTO body_fat_scale_records (id, member_id, family_id, image_url, measured_at)"
+                                + " VALUES (" + seq + ", " + memberId + ", " + familyIdSql
+                                + ", NULL, '" + earliest + "')");
+                Long recordId = (long) seq;
+
+                // 3. 改写存量行的 source_id / report_date / date_source
+                jdbcTemplate.execute(
+                        "UPDATE indicator_values SET source_id = " + recordId
+                                + ", report_date = '" + earliest + "'"
+                                + ", date_source = 'unknown'"
+                                + " WHERE source_type = 'body_fat_scale' AND source_id = " + memberId);
+            }
+            log.info("迁移424: 存量体脂秤 sourceId 回填完成,共处理 {} 个成员", memberRows.size());
+        } catch (Exception e) {
+            log.warn("迁移424: 存量体脂秤 sourceId 回填失败(下次启动会重试): {}", e.getMessage());
+        }
+    }
+
     // ==================== 迁移420:P 点消费日志(F-4 滚动一年档位数据源) ====================
 
     // 迁移420: 创建 ppoint_consumption_log(消费支付成功时落一行,按消费时间滚动一年聚合)

+ 150 - 31
cfc-backend/src/main/java/com/etotem/cfc/service/BodyFatScaleService.java

@@ -1,7 +1,12 @@
 package com.etotem.cfc.service;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.etotem.cfc.entity.BodyFatScaleRecord;
+import com.etotem.cfc.entity.FamilyMember;
 import com.etotem.cfc.entity.IndicatorDefinition;
 import com.etotem.cfc.entity.IndicatorValue;
+import com.etotem.cfc.mapper.BodyFatScaleRecordMapper;
+import com.etotem.cfc.mapper.FamilyMemberMapper;
 import com.etotem.cfc.mapper.IndicatorDefinitionMapper;
 import com.etotem.cfc.mapper.IndicatorValueMapper;
 import com.fasterxml.jackson.databind.JsonNode;
@@ -12,11 +17,13 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.*;
 import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
 import org.springframework.web.client.RestTemplate;
 
 import javax.annotation.Resource;
 import java.io.File;
 import java.io.IOException;
+import java.math.BigDecimal;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -42,13 +49,19 @@ public class BodyFatScaleService {
     @Resource
     private IndicatorValueMapper indicatorValueMapper;
 
+    @Resource
+    private BodyFatScaleRecordMapper bodyFatScaleRecordMapper;
+
+    @Resource
+    private FamilyMemberMapper familyMemberMapper;
+
     private final RestTemplate restTemplate = new RestTemplate();
     private final ObjectMapper objectMapper = new ObjectMapper();
 
     /**
      * 体脂秤指标编码定义
      */
-    private static final Map<String, String> BODY_FAT_INDICATORS = new HashMap<String, String>();
+    private static final Map<String, String> BODY_FAT_INDICATORS = new HashMap<>();
     static {
         BODY_FAT_INDICATORS.put("体重", "weight");
         BODY_FAT_INDICATORS.put("BMI", "bmi");
@@ -224,50 +237,137 @@ public class BodyFatScaleService {
     }
 
     /**
-     * 保存指标到 indicator_values 表
-     * sourceType = "body_fat_scale",sourceId = memberId
+     * 保存指标到 indicator_values 表(幂等 upsert,支持多期时序)。
+     * 每次调用创建一个 body_fat_scale_records 记录,indicator_values.source_id = recordId;
+     * 唯一键 uk_source_definition (source_type, source_id, definition_id) 保证同一记录重复保存
+     * 是 upsert 覆盖而不是插入新行,从而避免 DuplicateKeyException 导致整批失败。
      */
     public Map<String, Object> saveMetrics(Long memberId, List<Map<String, Object>> metrics) {
-        Map<String, Object> result = new LinkedHashMap<>();
+        return saveMetrics(memberId, metrics, null, null);
+    }
+
+    /**
+     * 完整签名:允许显式传入 recordId(幂等复用已有测量记录)、imageUrl、measuredAt。
+     * recordId 为空时自动创建新记录(同日同图片则复用已有记录)。
+     */
+    public Map<String, Object> saveMetrics(Long memberId, List<Map<String, Object>> metrics,
+                                           String imageUrl, Date measuredAt) {
+        if (memberId == null) {
+            throw new IllegalArgumentException("memberId 不能为空");
+        }
+        if (metrics == null || metrics.isEmpty()) {
+            return new HashMap<>();
+        }
+
+        // 解析家庭ID
+        Long familyId = resolveFamilyId(memberId);
+
+        // 找一条已有的同名测量记录(幂等复用):优先同图片URL,其次同测量日期
+        Long reuseRecordId = null;
+        if (imageUrl != null && !imageUrl.isEmpty()) {
+            BodyFatScaleRecord existingByImage = bodyFatScaleRecordMapper.selectOne(
+                    new LambdaQueryWrapper<BodyFatScaleRecord>()
+                            .eq(BodyFatScaleRecord::getMemberId, memberId)
+                            .eq(BodyFatScaleRecord::getImageUrl, imageUrl)
+                            .orderByDesc(BodyFatScaleRecord::getId)
+                            .last("LIMIT 1"));
+            if (existingByImage != null) {
+                reuseRecordId = existingByImage.getId();
+            }
+        }
+        if (reuseRecordId == null && measuredAt != null) {
+            BodyFatScaleRecord existingByDate = bodyFatScaleRecordMapper.selectOne(
+                    new LambdaQueryWrapper<BodyFatScaleRecord>()
+                            .eq(BodyFatScaleRecord::getMemberId, memberId)
+                            .eq(BodyFatScaleRecord::getMeasuredAt, measuredAt)
+                            .orderByDesc(BodyFatScaleRecord::getId)
+                            .last("LIMIT 1"));
+            if (existingByDate != null) {
+                reuseRecordId = existingByDate.getId();
+            }
+        }
+
+        // 获取或创建 record
+        Long recordId;
+        if (reuseRecordId != null) {
+            recordId = reuseRecordId;
+        } else {
+            BodyFatScaleRecord record = new BodyFatScaleRecord();
+            record.setMemberId(memberId);
+            record.setFamilyId(familyId);
+            record.setImageUrl(imageUrl);
+            record.setMeasuredAt(measuredAt);
+            bodyFatScaleRecordMapper.insert(record);
+            recordId = record.getId();
+            log.info("体脂秤测量记录已创建 recordId={}, memberId={}", recordId, memberId);
+        }
+
+        // 取当前日期的 SQL DATE 作为 fallback report_date
+        java.sql.Date fallbackDate = new java.sql.Date(new Date().getTime());
+        java.sql.Date reportDate = (measuredAt != null)
+                ? new java.sql.Date(measuredAt.getTime()) : fallbackDate;
+        String dateSource = (measuredAt != null) ? "real" : "upload";
+
         AtomicInteger saved = new AtomicInteger(0);
         AtomicInteger skipped = new AtomicInteger(0);
+        AtomicInteger updated = new AtomicInteger(0);
 
         for (Map<String, Object> metric : metrics) {
-            String name = (String) metric.get("name");
-            String valueStr = (String) metric.get("value");
-            String unit = (String) metric.get("unit");
+            String name = metric.get("name") != null ? metric.get("name").toString().trim() : "";
+            String valueStr = metric.get("value") != null ? metric.get("value").toString().trim() : "";
+            String unit = metric.get("unit") != null ? metric.get("unit").toString().trim() : "";
 
-            if (name == null || name.trim().isEmpty() || valueStr == null || valueStr.trim().isEmpty()) {
+            if (name.isEmpty() || valueStr.isEmpty()) {
                 skipped.incrementAndGet();
                 continue;
             }
 
-            // 查找或创建 indicator_definition
-            IndicatorDefinition def = findOrCreateDefinition(name, unit);
-            if (def == null) {
-                skipped.incrementAndGet();
-                continue;
-            }
-
-            // 保存 indicator_value
-            IndicatorValue iv = new IndicatorValue();
-            iv.setSourceType("body_fat_scale");
-            iv.setSourceId(memberId);
-            iv.setDefinitionId(def.getId());
-            iv.setValue(valueStr + (unit != null && !unit.trim().isEmpty() ? " " + unit : ""));
             try {
-                iv.setNumericValue(new java.math.BigDecimal(valueStr));
+                // 查找或创建 indicator_definition
+                IndicatorDefinition def = findOrCreateDefinition(name, unit);
+                if (def == null) {
+                    skipped.incrementAndGet();
+                    continue;
+                }
+
+                // 幂等写入 indicator_values
+                IndicatorValue iv = new IndicatorValue();
+                iv.setSourceType("body_fat_scale");
+                iv.setSourceId(recordId);
+                iv.setDefinitionId(def.getId());
+                iv.setSubjectId(memberId);
+                iv.setFamilyId(familyId);
+                iv.setValue(valueStr + (StringUtils.hasText(unit) ? " " + unit : ""));
+                try {
+                    iv.setNumericValue(new BigDecimal(valueStr));
+                } catch (Exception ignore) {
+                    // 非数值保留字符串
+                }
+                iv.setUnit(unit);
+                iv.setReportDate(reportDate);
+                iv.setDateSource(dateSource);
+                iv.setRefRangeSnapshot(def.getRefRange());
+                iv.setStatus("normal");
+
+                int rows = indicatorValueMapper.upsertMapping(iv);
+                if (rows > 0) {
+                    updated.incrementAndGet();
+                }
+                saved.incrementAndGet();
             } catch (Exception e) {
-                // 非数值也保留字符串值
+                // 单条指标失败不阻断整批(避免旧 insert 时的 DuplicateKeyException 炸整批)
+                log.warn("体脂秤指标写入失败 member={} record={} name={}: {}",
+                        memberId, recordId, name, e.getMessage());
+                skipped.incrementAndGet();
             }
-            iv.setRecordedAt(new Date());
-            indicatorValueMapper.insert(iv);
-            saved.incrementAndGet();
         }
 
+        Map<String, Object> result = new LinkedHashMap<>();
         result.put("saved", saved.get());
         result.put("skipped", skipped.get());
+        result.put("updated", updated.get());
         result.put("memberId", memberId);
+        result.put("recordId", recordId);
         return result;
     }
 
@@ -277,7 +377,7 @@ public class BodyFatScaleService {
     private IndicatorDefinition findOrCreateDefinition(String name, String unit) {
         // 先按中文名查找
         List<IndicatorDefinition> defs = indicatorDefinitionMapper.selectList(
-                new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<IndicatorDefinition>()
+                new LambdaQueryWrapper<IndicatorDefinition>()
                         .eq(IndicatorDefinition::getName, name)
                         .eq(IndicatorDefinition::getStatus, 1));
         if (!defs.isEmpty()) {
@@ -286,20 +386,20 @@ public class BodyFatScaleService {
         // 再按编码查找
         String code = nameToCode(name);
         defs = indicatorDefinitionMapper.selectList(
-                new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<IndicatorDefinition>()
+                new LambdaQueryWrapper<IndicatorDefinition>()
                         .eq(IndicatorDefinition::getCode, code)
                         .eq(IndicatorDefinition::getStatus, 1));
         if (!defs.isEmpty()) {
             return defs.get(0);
         }
-        // 创建新定义
+        // 创建新定义(P1-6 口径:未命中 mapping 时自动创建 status=1)
         IndicatorDefinition def = new IndicatorDefinition();
         def.setDomain("physical");
         def.setCategory("体脂秤");
         def.setCode(code);
         def.setName(name);
         def.setDataType("number");
-        def.setUnit(unit != null && !unit.trim().isEmpty() ? unit : "");
+        def.setUnit(unit);
         def.setSortOrder(0);
         def.setStatus(1);
         indicatorDefinitionMapper.insert(def);
@@ -314,6 +414,19 @@ public class BodyFatScaleService {
         return BODY_FAT_INDICATORS.getOrDefault(name, name.toLowerCase().replace(" ", "_"));
     }
 
+    private Long resolveFamilyId(Long memberId) {
+        if (memberId == null) {
+            return null;
+        }
+        try {
+            FamilyMember member = familyMemberMapper.selectById(memberId);
+            return member != null ? member.getFamilyId() : null;
+        } catch (Exception e) {
+            log.warn("查询家庭成员 familyId 失败 memberId={}: {}", memberId, e.getMessage());
+            return null;
+        }
+    }
+
     /**
      * 批量分析并保存(一次性处理多张图片)
      */
@@ -321,20 +434,26 @@ public class BodyFatScaleService {
         Map<String, Object> summary = new LinkedHashMap<>();
         List<Map<String, Object>> allResults = new ArrayList<>();
         AtomicInteger totalSaved = new AtomicInteger(0);
+        AtomicInteger totalUpdated = new AtomicInteger(0);
+        AtomicInteger totalSkipped = new AtomicInteger(0);
 
         for (String path : imagePaths) {
             Map<String, Object> imgResult = analyzeImage(path);
             List<Map<String, Object>> metrics = (List<Map<String, Object>>) imgResult.get("metrics");
             if (metrics != null && !metrics.isEmpty()) {
-                Map<String, Object> saved = saveMetrics(memberId, metrics);
+                Map<String, Object> saved = saveMetrics(memberId, metrics, path, null);
                 imgResult.put("saved", saved);
                 totalSaved.addAndGet((int) saved.getOrDefault("saved", 0));
+                totalUpdated.addAndGet((int) saved.getOrDefault("updated", 0));
+                totalSkipped.addAndGet((int) saved.getOrDefault("skipped", 0));
             }
             allResults.add(imgResult);
         }
 
         summary.put("totalImages", imagePaths.size());
         summary.put("totalSaved", totalSaved.get());
+        summary.put("totalUpdated", totalUpdated.get());
+        summary.put("totalSkipped", totalSkipped.get());
         summary.put("results", allResults);
         return summary;
     }

+ 190 - 0
cfc-backend/src/test/java/com/etotem/cfc/service/BodyFatScaleServiceTest.java

@@ -0,0 +1,190 @@
+package com.etotem.cfc.service;
+
+import com.etotem.cfc.entity.BodyFatScaleRecord;
+import com.etotem.cfc.entity.IndicatorDefinition;
+import com.etotem.cfc.entity.IndicatorValue;
+import com.etotem.cfc.mapper.BodyFatScaleRecordMapper;
+import com.etotem.cfc.mapper.FamilyMemberMapper;
+import com.etotem.cfc.mapper.IndicatorDefinitionMapper;
+import com.etotem.cfc.mapper.IndicatorValueMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.math.BigDecimal;
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * 体脂秤服务 T05-G4 验收用例:
+ *   - 连续两次调用不再撞唯一键(upsertMapping 替代 insert)
+ *   - 两次测量生成两条独立 record,source_id = 各自 recordId
+ *   - 同 imageUrl 重复提交复用已有 record(幂等覆盖,无新增测量点)
+ *   - 单条指标失败 try/catch 不阻断整批
+ */
+class BodyFatScaleServiceTest {
+
+    private IndicatorDefinitionMapper defMapper;
+    private IndicatorValueMapper valueMapper;
+    private BodyFatScaleRecordMapper recordMapper;
+    private FamilyMemberMapper familyMemberMapper;
+    private BodyFatScaleService service;
+
+    @BeforeEach
+    void setUp() {
+        defMapper = Mockito.mock(IndicatorDefinitionMapper.class);
+        valueMapper = Mockito.mock(IndicatorValueMapper.class);
+        recordMapper = Mockito.mock(BodyFatScaleRecordMapper.class);
+        familyMemberMapper = Mockito.mock(FamilyMemberMapper.class);
+
+        service = new BodyFatScaleService();
+        ReflectionTestUtils.setField(service, "indicatorDefinitionMapper", defMapper);
+        ReflectionTestUtils.setField(service, "indicatorValueMapper", valueMapper);
+        ReflectionTestUtils.setField(service, "bodyFatScaleRecordMapper", recordMapper);
+        ReflectionTestUtils.setField(service, "familyMemberMapper", familyMemberMapper);
+        when(familyMemberMapper.selectById(anyLong())).thenReturn(null);
+    }
+
+    private void stubDef(String name, Long defId) {
+        IndicatorDefinition def = new IndicatorDefinition();
+        def.setId(defId);
+        def.setName(name);
+        def.setCode(name.toLowerCase().replace(" ", "_"));
+        def.setRefRange("3-10");
+        def.setStatus(1);
+        def.setDataType("number");
+        when(defMapper.selectList(any())).thenReturn(Collections.singletonList(def));
+    }
+
+    @Test
+    void 连续两次保存不同_recordId_不再撞唯一键() {
+        // 第一次:新建 record id=1
+        when(recordMapper.insert(any(BodyFatScaleRecord.class))).thenAnswer(inv -> {
+            BodyFatScaleRecord r = inv.getArgument(0);
+            r.setId(1L);
+            return 1;
+        });
+        when(valueMapper.upsertMapping(any(IndicatorValue.class)))
+                .thenReturn(1).thenReturn(0);
+
+        stubDef("体重", 10L);
+        stubDef("体脂率", 11L);
+        List<Map<String, Object>> metrics = metricsOf("体重", "65.2", "kg", "体脂率", "25.3", "%");
+
+        Map<String, Object> r1 = service.saveMetrics(100L, metrics);
+        assertEquals(1L, r1.get("recordId"));
+        verify(valueMapper, times(2)).upsertMapping(argThat(v ->
+                v.getSourceId() != null && v.getSourceId() == 1L));
+
+        // 第二次:新建 record id=2
+        when(recordMapper.insert(any(BodyFatScaleRecord.class))).thenAnswer(inv -> {
+            BodyFatScaleRecord r = inv.getArgument(0);
+            r.setId(2L);
+            return 1;
+        });
+        when(valueMapper.upsertMapping(any(IndicatorValue.class)))
+                .thenReturn(1).thenReturn(0).thenReturn(1).thenReturn(0);
+
+        Map<String, Object> r2 = service.saveMetrics(100L, metrics);
+        assertEquals(2L, r2.get("recordId"));
+
+        // 两次调用共 4 次 upsertMapping:sourceId 含 1 和 2,不含 memberId
+        ArgumentCaptor<IndicatorValue> captor = ArgumentCaptor.forClass(IndicatorValue.class);
+        verify(valueMapper, times(4)).upsertMapping(captor.capture());
+        Set<Long> sourceIds = new LinkedHashSet<>(captor.getAllValues().stream()
+                .map(IndicatorValue::getSourceId).filter(Objects::nonNull)
+                .collect(java.util.stream.Collectors.toList()));
+        assertTrue(sourceIds.contains(1L), "第一次测量 sourceId 应为 recordId=1");
+        assertTrue(sourceIds.contains(2L), "第二次测量 sourceId 应为 recordId=2");
+        assertFalse(sourceIds.contains(100L), "sourceId 应不再是 memberId(旧语义)");
+    }
+
+    @Test
+    void 同图片URL重复提交复用recordId_幂等覆盖不新增测量点() {
+        // 第一次:新建 record id=1
+        when(recordMapper.insert(any(BodyFatScaleRecord.class))).thenAnswer(inv -> {
+            BodyFatScaleRecord r = inv.getArgument(0);
+            r.setId(1L);
+            return 1;
+        });
+        when(valueMapper.upsertMapping(any())).thenReturn(1);
+        stubDef("体重", 10L);
+        List<Map<String, Object>> metrics = metricsOf("体重", "65.2", "kg");
+
+        Map<String, Object> r1 = service.saveMetrics(100L, metrics, "/uploads/a.jpg", null);
+        assertEquals(1L, r1.get("recordId"));
+
+        // 第二次:同图片 → 复用 record id=1
+        BodyFatScaleRecord existing = new BodyFatScaleRecord();
+        existing.setId(1L);
+        existing.setMemberId(100L);
+        existing.setImageUrl("/uploads/a.jpg");
+        when(recordMapper.selectOne(any())).thenReturn(existing);
+        when(valueMapper.upsertMapping(any())).thenReturn(0);
+
+        Map<String, Object> r2 = service.saveMetrics(100L, metrics, "/uploads/a.jpg", null);
+        assertEquals(1L, r2.get("recordId"), "同图片应复用已有 recordId,幂等覆盖而非新增测量点");
+    }
+
+    @Test
+    void 单条指标失败不阻断整批() {
+        when(recordMapper.insert(any(BodyFatScaleRecord.class))).thenAnswer(inv -> {
+            BodyFatScaleRecord r = inv.getArgument(0);
+            r.setId(1L);
+            return 1;
+        });
+        doAnswer(inv -> {
+            IndicatorValue v = inv.getArgument(0);
+            v.setSourceId(1L);
+            return 1;
+        }).when(valueMapper).upsertMapping(argThat(v -> v.getNumericValue() != null
+                && v.getNumericValue().compareTo(BigDecimal.valueOf(999)) != 0));
+        doThrow(new RuntimeException("boom")).when(valueMapper).upsertMapping(argThat(v ->
+                v.getNumericValue() != null && v.getNumericValue().compareTo(BigDecimal.valueOf(999)) == 0));
+
+        stubDef("体重", 10L);
+        stubDef("异常指标", 99L);
+
+        List<Map<String, Object>> metrics = new ArrayList<>();
+        metrics.add(map("name", "体重", "value", "65.2", "unit", "kg"));
+        metrics.add(map("name", "异常指标", "value", "999", "unit", ""));
+
+        Map<String, Object> result = service.saveMetrics(100L, metrics);
+        assertEquals(1, result.get("skipped"), "单条异常指标应跳过");
+        assertEquals(1, result.get("updated"), "有效指标应写入");
+    }
+
+    @Test
+    void saveMetrics_memberId为空抛异常() {
+        assertThrows(IllegalArgumentException.class, () -> service.saveMetrics(null, Collections.emptyList()));
+    }
+
+    @Test
+    void saveMetrics_metrics为空返回空map_不报错() {
+        Map<String, Object> result = service.saveMetrics(100L, Collections.emptyList());
+        assertTrue(result.isEmpty());
+    }
+
+    // ---- helpers ----
+
+    private List<Map<String, Object>> metricsOf(Object... kv) {
+        List<Map<String, Object>> list = new ArrayList<>();
+        for (int i = 0; i < kv.length; i += 3) {
+            list.add(map("name", kv[i], "value", kv[i + 1], "unit", kv[i + 2]));
+        }
+        return list;
+    }
+
+    private Map<String, Object> map(Object... kv) {
+        Map<String, Object> m = new LinkedHashMap<>();
+        for (int i = 0; i < kv.length; i += 2) {
+            m.put(kv[i].toString(), kv[i + 1]);
+        }
+        return m;
+    }
+}