jakob/rusty-petroleum
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Add invoice generator for fuel station transactions

Browse Source 
- Read CSV files from input/ directory
- Generate static HTML invoices grouped by customer and card
- Filter transactions to only include fleet customers
- Compact print-friendly layout with 2 decimal precision
This commit is contained in:
Jakob
2026-03-23 10:36:14 +01:00
parent d3b8828260
commit 650435e00c
6 changed files with 609 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
src/invoice_generator.rs Normal file
View File

@@ -0,0 +1,126 @@
use chrono::NaiveDateTime;
use csv::ReaderBuilder;
use std::collections::BTreeMap;
use std::fs;
use std::path::Path;
#[derive(Debug, Clone)]
pub struct Transaction {
pub date: NaiveDateTime,
pub batch_number: String,
pub amount: f64,
pub volume: f64,
pub price: f64,
pub quality: i32,
pub quality_name: String,
pub card_number: String,
pub card_type: String,
pub customer_number: String,
pub station: String,
pub terminal: String,
pub pump: String,
pub receipt: String,
pub card_report_group_number: String,
pub control_number: String,
}
#[derive(Debug, Clone)]
pub struct Batch {
pub filename: String,
pub transactions: Vec<Transaction>,
}
#[derive(Debug, Clone)]
pub struct Customer {
pub customer_number: String,
pub cards: BTreeMap<String, Vec<Transaction>>,
}
fn get_field(record: &csv::StringRecord, index: usize) -> &str {
record.get(index).unwrap_or("")
}
impl Transaction {
pub fn from_record(record: &csv::StringRecord) -> Option<Self> {
let date_str = get_field(record, 0);
let date = NaiveDateTime::parse_from_str(date_str, "%Y-%m-%d %H:%M:%S").ok()?;
Some(Transaction {
date,
batch_number: get_field(record, 1).to_string(),
amount: get_field(record, 2).parse().unwrap_or(0.0),
volume: get_field(record, 3).parse().unwrap_or(0.0),
price: get_field(record, 4).parse().unwrap_or(0.0),
quality: get_field(record, 5).parse().unwrap_or(0),
quality_name: get_field(record, 6).to_string(),
card_number: get_field(record, 7).to_string(),
card_type: get_field(record, 8).to_string(),
customer_number: get_field(record, 9).to_string(),
station: get_field(record, 10).to_string(),
terminal: get_field(record, 11).to_string(),
pump: get_field(record, 12).to_string(),
receipt: get_field(record, 13).to_string(),
card_report_group_number: get_field(record, 14).to_string(),
control_number: get_field(record, 15).to_string(),
})
}
}
pub fn read_csv_file(path: &Path) -> Result<Batch, Box<dyn std::error::Error>> {
let filename = path
.file_name()
.and_then(|n| n.to_str())
.unwrap_or("unknown")
.to_string();
let file = fs::File::open(path)?;
let mut rdr = ReaderBuilder::new()
.delimiter(b'\t')
.has_headers(true)
.flexible(true)
.from_reader(file);
let mut transactions = Vec::new();
for result in rdr.records() {
let record = result?;
if let Some(tx) = Transaction::from_record(&record) {
if tx.amount > 0.0 && !tx.customer_number.is_empty() {
transactions.push(tx);
}
}
}
transactions.sort_by(|a, b| a.date.cmp(&b.date));
Ok(Batch {
filename,
transactions,
})
}
pub fn group_by_customer(batches: &[Batch]) -> BTreeMap<String, Customer> {
let mut customers: BTreeMap<String, Customer> = BTreeMap::new();
for batch in batches {
for tx in &batch.transactions {
let customer = customers
.entry(tx.customer_number.clone())
.or_insert_with(|| Customer {
customer_number: tx.customer_number.clone(),
cards: BTreeMap::new(),
});
let card_txs = customer.cards.entry(tx.card_number.clone()).or_default();
card_txs.push(tx.clone());
}
}
for customer in customers.values_mut() {
for card_txs in customer.cards.values_mut() {
card_txs.sort_by(|a, b| a.date.cmp(&b.date));
}
}
customers
}

175
src/main.rs Normal file
View File

