psdn-tacsvs/src/main.rs

use chrono::naive::NaiveDate;
use std::collections::HashSet;
use string_cache::DefaultAtom;

/// simple typed helper enums
mod simple_enums;
use simple_enums::*;

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
enum KontoDaten {
    None,
    Old { knr: u64, blz: u32 },
    New { iban: String, bic: String },
}

type TransactionValue = fixed::types::U21F11;

#[derive(Clone, Debug, Eq, PartialEq)]
struct TransactionLine {
    d_buchungs: NaiveDate,
    d_valuta: NaiveDate,
    // ignore 3. column = "Auftraggeber/Zahlungsempfänger",
    // because that should be nearly equivalent for every row
    p_other: DefaultAtom,
    konto_data: KontoDaten,
    verwendungszw: String,
    kref: String,
    waehrung: Waehrung,
    umsatz: TransactionValue,
    direction: TransactionDirection,
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
struct Transactions {
    pothc: HashSet<DefaultAtom>,
    elems: Vec<TransactionLine>,
}

impl std::ops::Deref for Transactions {
    type Target = [TransactionLine];

    #[inline]
    fn deref(&self) -> &[TransactionLine] {
        &self.elems[..]
    }
}

impl Transactions {
    #[inline]
    pub fn new() -> Self {
        Default::default()
    }

    #[inline]
    pub fn is_empty(&self) -> bool {
        self.elems.is_empty()
    }

    #[inline]
    pub fn len(&self) -> usize {
        self.elems.len()
    }

    pub fn push(&mut self, mut tl: TransactionLine) {
        if let Some(x) = self.pothc.get(&tl.p_other) {
            tl.p_other = x.clone();
        } else {
            self.pothc.insert(tl.p_other.clone());
        }
        self.elems.push(tl);
    }
}

fn main() {
    use encoding::types::Encoding;

    for i in std::env::args().skip(1) {
        println!("F = {}", i);

        let fh = readfilez::read_from_file(std::fs::File::open(i)).expect("unable to open file");

        let dat = encoding::all::ISO_8859_1
            .decode(&*fh, encoding::types::DecoderTrap::Replace)
            .expect("got invalid latin-1 data");

        std::mem::drop(fh);

        let mut rdr = csv::ReaderBuilder::new()
            .delimiter(b';')
            .flexible(true)
            .has_headers(false)
            .from_reader(dat.as_bytes());

        let mut recsit = rdr.records().skip(8);

        assert_eq!(
            recsit.next().unwrap().unwrap(),
            vec![
                "Buchungstag",
                "Valuta",
                "Auftraggeber/Zahlungsempfänger",
                "Empfänger/Zahlungspflichtiger",
                "Konto-Nr.",
                "IBAN",
                "BLZ",
                "BIC",
                "Vorgang/Verwendungszweck",
                "Kundenreferenz",
                "Währung",
                "Umsatz",
                " "
            ]
        );

        println!("\nData:");
        for result in recsit {
            let record = result.expect("got invalid line");
            assert_eq!(record.len(), 13);
            if record[1].is_empty() {
                // finalizer line -> ignore
                break;
            }

            // decode KontoDaten
            let r_e: &[u8] = &[
                record[4].is_empty() as u8,
                record[5].is_empty() as u8,
                record[6].is_empty() as u8,
                record[7].is_empty() as u8,
            ];
            let konto_data = match &*r_e {
                &[0, 1, 0, 1] => KontoDaten::Old {
                    knr: record[4].parse().expect("invalid Konto-Nr."),
                    blz: record[6].parse().expect("invalid BLZ"),
                },
                &[1, 0, 1, 0] => KontoDaten::New {
                    iban: record[5].to_string(),
                    bic: record[7].to_string(),
                },
                &[1, 1, 1, 1] => KontoDaten::None,
                _ => unimplemented!(
                    "unsupported KontoData encoding: {:?} :in: {:?}",
                    &r_e,
                    &record
                ),
            };

            let tl = TransactionLine {
                d_buchungs: NaiveDate::parse_from_str(&record[0], "%d.%m.%Y")
                    .expect("invalid date format"),
                d_valuta: NaiveDate::parse_from_str(&record[1], "%d.%m.%Y")
                    .expect("invalid date format"),
                p_other: DefaultAtom::from(&record[3]),
                konto_data,
                verwendungszw: record[8].to_string(),
                kref: record[9].to_string(),
                waehrung: record[10].parse().unwrap(),
                umsatz: record[11]
                    .replace('.', "")
                    .replace(',', ".")
                    .parse()
                    .expect("invalid Umsatz"),
                direction: record[12].parse().unwrap(),
            };
            println!("{:?}", tl);
        }
    }
}