Skip to main content

qualia_client_core/wellfair/
import_samsung.rs

1//! Samsung Health import — companion bundle (primary) and folder scan (dev fallback).
2
3use std::fs;
4use std::path::{Path, PathBuf};
5
6use serde::{Deserialize, Serialize};
7use sha2::{Digest, Sha256};
8use wellfare_core::companion_sync::CompanionHealthBundle;
9use wellfare_core::models::{HeartRateRecord, SleepRecord, StepRecord, WeightRecord};
10use wellfare_core::parser::{
11    parse_heart_rate_csv, parse_sleep_csv, parse_steps_csv, parse_weight_csv,
12};
13use wellfare_core::record::{EpistemicStatus, EvidenceType, RecordEnvelope, SensitivityClass};
14
15use super::api::WebizenHostApi;
16
17const QAPP_HEALTH: &str = "wellfair-health";
18
19#[derive(Debug, Clone)]
20pub struct EnvelopeWithSummary {
21    pub envelope: RecordEnvelope,
22    pub summary: Option<String>,
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
26pub struct SamsungFileReport {
27    pub path: String,
28    pub kind: String,
29    pub records: u32,
30    pub rejected: u32,
31}
32
33#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
34pub struct SamsungImportReport {
35    pub source: String,
36    pub files: Vec<SamsungFileReport>,
37    pub records_committed: usize,
38    pub records_skipped: usize,
39    pub errors: Vec<String>,
40    #[serde(default, skip_serializing_if = "Option::is_none")]
41    pub checkpoint_hash: Option<String>,
42    /// A durable, source-batch Q42 artifact written by the host after a successful import.
43    /// The historical type name remains for compatibility; the same report is used by the
44    /// vendor-neutral companion bundle path.
45    #[serde(default, skip_serializing_if = "Option::is_none")]
46    pub q42_artifact_path: Option<String>,
47}
48
49fn content_hash_hex(payload: &str) -> String {
50    hex::encode(Sha256::digest(payload.as_bytes()).as_slice())
51}
52
53fn envelope_from_parts(
54    id: &str,
55    owner_did: &str,
56    author_did: &str,
57    asserted_unix: u32,
58    payload_json: &str,
59) -> RecordEnvelope {
60    RecordEnvelope {
61        id: id.to_string(),
62        owner_did: owner_did.to_string(),
63        author_did: author_did.to_string(),
64        proxy_did: None,
65        epistemic_status: EpistemicStatus::Asserted,
66        evidence_type: EvidenceType::DeviceMeasured,
67        sensitivity: SensitivityClass::Restricted,
68        asserted_time_unix: asserted_unix,
69        asserted_instant: None,
70        valid_time_start_unix: Some(asserted_unix),
71        valid_time_start_instant: None,
72        valid_time_end_unix: None,
73        valid_time_end_instant: None,
74        predecessor_id: None,
75        blob_hash: Some(content_hash_hex(payload_json)),
76        tombstone: false,
77    }
78}
79
80fn weight_envelopes(
81    records: &[WeightRecord],
82    owner: &str,
83    author: &str,
84) -> Vec<EnvelopeWithSummary> {
85    records
86        .iter()
87        .filter_map(|r| {
88            let payload = serde_json::to_string(r).ok()?;
89            let id = format!("urn:wellfair:weight:{}", r.uuid);
90            let unix = r.start_datetime.timestamp().max(0) as u32;
91            let summary = serde_json::json!({
92                "weight_kg": r.weight,
93                "bmi": r.bmi,
94            })
95            .to_string();
96            Some(EnvelopeWithSummary {
97                envelope: envelope_from_parts(&id, owner, author, unix, &payload),
98                summary: Some(summary),
99            })
100        })
101        .collect()
102}
103
104fn sleep_envelopes(records: &[SleepRecord], owner: &str, author: &str) -> Vec<EnvelopeWithSummary> {
105    records
106        .iter()
107        .filter_map(|r| {
108            let payload = serde_json::to_string(r).ok()?;
109            let id = format!("urn:wellfair:sleep:{}", r.uuid);
110            let unix = r.start_datetime.timestamp().max(0) as u32;
111            let summary = serde_json::json!({
112                "duration_min": r.sleep_duration,
113                "efficiency": r.efficiency,
114                "deep_min": r.deep_sleep,
115                "rem_min": r.rem_sleep,
116                "light_min": r.light_sleep,
117            })
118            .to_string();
119            Some(EnvelopeWithSummary {
120                envelope: envelope_from_parts(&id, owner, author, unix, &payload),
121                summary: Some(summary),
122            })
123        })
124        .collect()
125}
126
127fn heart_rate_envelopes(
128    records: &[HeartRateRecord],
129    owner: &str,
130    author: &str,
131) -> Vec<EnvelopeWithSummary> {
132    records
133        .iter()
134        .filter_map(|r| {
135            let payload = serde_json::to_string(r).ok()?;
136            let id = format!("urn:wellfair:heart_rate:{}", r.uuid);
137            let unix = r.start_datetime.timestamp().max(0) as u32;
138            let summary = serde_json::json!({
139                "heart_rate": r.heart_rate,
140                "min": r.min,
141                "max": r.max,
142            })
143            .to_string();
144            Some(EnvelopeWithSummary {
145                envelope: envelope_from_parts(&id, owner, author, unix, &payload),
146                summary: Some(summary),
147            })
148        })
149        .collect()
150}
151
152fn steps_envelopes(records: &[StepRecord], owner: &str, author: &str) -> Vec<EnvelopeWithSummary> {
153    records
154        .iter()
155        .filter_map(|r| {
156            let payload = serde_json::to_string(r).ok()?;
157            let id = format!("urn:wellfair:steps:{}", r.uuid);
158            let unix = r.start_datetime.timestamp().max(0) as u32;
159            let summary = serde_json::json!({
160                "steps": r.count,
161                "distance_m": r.distance,
162            })
163            .to_string();
164            Some(EnvelopeWithSummary {
165                envelope: envelope_from_parts(&id, owner, author, unix, &payload),
166                summary: Some(summary),
167            })
168        })
169        .collect()
170}
171
172#[derive(Debug, Clone, Copy, PartialEq, Eq)]
173pub enum SamsungCsvKind {
174    Weight,
175    Sleep,
176    HeartRate,
177    Steps,
178    Unknown,
179}
180
181fn classify_samsung_csv(name: &str) -> SamsungCsvKind {
182    let lower = name.to_ascii_lowercase();
183    if lower.contains("weight") || lower.contains("body_composition") {
184        SamsungCsvKind::Weight
185    } else if lower.contains("sleep") {
186        SamsungCsvKind::Sleep
187    } else if lower.contains("heart") {
188        SamsungCsvKind::HeartRate
189    } else if lower.contains("step") || lower.contains("walk") {
190        SamsungCsvKind::Steps
191    } else {
192        SamsungCsvKind::Unknown
193    }
194}
195
196fn kind_label(kind: SamsungCsvKind) -> &'static str {
197    match kind {
198        SamsungCsvKind::Weight => "weight",
199        SamsungCsvKind::Sleep => "sleep",
200        SamsungCsvKind::HeartRate => "heart_rate",
201        SamsungCsvKind::Steps => "steps",
202        SamsungCsvKind::Unknown => "unknown",
203    }
204}
205
206/// Parse Samsung CSV content using filename heuristics (transport-neutral).
207pub fn parse_csv_named_content(
208    filename: &str,
209    content: &str,
210    owner_did: &str,
211    author_did: &str,
212) -> Result<(SamsungCsvKind, Vec<EnvelopeWithSummary>, u32), String> {
213    let kind = classify_samsung_csv(filename);
214    match kind {
215        SamsungCsvKind::Weight => {
216            let records = parse_weight_csv(content).map_err(|e| e.to_string())?;
217            Ok((kind, weight_envelopes(&records, owner_did, author_did), 0))
218        }
219        SamsungCsvKind::Sleep => {
220            let records = parse_sleep_csv(content).map_err(|e| e.to_string())?;
221            Ok((kind, sleep_envelopes(&records, owner_did, author_did), 0))
222        }
223        SamsungCsvKind::HeartRate => {
224            let records = parse_heart_rate_csv(content).map_err(|e| e.to_string())?;
225            Ok((
226                kind,
227                heart_rate_envelopes(&records, owner_did, author_did),
228                0,
229            ))
230        }
231        SamsungCsvKind::Steps => {
232            let records = parse_steps_csv(content).map_err(|e| e.to_string())?;
233            Ok((kind, steps_envelopes(&records, owner_did, author_did), 0))
234        }
235        SamsungCsvKind::Unknown => Ok((kind, Vec::new(), 0)),
236    }
237}
238
239fn parse_csv_file(
240    path: &Path,
241    owner_did: &str,
242    author_did: &str,
243) -> Result<(SamsungCsvKind, Vec<EnvelopeWithSummary>, u32), String> {
244    let content = fs::read_to_string(path).map_err(|e| format!("read {}: {e}", path.display()))?;
245    let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
246    parse_csv_named_content(name, &content, owner_did, author_did)
247}
248
249fn commit_envelopes(
250    host: &mut WebizenHostApi,
251    report: &mut SamsungImportReport,
252    path_label: &str,
253    kind: SamsungCsvKind,
254    envelopes: Vec<EnvelopeWithSummary>,
255    rejected: u32,
256) {
257    let mut committed = 0u32;
258    for item in envelopes {
259        match host.submit_record_with_summary(
260            QAPP_HEALTH,
261            item.envelope,
262            &report.source,
263            item.summary,
264        ) {
265            Ok(n) => {
266                report.records_committed += n;
267                committed += 1;
268            }
269            Err(e) => {
270                report.records_skipped += 1;
271                report.errors.push(e);
272            }
273        }
274    }
275    report.files.push(SamsungFileReport {
276        path: path_label.to_string(),
277        kind: kind_label(kind).to_string(),
278        records: committed,
279        rejected,
280    });
281}
282
283/// Primary path: ingest a companion bundle produced on the user's phone.
284pub fn ingest_companion_health_bundle(
285    host: &mut WebizenHostApi,
286    bundle: &CompanionHealthBundle,
287    owner_did: &str,
288    author_did: &str,
289) -> SamsungImportReport {
290    let mut report = SamsungImportReport {
291        source: format!("companion:{}", bundle.device_id),
292        files: Vec::new(),
293        records_committed: 0,
294        records_skipped: 0,
295        errors: Vec::new(),
296        checkpoint_hash: None,
297        q42_artifact_path: None,
298    };
299
300    if let Err(e) = bundle.validate() {
301        report.errors.push(e);
302        return report;
303    }
304
305    for file in &bundle.files {
306        match parse_csv_named_content(&file.filename, &file.csv_content, owner_did, author_did) {
307            Ok((kind, envelopes, rejected)) => {
308                commit_envelopes(host, &mut report, &file.filename, kind, envelopes, rejected);
309            }
310            Err(e) => {
311                report.errors.push(e);
312                report.files.push(SamsungFileReport {
313                    path: file.filename.clone(),
314                    kind: "error".into(),
315                    records: 0,
316                    rejected: 1,
317                });
318            }
319        }
320    }
321
322    report
323}
324
325/// Dev/testing fallback: scan a desktop folder for Samsung Health CSV exports.
326pub fn import_samsung_folder(
327    host: &mut WebizenHostApi,
328    folder: &Path,
329    owner_did: &str,
330    author_did: &str,
331) -> SamsungImportReport {
332    let mut report = SamsungImportReport {
333        source: format!("folder:{}", folder.display()),
334        files: Vec::new(),
335        records_committed: 0,
336        records_skipped: 0,
337        errors: Vec::new(),
338        checkpoint_hash: None,
339        q42_artifact_path: None,
340    };
341
342    if !folder.is_dir() {
343        report
344            .errors
345            .push(format!("Not a directory: {}", folder.display()));
346        return report;
347    }
348
349    let mut csv_paths: Vec<PathBuf> = Vec::new();
350    let entries = match fs::read_dir(folder) {
351        Ok(e) => e,
352        Err(e) => {
353            report.errors.push(format!("read_dir: {e}"));
354            return report;
355        }
356    };
357
358    for entry in entries.filter_map(Result::ok) {
359        let path = entry.path();
360        if path.extension().and_then(|e| e.to_str()) == Some("csv") {
361            csv_paths.push(path);
362        }
363    }
364    csv_paths.sort();
365
366    for path in csv_paths {
367        let label = path.display().to_string();
368        match parse_csv_file(&path, owner_did, author_did) {
369            Ok((kind, envelopes, rejected)) => {
370                commit_envelopes(host, &mut report, &label, kind, envelopes, rejected);
371            }
372            Err(e) => {
373                report.errors.push(e);
374                report.files.push(SamsungFileReport {
375                    path: label,
376                    kind: "error".into(),
377                    records: 0,
378                    rejected: 1,
379                });
380            }
381        }
382    }
383
384    report
385}
386
387#[cfg(test)]
388mod tests {
389    use super::*;
390    use std::io::Write;
391    use wellfare_core::companion_sync::{CompanionCsvFile, CompanionHealthBundle};
392
393    #[test]
394    fn classifies_samsung_csv_names() {
395        assert_eq!(
396            classify_samsung_csv("com.samsung.health.weight.20260101.csv"),
397            SamsungCsvKind::Weight
398        );
399        assert_eq!(classify_samsung_csv("sleep.csv"), SamsungCsvKind::Sleep);
400    }
401
402    #[test]
403    fn weight_csv_produces_envelopes() {
404        let dir = tempfile::tempdir().unwrap();
405        let csv = dir.path().join("weight.csv");
406        let mut f = fs::File::create(&csv).unwrap();
407        writeln!(
408            f,
409            "uuid,start_time,end_time,time_offset,weight,body_fat,muscle_mass,body_water,skeletal_muscle,bmi"
410        )
411        .unwrap();
412        writeln!(
413            f,
414            "a1000001-0000-4000-8000-000000000001,1777632000000,1777632060000,60,72.0,18.5,32.1,55.2,30.5,23.1"
415        )
416        .unwrap();
417
418        let (kind, envelopes, _) = parse_csv_file(&csv, "did:wf:owner", "did:wf:owner").unwrap();
419        assert_eq!(kind, SamsungCsvKind::Weight);
420        assert_eq!(envelopes.len(), 1);
421        assert_eq!(
422            envelopes[0].envelope.evidence_type,
423            EvidenceType::DeviceMeasured
424        );
425    }
426
427    #[test]
428    fn companion_bundle_parses_named_content() {
429        let csv = "uuid,start_time,end_time,time_offset,weight,body_fat,muscle_mass,body_water,skeletal_muscle,bmi\n\
430                   a1000001-0000-4000-8000-000000000001,1777632000000,1777632060000,60,72.0,18.5,32.1,55.2,30.5,23.1\n";
431        let (kind, envelopes, _) =
432            parse_csv_named_content("weight.csv", csv, "did:wf:owner", "did:wf:owner").unwrap();
433        assert_eq!(kind, SamsungCsvKind::Weight);
434        assert_eq!(envelopes.len(), 1);
435
436        let bundle = CompanionHealthBundle::new(
437            "pixel-test",
438            1_700_000_000,
439            vec![CompanionCsvFile {
440                filename: "weight.csv".into(),
441                csv_content: csv.into(),
442            }],
443        );
444        assert!(bundle.validate().is_ok());
445    }
446}