cashflow 0.1.1

A terminal-based expense tracker built with Ratatui
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use anyhow::{Context, Result};
use chrono::Local;
use std::fs;
use std::path::PathBuf;

use crate::model::{Budget, Currency, Expense};

fn data_dir() -> Result<PathBuf> {
    let home = dirs::home_dir().context("Could not determine home directory")?;
    let dir = home.join(".cashflow");
    if !dir.exists() {
        fs::create_dir_all(&dir).context("Could not create data directory")?;
    }
    Ok(dir)
}

fn expenses_path() -> Result<PathBuf> {
    Ok(data_dir()?.join("expenses.csv"))
}

fn budgets_path() -> Result<PathBuf> {
    Ok(data_dir()?.join("budgets.csv"))
}

pub fn load_expenses() -> Result<Vec<Expense>> {
    let path = expenses_path()?;
    if !path.exists() {
        return Ok(Vec::new());
    }

    let mut reader = csv::Reader::from_path(&path)
        .with_context(|| format!("Could not open {}", path.display()))?;

    let mut expenses = Vec::new();
    for result in reader.deserialize() {
        let expense: Expense = result.context("Could not parse expense record")?;
        expenses.push(expense);
    }

    Ok(expenses)
}

pub fn save_expenses(expenses: &[Expense]) -> Result<()> {
    let path = expenses_path()?;
    let mut writer = csv::Writer::from_path(&path)
        .with_context(|| format!("Could not write to {}", path.display()))?;

    for expense in expenses {
        writer
            .serialize(expense)
            .context("Could not serialize expense")?;
    }

    writer.flush().context("Could not flush CSV writer")?;
    Ok(())
}

pub fn load_budgets() -> Result<Vec<Budget>> {
    let path = budgets_path()?;
    if !path.exists() {
        return Ok(Vec::new());
    }

    let mut reader = csv::Reader::from_path(&path)
        .with_context(|| format!("Could not open {}", path.display()))?;

    let mut budgets = Vec::new();
    for result in reader.deserialize() {
        let budget: Budget = result.context("Could not parse budget record")?;
        budgets.push(budget);
    }

    Ok(budgets)
}

pub fn save_budgets(budgets: &[Budget]) -> Result<()> {
    let path = budgets_path()?;
    let mut writer = csv::Writer::from_path(&path)
        .with_context(|| format!("Could not write to {}", path.display()))?;

    for budget in budgets {
        writer
            .serialize(budget)
            .context("Could not serialize budget")?;
    }

    writer.flush().context("Could not flush CSV writer")?;
    Ok(())
}

pub fn export_expenses(expenses: &[Expense]) -> Result<String> {
    let dir = data_dir()?;
    let timestamp = Local::now().format("%Y%m%d_%H%M%S");
    let filename = format!("export_{}.csv", timestamp);
    let path = dir.join(&filename);

    let mut writer = csv::Writer::from_path(&path)
        .with_context(|| format!("Could not write export to {}", path.display()))?;

    for expense in expenses {
        writer
            .serialize(expense)
            .context("Could not serialize expense for export")?;
    }

    writer.flush().context("Could not flush export CSV writer")?;
    Ok(path.display().to_string())
}

pub fn import_csv(path: &str, existing: &mut Vec<Expense>) -> Result<usize> {
    let mut reader = csv::Reader::from_path(path)
        .with_context(|| format!("Could not open import file: {}", path))?;

    let mut next = next_id(existing);
    let mut count = 0;

    for result in reader.deserialize() {
        let mut expense: Expense = result.context("Could not parse import record")?;
        expense.id = next;
        next += 1;
        existing.push(expense);
        count += 1;
    }

    Ok(count)
}

pub fn next_id(expenses: &[Expense]) -> u64 {
    expenses.iter().map(|e| e.id).max().unwrap_or(0) + 1
}

fn config_path() -> Result<PathBuf> {
    Ok(data_dir()?.join("config"))
}

pub fn load_currency() -> Result<Currency> {
    let path = config_path()?;
    if !path.exists() {
        return Ok(Currency::default());
    }
    let content = fs::read_to_string(&path)
        .with_context(|| format!("Could not read config at {}", path.display()))?;
    let code = content.trim();
    Ok(Currency::from_code(code).unwrap_or_default())
}

pub fn save_currency(currency: &Currency) -> Result<()> {
    let path = config_path()?;
    fs::write(&path, currency.code())
        .with_context(|| format!("Could not write config to {}", path.display()))?;
    Ok(())
}