Skip to main content

wellfare_core/
parser.rs

1use crate::models::{HeartRateRecord, SleepRecord, StepRecord, WeightRecord};
2use chrono::{DateTime, FixedOffset, NaiveDateTime, TimeZone};
3use serde::Deserialize;
4
5/// Cleans CSV content.
6pub fn clean_csv_content(content: &str) -> String {
7    let mut lines = content.lines();
8    if let Some(first_line) = lines.next() {
9        let stripped = first_line.trim();
10        if stripped.starts_with("com.samsung.health.")
11            || stripped.starts_with("com.samsung.shealth.")
12        {
13            return lines.collect::<Vec<&str>>().join("\n");
14        }
15    }
16    content.to_string()
17}
18
19/// Parses a time offset in minutes.
20pub fn parse_time_offset_minutes(offset_str: &str) -> i32 {
21    let s = offset_str.trim();
22    if s.is_empty() {
23        return 0;
24    }
25
26    if let Ok(val) = s.parse::<i32>() {
27        return val;
28    }
29    if let Ok(val) = s.parse::<f64>() {
30        return val as i32;
31    }
32
33    if s.to_uppercase().starts_with("UTC") {
34        let clean = s[3..].trim();
35        if clean.is_empty() {
36            return 0;
37        }
38        let sign = if clean.starts_with('-') { -1 } else { 1 };
39        let numeric_part: String = clean.chars().filter(|c| c.is_ascii_digit()).collect();
40        if numeric_part.len() >= 2 {
41            if let Ok(hours) = numeric_part[0..2].parse::<i32>() {
42                let minutes = if numeric_part.len() >= 4 {
43                    numeric_part[2..4].parse::<i32>().unwrap_or(0)
44                } else {
45                    0
46                };
47                return sign * (hours * 60 + minutes);
48            }
49        }
50    }
51
52    0
53}
54
55/// Parses a Samsung datetime.
56pub fn parse_samsung_datetime(
57    value: &str,
58    offset_minutes: i32,
59) -> Result<DateTime<FixedOffset>, String> {
60    let value = value.trim();
61    let offset = FixedOffset::east_opt(offset_minutes * 60)
62        .ok_or_else(|| format!("Invalid timezone offset: {} minutes", offset_minutes))?;
63
64    if let Ok(val_f) = value.parse::<f64>() {
65        let val_i = val_f as i64;
66        if val_i > 1_000_000_000_000 {
67            let seconds = val_i / 1000;
68            let nanos = (val_i % 1000) * 1_000_000;
69            if let Some(utc_dt) = DateTime::from_timestamp(seconds, nanos as u32) {
70                return Ok(utc_dt.with_timezone(&offset));
71            }
72        } else if val_i > 1_000_000_000 {
73            if let Some(utc_dt) = DateTime::from_timestamp(val_i, 0) {
74                return Ok(utc_dt.with_timezone(&offset));
75            }
76        }
77    }
78
79    let formats = [
80        "%Y-%m-%d %H:%M:%S%.3f",
81        "%Y-%m-%d %H:%M:%S",
82        "%Y-%m-%d %H:%M",
83        "%Y/%m/%d %H:%M:%S",
84        "%Y/%m/%d %H:%M",
85    ];
86
87    for fmt in &formats {
88        if let Ok(naive) = NaiveDateTime::parse_from_str(value, fmt) {
89            if let Some(local_dt) = offset.from_local_datetime(&naive).single() {
90                return Ok(local_dt);
91            } else {
92                return Ok(DateTime::<FixedOffset>::from_naive_utc_and_offset(
93                    naive, offset,
94                ));
95            }
96        }
97    }
98
99    if let Ok(dt) = DateTime::parse_from_rfc3339(value) {
100        return Ok(dt.with_timezone(&offset));
101    }
102
103    Err(format!("Could not parse datetime: {}", value))
104}
105
106#[derive(Debug, Deserialize)]
107struct WeightCsvRow {
108    uuid: String,
109    start_time: String,
110    time_offset: Option<String>,
111    weight: f64,
112    body_fat: Option<f64>,
113    muscle_mass: Option<f64>,
114    body_water: Option<f64>,
115    skeletal_muscle: Option<f64>,
116    bmi: f64,
117}
118
119/// Parses  CSV.
120pub fn parse_weight_csv(content: &str) -> Result<Vec<WeightRecord>, String> {
121    let cleaned = clean_csv_content(content);
122    let mut rdr = csv::ReaderBuilder::new()
123        .flexible(true)
124        .trim(csv::Trim::All)
125        .from_reader(cleaned.as_bytes());
126
127    let mut records = Vec::new();
128    for result in rdr.deserialize::<WeightCsvRow>() {
129        let row = result.map_err(|e| format!("CSV deserialize error: {}", e))?;
130        let offset_str = row.time_offset.unwrap_or_default();
131        let offset = parse_time_offset_minutes(&offset_str);
132        let start_datetime = parse_samsung_datetime(&row.start_time, offset)?;
133
134        records.push(WeightRecord {
135            uuid: row.uuid,
136            weight: row.weight,
137            body_fat: row.body_fat,
138            muscle_mass: row.muscle_mass,
139            body_water: row.body_water,
140            skeletal_muscle: row.skeletal_muscle,
141            bmi: row.bmi,
142            start_datetime,
143        });
144    }
145    Ok(records)
146}
147
148#[derive(Debug, Deserialize)]
149struct SleepCsvRow {
150    uuid: String,
151    start_time: String,
152    end_time: String,
153    time_offset: Option<String>,
154    sleep_duration: f64,
155    efficiency: f64,
156    deep_sleep: Option<f64>,
157    rem_sleep: Option<f64>,
158    light_sleep: Option<f64>,
159    wake_up_count: Option<u32>,
160}
161
162/// Parses  CSV.
163pub fn parse_sleep_csv(content: &str) -> Result<Vec<SleepRecord>, String> {
164    let cleaned = clean_csv_content(content);
165    let mut rdr = csv::ReaderBuilder::new()
166        .flexible(true)
167        .trim(csv::Trim::All)
168        .from_reader(cleaned.as_bytes());
169
170    let mut records = Vec::new();
171    for result in rdr.deserialize::<SleepCsvRow>() {
172        let row = result.map_err(|e| format!("CSV deserialize error: {}", e))?;
173        let offset_str = row.time_offset.unwrap_or_default();
174        let offset = parse_time_offset_minutes(&offset_str);
175        let start_datetime = parse_samsung_datetime(&row.start_time, offset)?;
176        let end_datetime = parse_samsung_datetime(&row.end_time, offset)?;
177
178        records.push(SleepRecord {
179            uuid: row.uuid,
180            sleep_duration: row.sleep_duration,
181            efficiency: row.efficiency,
182            deep_sleep: row.deep_sleep,
183            rem_sleep: row.rem_sleep,
184            light_sleep: row.light_sleep,
185            wake_up_count: row.wake_up_count,
186            start_datetime,
187            end_datetime,
188        });
189    }
190    Ok(records)
191}
192
193#[derive(Debug, Deserialize)]
194struct HeartRateCsvRow {
195    uuid: String,
196    start_time: String,
197    time_offset: Option<String>,
198    heart_rate: u32,
199    min: Option<u32>,
200    max: Option<u32>,
201    heart_rate_zone: Option<String>,
202    binning_data: Option<String>,
203}
204
205/// Parses  CSV.
206pub fn parse_heart_rate_csv(content: &str) -> Result<Vec<HeartRateRecord>, String> {
207    let cleaned = clean_csv_content(content);
208    let mut rdr = csv::ReaderBuilder::new()
209        .flexible(true)
210        .trim(csv::Trim::All)
211        .from_reader(cleaned.as_bytes());
212
213    let mut records = Vec::new();
214    for result in rdr.deserialize::<HeartRateCsvRow>() {
215        let row = result.map_err(|e| format!("CSV deserialize error: {}", e))?;
216        let offset_str = row.time_offset.unwrap_or_default();
217        let offset = parse_time_offset_minutes(&offset_str);
218        let start_datetime = parse_samsung_datetime(&row.start_time, offset)?;
219
220        records.push(HeartRateRecord {
221            uuid: row.uuid,
222            heart_rate: row.heart_rate,
223            min: row.min,
224            max: row.max,
225            heart_rate_zone: row.heart_rate_zone,
226            binning_data: row.binning_data,
227            start_datetime,
228        });
229    }
230    Ok(records)
231}
232
233#[derive(Debug, Deserialize)]
234struct StepCsvRow {
235    uuid: String,
236    start_time: String,
237    end_time: String,
238    time_offset: Option<String>,
239    count: u32,
240    calorie: f64,
241    distance: f64,
242}
243
244/// Parses  CSV.
245pub fn parse_steps_csv(content: &str) -> Result<Vec<StepRecord>, String> {
246    let cleaned = clean_csv_content(content);
247    let mut rdr = csv::ReaderBuilder::new()
248        .flexible(true)
249        .trim(csv::Trim::All)
250        .from_reader(cleaned.as_bytes());
251
252    let mut records = Vec::new();
253    for result in rdr.deserialize::<StepCsvRow>() {
254        let row = result.map_err(|e| format!("CSV deserialize error: {}", e))?;
255        let offset_str = row.time_offset.unwrap_or_default();
256        let offset = parse_time_offset_minutes(&offset_str);
257        let start_datetime = parse_samsung_datetime(&row.start_time, offset)?;
258        let end_datetime = parse_samsung_datetime(&row.end_time, offset)?;
259
260        records.push(StepRecord {
261            uuid: row.uuid,
262            count: row.count,
263            calorie: row.calorie,
264            distance: row.distance,
265            start_datetime,
266            end_datetime,
267        });
268    }
269    Ok(records)
270}