Skip to main content

macfly_core/
import.rs

1use std::path::Path;
2
3use serde_json::Value;
4
5use crate::error::MacflyError;
6use crate::html::html_to_clean_text;
7
8#[derive(Debug, Clone, PartialEq, Eq)]
9pub struct ImportedNote {
10    pub title: String,
11    pub body: String,
12    pub folder_override: Option<String>,
13}
14
15#[derive(Debug, Clone, PartialEq, Eq)]
16pub struct ImportedReminder {
17    pub title: String,
18    pub notes: Option<String>,
19    pub list_override: Option<String>,
20}
21
22/// Unterstützte Dateiendungen für `macfly notes import`.
23pub fn is_supported_note_file(path: &Path) -> bool {
24    matches!(
25        path.extension()
26            .and_then(|e| e.to_str())
27            .map(|s| s.to_ascii_lowercase())
28            .as_deref(),
29        Some("md" | "markdown" | "txt" | "html" | "htm" | "json" | "jsonl" | "csv")
30    )
31}
32
33/// Unterstützte Dateiendungen für `macfly reminders import`.
34pub fn is_supported_reminder_file(path: &Path) -> bool {
35    matches!(
36        path.extension()
37            .and_then(|e| e.to_str())
38            .map(|s| s.to_ascii_lowercase())
39            .as_deref(),
40        Some("md" | "markdown" | "txt" | "json" | "jsonl" | "csv")
41    )
42}
43
44/// Parst eine Datei anhand ihrer Endung (`.md`, `.txt`, `.html`, `.json`, `.jsonl`, `.csv`)
45/// in eine oder mehrere `ImportedNote`-Einträge.
46pub fn parse_notes_from_str(path: &Path, raw: &str) -> Result<Vec<ImportedNote>, MacflyError> {
47    let ext = path
48        .extension()
49        .and_then(|e| e.to_str())
50        .map(|s| s.to_ascii_lowercase())
51        .unwrap_or_default();
52    let fallback_title = path
53        .file_stem()
54        .and_then(|s| s.to_str())
55        .unwrap_or("Imported Note")
56        .to_string();
57
58    match ext.as_str() {
59        "json" => parse_notes_json(raw, &fallback_title),
60        "jsonl" => parse_notes_jsonl(raw, &fallback_title),
61        "csv" => parse_notes_csv(raw),
62        "html" | "htm" => Ok(vec![parse_note_html(raw, &fallback_title)]),
63        _ => Ok(vec![parse_note_markdown(raw, &fallback_title)]),
64    }
65}
66
67/// Parst eine Datei anhand ihrer Endung (`.md`, `.txt`, `.json`, `.jsonl`, `.csv`)
68/// in `ImportedReminder`-Einträge.
69pub fn parse_reminders_from_str(
70    path: &Path,
71    raw: &str,
72) -> Result<Vec<ImportedReminder>, MacflyError> {
73    let ext = path
74        .extension()
75        .and_then(|e| e.to_str())
76        .map(|s| s.to_ascii_lowercase())
77        .unwrap_or_default();
78
79    match ext.as_str() {
80        "json" => parse_reminders_json(raw),
81        "jsonl" => parse_reminders_jsonl(raw),
82        "csv" => parse_reminders_csv(raw),
83        "txt" => Ok(parse_reminders_txt(raw)),
84        _ => Ok(parse_reminders_markdown(raw)),
85    }
86}
87
88fn parse_note_markdown(raw: &str, fallback_title: &str) -> ImportedNote {
89    let mut body = raw.trim().to_string();
90    let mut fm_title: Option<String> = None;
91    let mut fm_folder: Option<String> = None;
92
93    if let Some(rest) = body.strip_prefix("---\n")
94        && let Some(end_idx) = rest.find("\n---\n")
95    {
96        let fm = &rest[..end_idx];
97        for line in fm.lines() {
98            if let Some(val) = line.strip_prefix("title:") {
99                let t = unquote(val);
100                if !t.is_empty() {
101                    fm_title = Some(t);
102                }
103            } else if let Some(val) = line.strip_prefix("folder:") {
104                let f = unquote(val);
105                if !f.is_empty() {
106                    fm_folder = Some(f);
107                }
108            }
109        }
110        body = rest[end_idx + 5..].trim().to_string();
111    }
112
113    if let Some(title) = fm_title {
114        return ImportedNote {
115            title,
116            body,
117            folder_override: fm_folder,
118        };
119    }
120
121    let mut lines = body.lines();
122    if let Some(first) = lines.next()
123        && let Some(heading) = first.strip_prefix("# ")
124    {
125        let title = heading.trim().to_string();
126        let remaining: String = lines.collect::<Vec<_>>().join("\n").trim().to_string();
127        if !title.is_empty() {
128            return ImportedNote {
129                title,
130                body: remaining,
131                folder_override: fm_folder,
132            };
133        }
134    }
135
136    ImportedNote {
137        title: fallback_title.to_string(),
138        body,
139        folder_override: fm_folder,
140    }
141}
142
143fn parse_note_html(raw: &str, fallback_title: &str) -> ImportedNote {
144    let title = extract_html_tag(raw, "title")
145        .or_else(|| extract_html_tag(raw, "h1"))
146        .map(|s| html_to_clean_text(&s))
147        .filter(|s| !s.is_empty())
148        .unwrap_or_else(|| fallback_title.to_string());
149    let body = html_to_clean_text(raw);
150    ImportedNote {
151        title,
152        body,
153        folder_override: None,
154    }
155}
156
157fn extract_html_tag(html: &str, tag: &str) -> Option<String> {
158    let lower = html.to_ascii_lowercase();
159    let open_pat = format!("<{tag}");
160    let close_pat = format!("</{tag}>");
161    let start_tag = lower.find(&open_pat)?;
162    let gt = lower[start_tag..].find('>')? + start_tag + 1;
163    let end_tag = lower[gt..].find(&close_pat)? + gt;
164    Some(html[gt..end_tag].trim().to_string())
165}
166
167fn parse_notes_json(raw: &str, fallback_title: &str) -> Result<Vec<ImportedNote>, MacflyError> {
168    let val: Value = serde_json::from_str(raw)?;
169    match &val {
170        Value::Array(items) => {
171            let mut out = Vec::new();
172            for (idx, item) in items.iter().enumerate() {
173                if let Some(note) = note_from_json_value(item, &format!("{fallback_title} #{}", idx + 1)) {
174                    out.push(note);
175                }
176            }
177            Ok(out)
178        }
179        Value::Object(map) => {
180            if let Some(Value::Array(items)) = map.get("notes").or_else(|| map.get("items")) {
181                let mut out = Vec::new();
182                for (idx, item) in items.iter().enumerate() {
183                    if let Some(note) =
184                        note_from_json_value(item, &format!("{fallback_title} #{}", idx + 1))
185                    {
186                        out.push(note);
187                    }
188                }
189                return Ok(out);
190            }
191            Ok(note_from_json_value(&val, fallback_title)
192                .into_iter()
193                .collect())
194        }
195        _ => Err(MacflyError::PlanError(
196            "JSON-Import erwartet ein Objekt oder ein Array von Notizen".to_string(),
197        )),
198    }
199}
200
201fn parse_notes_jsonl(raw: &str, fallback_title: &str) -> Result<Vec<ImportedNote>, MacflyError> {
202    let mut out = Vec::new();
203    for (idx, line) in raw.lines().enumerate() {
204        let trimmed = line.trim();
205        if trimmed.is_empty() {
206            continue;
207        }
208        let val: Value = serde_json::from_str(trimmed)?;
209        if let Some(note) = note_from_json_value(&val, &format!("{fallback_title} #{}", idx + 1)) {
210            out.push(note);
211        }
212    }
213    Ok(out)
214}
215
216fn note_from_json_value(val: &Value, fallback_title: &str) -> Option<ImportedNote> {
217    let obj = val.as_object()?;
218    let title = pick_str(obj, &["title", "name", "subject", "heading"])
219        .unwrap_or_else(|| fallback_title.to_string());
220    let body = pick_str(
221        obj,
222        &["body", "body_text", "content", "text", "markdown", "note", "description"],
223    )
224    .unwrap_or_default();
225    let folder_override = pick_str(obj, &["folder", "folder_path"]);
226    if title.is_empty() && body.is_empty() {
227        return None;
228    }
229    Some(ImportedNote {
230        title,
231        body,
232        folder_override,
233    })
234}
235
236fn parse_notes_csv(raw: &str) -> Result<Vec<ImportedNote>, MacflyError> {
237    let rows = parse_csv_rows(raw);
238    if rows.len() < 2 {
239        return Ok(Vec::new());
240    }
241    let headers: Vec<String> = rows[0].iter().map(|h| h.trim().to_ascii_lowercase()).collect();
242    let title_idx = find_col(&headers, &["title", "name", "subject", "heading"]).unwrap_or(0);
243    let body_idx = find_col(
244        &headers,
245        &["body", "content", "text", "notes", "note", "description", "markdown"],
246    )
247    .or(if headers.len() > 1 { Some(1) } else { None });
248    let folder_idx = find_col(&headers, &["folder", "folder_path", "category"]);
249
250    let mut out = Vec::new();
251    for row in rows.iter().skip(1) {
252        let title = row
253            .get(title_idx)
254            .map(|s| s.trim().to_string())
255            .unwrap_or_default();
256        let body = body_idx
257            .and_then(|i| row.get(i))
258            .map(|s| s.trim().to_string())
259            .unwrap_or_default();
260        let folder_override = folder_idx
261            .and_then(|i| row.get(i))
262            .map(|s| s.trim().to_string())
263            .filter(|s| !s.is_empty());
264
265        if title.is_empty() && body.is_empty() {
266            continue;
267        }
268        out.push(ImportedNote {
269            title: if title.is_empty() {
270                "Imported Note".to_string()
271            } else {
272                title
273            },
274            body,
275            folder_override,
276        });
277    }
278    Ok(out)
279}
280
281fn parse_reminders_markdown(raw: &str) -> Vec<ImportedReminder> {
282    let mut out = Vec::new();
283    for line in raw.lines() {
284        let trimmed = line.trim();
285        let item = trimmed
286            .strip_prefix("- [ ] ")
287            .or_else(|| trimmed.strip_prefix("* [ ] "));
288        if let Some(task) = item {
289            let title = task.trim();
290            if !title.is_empty() {
291                out.push(ImportedReminder {
292                    title: title.to_string(),
293                    notes: None,
294                    list_override: None,
295                });
296            }
297        }
298    }
299    out
300}
301
302fn parse_reminders_txt(raw: &str) -> Vec<ImportedReminder> {
303    let mut out = Vec::new();
304    for line in raw.lines() {
305        let trimmed = line.trim();
306        if trimmed.is_empty() || trimmed.starts_with('#') {
307            continue;
308        }
309        let clean = trimmed
310            .strip_prefix("- [ ] ")
311            .or_else(|| trimmed.strip_prefix("* [ ] "))
312            .or_else(|| trimmed.strip_prefix("- "))
313            .or_else(|| trimmed.strip_prefix("* "))
314            .unwrap_or(trimmed)
315            .trim();
316        if !clean.is_empty() {
317            out.push(ImportedReminder {
318                title: clean.to_string(),
319                notes: None,
320                list_override: None,
321            });
322        }
323    }
324    out
325}
326
327fn parse_reminders_json(raw: &str) -> Result<Vec<ImportedReminder>, MacflyError> {
328    let val: Value = serde_json::from_str(raw)?;
329    match &val {
330        Value::Array(items) => Ok(items.iter().filter_map(reminder_from_json_value).collect()),
331        Value::Object(map) => {
332            if let Some(Value::Array(items)) = map.get("reminders").or_else(|| map.get("tasks")).or_else(|| map.get("items")) {
333                return Ok(items.iter().filter_map(reminder_from_json_value).collect());
334            }
335            Ok(reminder_from_json_value(&val).into_iter().collect())
336        }
337        _ => Err(MacflyError::PlanError(
338            "JSON-Import für Reminders erwartet ein Array oder Objekt".to_string(),
339        )),
340    }
341}
342
343fn parse_reminders_jsonl(raw: &str) -> Result<Vec<ImportedReminder>, MacflyError> {
344    let mut out = Vec::new();
345    for line in raw.lines() {
346        let trimmed = line.trim();
347        if trimmed.is_empty() {
348            continue;
349        }
350        let val: Value = serde_json::from_str(trimmed)?;
351        if let Some(r) = reminder_from_json_value(&val) {
352            out.push(r);
353        }
354    }
355    Ok(out)
356}
357
358fn reminder_from_json_value(val: &Value) -> Option<ImportedReminder> {
359    if let Some(s) = val.as_str() {
360        let t = s.trim();
361        if t.is_empty() {
362            return None;
363        }
364        return Some(ImportedReminder {
365            title: t.to_string(),
366            notes: None,
367            list_override: None,
368        });
369    }
370    let obj = val.as_object()?;
371    let title = pick_str(obj, &["title", "name", "task", "content", "summary"])?;
372    if title.is_empty() {
373        return None;
374    }
375    let notes = pick_str(obj, &["notes", "body", "description", "comment"]);
376    let list_override = pick_str(obj, &["list", "project", "category"]);
377    Some(ImportedReminder {
378        title,
379        notes,
380        list_override,
381    })
382}
383
384fn parse_reminders_csv(raw: &str) -> Result<Vec<ImportedReminder>, MacflyError> {
385    let rows = parse_csv_rows(raw);
386    if rows.len() < 2 {
387        return Ok(Vec::new());
388    }
389    let headers: Vec<String> = rows[0].iter().map(|h| h.trim().to_ascii_lowercase()).collect();
390    let title_idx = find_col(&headers, &["title", "task", "name", "content", "summary"]).unwrap_or(0);
391    let notes_idx = find_col(&headers, &["notes", "description", "body", "comment"]);
392    let list_idx = find_col(&headers, &["list", "project", "category"]);
393
394    let mut out = Vec::new();
395    for row in rows.iter().skip(1) {
396        let title = row
397            .get(title_idx)
398            .map(|s| s.trim().to_string())
399            .unwrap_or_default();
400        if title.is_empty() {
401            continue;
402        }
403        let notes = notes_idx
404            .and_then(|i| row.get(i))
405            .map(|s| s.trim().to_string())
406            .filter(|s| !s.is_empty());
407        let list_override = list_idx
408            .and_then(|i| row.get(i))
409            .map(|s| s.trim().to_string())
410            .filter(|s| !s.is_empty());
411
412        out.push(ImportedReminder {
413            title,
414            notes,
415            list_override,
416        });
417    }
418    Ok(out)
419}
420
421/// Schlanker RFC-4180-CSV-Parser (unterstützt Anführungszeichen, `""`-Escapes und Zeilenumbrüche in Feldern).
422pub fn parse_csv_rows(input: &str) -> Vec<Vec<String>> {
423    let mut rows = Vec::new();
424    let mut row = Vec::new();
425    let mut field = String::new();
426    let mut in_quotes = false;
427    let mut chars = input.chars().peekable();
428
429    while let Some(c) = chars.next() {
430        if in_quotes {
431            if c == '"' {
432                if chars.peek() == Some(&'"') {
433                    chars.next();
434                    field.push('"');
435                } else {
436                    in_quotes = false;
437                }
438            } else {
439                field.push(c);
440            }
441        } else {
442            match c {
443                '"' => in_quotes = true,
444                ',' => {
445                    row.push(std::mem::take(&mut field));
446                }
447                '\r' => {
448                    if chars.peek() == Some(&'\n') {
449                        chars.next();
450                    }
451                    row.push(std::mem::take(&mut field));
452                    if row.iter().any(|cell| !cell.trim().is_empty()) {
453                        rows.push(std::mem::take(&mut row));
454                    } else {
455                        row.clear();
456                    }
457                }
458                '\n' => {
459                    row.push(std::mem::take(&mut field));
460                    if row.iter().any(|cell| !cell.trim().is_empty()) {
461                        rows.push(std::mem::take(&mut row));
462                    } else {
463                        row.clear();
464                    }
465                }
466                _ => field.push(c),
467            }
468        }
469    }
470
471    if !field.is_empty() || !row.is_empty() {
472        row.push(field);
473        if row.iter().any(|cell| !cell.trim().is_empty()) {
474            rows.push(row);
475        }
476    }
477
478    rows
479}
480
481fn find_col(headers: &[String], candidates: &[&str]) -> Option<usize> {
482    for cand in candidates {
483        if let Some(pos) = headers.iter().position(|h| h == cand) {
484            return Some(pos);
485        }
486    }
487    None
488}
489
490fn pick_str(map: &serde_json::Map<String, Value>, keys: &[&str]) -> Option<String> {
491    for k in keys {
492        if let Some(v) = map.get(*k).and_then(Value::as_str) {
493            let trimmed = v.trim();
494            if !trimmed.is_empty() {
495                return Some(trimmed.to_string());
496            }
497        }
498    }
499    None
500}
501
502fn unquote(val: &str) -> String {
503    val.trim().trim_matches('"').trim_matches('\'').trim().to_string()
504}
505
506#[cfg(test)]
507mod tests {
508    use super::*;
509
510    #[test]
511    fn parses_csv_json_jsonl_and_html_notes() {
512        let csv = "title,content,folder\n\"Alpha, 1\",\"Line 1\nLine 2\",10 · Work\nBeta,Hello,\n";
513        let notes = parse_notes_from_str(Path::new("export.csv"), csv).unwrap();
514        assert_eq!(notes.len(), 2);
515        assert_eq!(notes[0].title, "Alpha, 1");
516        assert_eq!(notes[0].body, "Line 1\nLine 2");
517        assert_eq!(notes[0].folder_override.as_deref(), Some("10 · Work"));
518
519        let jsonl = "{\"name\":\"N1\",\"text\":\"B1\"}\n{\"title\":\"N2\",\"body\":\"B2\"}\n";
520        let notes_jl = parse_notes_from_str(Path::new("notes.jsonl"), jsonl).unwrap();
521        assert_eq!(notes_jl.len(), 2);
522        assert_eq!(notes_jl[0].title, "N1");
523        assert_eq!(notes_jl[1].body, "B2");
524
525        let html = "<html><head><title>Evernote Clip</title></head><body><p>Saved paragraph</p></body></html>";
526        let notes_html = parse_notes_from_str(Path::new("clip.html"), html).unwrap();
527        assert_eq!(notes_html[0].title, "Evernote Clip");
528        assert!(notes_html[0].body.contains("Saved paragraph"));
529    }
530
531    #[test]
532    fn parses_csv_and_json_reminders() {
533        let csv = "Task,Description,Project\nSteuererklärung,Q4 Belege,Finanzen\n";
534        let rems = parse_reminders_from_str(Path::new("tasks.csv"), csv).unwrap();
535        assert_eq!(rems.len(), 1);
536        assert_eq!(rems[0].title, "Steuererklärung");
537        assert_eq!(rems[0].notes.as_deref(), Some("Q4 Belege"));
538        assert_eq!(rems[0].list_override.as_deref(), Some("Finanzen"));
539    }
540}