@@ -0,0 +1,175 @@
use askama::Template;
use chrono::Utc;
use std::fs;
use std::path::Path;
mod invoice_generator;
use invoice_generator::{group_by_customer, read_csv_file, Batch, Customer};
fn fmt(v: f64) -> String {
format!("{:.2}", v)
}
#[derive(Clone)]
struct CardData {
card_number: String,
transactions: Vec<FormattedTransaction>,
total_amount: String,
total_volume: String,
}
#[derive(Clone)]
struct FormattedTransaction {
date: String,
quality_name: String,
price: String,
volume: String,
amount: String,
receipt: String,
}
#[derive(Clone)]
struct PreparedCustomer {
customer_number: String,
cards: Vec<CardData>,
grand_total: String,
}
impl PreparedCustomer {
fn from_customer(customer: Customer) -> Self {
let cards: Vec<CardData> = customer
.cards
.into_iter()
.map(|(card_number, transactions)| {
let formatted_txs: Vec<FormattedTransaction> = transactions
.into_iter()
.map(|t| FormattedTransaction {
date: t.date.format("%Y-%m-%d %H:%M").to_string(),
quality_name: t.quality_name,
price: fmt(t.price),
volume: fmt(t.volume),
amount: fmt(t.amount),
receipt: t.receipt,
})
.collect();
let total_amount: f64 = formatted_txs
.iter()
.map(|t| t.amount.parse::<f64>().unwrap())
.sum();
let total_volume: f64 = formatted_txs
.iter()
.map(|t| t.volume.parse::<f64>().unwrap())
.sum();
CardData {
card_number,
transactions: formatted_txs,
total_amount: fmt(total_amount),
total_volume: fmt(total_volume),
}
})
.collect();
let grand_total: f64 = cards
.iter()
.map(|c| c.total_amount.parse::<f64>().unwrap())
.sum();
PreparedCustomer {
customer_number: customer.customer_number,
cards,
grand_total: fmt(grand_total),
}
}
}
#[derive(Template)]
#[template(path = "index.html")]
struct IndexTemplate {
customers: Vec<(String, usize)>,
batches: Vec<String>,
}
#[derive(Template)]
#[template(path = "customer.html")]
struct CustomerTemplate {
customer: PreparedCustomer,
batches: Vec<String>,
generated_date: String,
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
let data_dir = Path::new("input");
let output_dir = Path::new("output");
if !output_dir.exists() {
fs::create_dir_all(output_dir)?;
}
let mut batches: Vec<Batch> = Vec::new();
for entry in fs::read_dir(data_dir)? {
let entry = entry?;
let path = entry.path();
if path.extension().and_then(|s| s.to_str()) == Some("csv") {
match read_csv_file(&path) {
Ok(batch) => {
println!(
"Loaded {} transactions from {}",
batch.transactions.len(),
batch.filename
);
batches.push(batch);
}
Err(e) => {
eprintln!("Error reading {:?}: {}", path, e);
}
}
}
}
batches.sort_by(|a, b| a.filename.cmp(&b.filename));
let batch_filenames: Vec<String> = batches.iter().map(|b| b.filename.clone()).collect();
let customers = group_by_customer(&batches);
let index_customers: Vec<(String, usize)> = customers
.iter()
.map(|(num, c)| (num.clone(), c.cards.len()))
.collect();
let html = IndexTemplate {
customers: index_customers,
batches: batch_filenames.clone(),
}
.render()
.unwrap();
fs::write(output_dir.join("index.html"), html)?;
let generated_date = Utc::now().format("%Y-%m-%d %H:%M").to_string();
let customer_count = customers.len();
for (customer_num, customer) in customers {
let prepared = PreparedCustomer::from_customer(customer);
let customer_html = CustomerTemplate {
customer: prepared,
batches: batch_filenames.clone(),
generated_date: generated_date.clone(),
}
.render()
.unwrap();
let filename = format!("customer_{}.html", customer_num);
fs::write(output_dir.join(&filename), customer_html)?;
println!("Generated {}", filename);
}
println!(
"\nGenerated {} customer invoices in output/",
customer_count
);
Ok(())
}

51
src/templates.rs Normal file
View File

@@ -0,0 +1,51 @@
use askama::Template;
use askama_derive::Filter;
use chrono::Utc;
use std::collections::BTreeMap;
use invoice_generator::{group_by_customer, read_csv_file, Customer, Transaction};
#[derive(Template)]
#[template(path = "index.html")]
pub struct IndexTemplate {
pub customers: Vec<(String, Customer)>,
pub batches: Vec<String>,
}
#[derive(Template)]
#[template(path = "customer.html")]
pub struct CustomerTemplate {
pub customer: &Customer,
pub batches: Vec<String>,
}
pub fn calculate_card_totals(transactions: &[Transaction]) -> (f64, f64) {
let total_amount: f64 = transactions.iter().map(|t| t.amount).sum();
let total_volume: f64 = transactions.iter().map(|t| t.volume).sum();
(total_amount, total_volume)
}
pub fn calculate_grand_total(customer: &Customer) -> f64 {
customer
.cards
.values()
.flat_map(|t| t.iter())
.map(|t| t.amount)
.sum()
}
pub fn format_amount(amount: f64) -> String {
format!("{:.2}", amount)
}
pub fn format_volume(volume: f64) -> String {
format!("{:.2}", volume)
}
pub fn format_date(date: &chrono::NaiveDateTime) -> String {
date.format("%Y-%m-%d %H:%M").to_string()
}
pub fn now_string() -> String {
Utc::now().format("%Y-%m-%d %H:%M").to_string()
}