libeufin

iso20022.rs (5705B)

---

 /*
 * This file is part of LibEuFin.
 * Copyright (C) 2026 Taler Systems S.A.
 
 * LibEuFin is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation; either version 3, or
 * (at your option) any later version.
 
 * LibEuFin is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
 * Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
 * License along with LibEuFin; see the file COPYING.  If not, see
 * <http://www.gnu.org/licenses/>
 */
 
 use taler_macros::EnumMeta;
 
 pub mod bank_tx_code;
 pub mod camt;
 pub mod hac;
 pub mod model;
 pub mod pain001;
 pub mod pain002;
 pub mod status_code;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, EnumMeta)]
 #[enum_meta(Description, Str)]
 #[allow(non_camel_case_types)]
 pub enum HacAction {
     /// File submitted to the bank
     FILE_UPLOAD,
     /// File downloaded from the bank
     FILE_DOWNLOAD,
     /// Electronic signature submitted to the bank
     ES_UPLOAD,
     /// Electronic signature downloaded from the bank
     ES_DOWNLOAD,
     /// Signature verification
     ES_VERIFICATION,
     /// Forwarding to EDS
     VEU_FORWARDING,
     /// EDS signature verification
     VEU_VERIFICATION,
     /// Forwarded for postprocessing
     VEU_VERIFICATION_END,
     /// Cancellation of EDS order
     VEU_CANCEL_ORDER,
     /// Additional information
     ADDITIONAL,
     /// HAC end of order (positive)
     ORDER_HAC_FINAL_POS,
     /// HAC end of order (negative)
     ORDER_HAC_FINAL_NEG,
     // Not in the spec but Credit Suisse test suite use it
     /// HAC end of order
     ORDER_HAC_FINAL,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, EnumMeta)]
 #[enum_meta(Description, Str)]
 pub enum ChargeBearer {
     /// BorneByDebtor
     DEBT,
     /// BorneByCreditor
     CRED,
     /// Shared
     SHAR,
     /// SLEV
     SLEV,
 }
 
 #[cfg(test)]
 pub mod test {
     use tracing::info;
 
     use crate::{
         ebics::administrative::{parse_haa, parse_hkd},
         iso20022::{camt::parse_camt, hac::parse_hac, pain002::parse_pain002},
     };
 
     #[test]
     pub fn sample() {
         taler_test_utils::setup_tracing();
         let mut samples = Vec::new();
         for entry in std::fs::read_dir("../testbench/sample").unwrap() {
             let entry = entry.unwrap();
             let path = entry.path();
             if path.is_dir() {
                 for entry in std::fs::read_dir(path).unwrap() {
                     let entry = entry.unwrap();
                     samples.push((entry.path(), entry.file_name()));
                 }
             } else {
                 samples.push((path, entry.file_name()));
             }
         }
         for (path, name) in samples {
             let xml = std::fs::read(&path).unwrap();
             let name = name.to_string_lossy();
 
             info!("Parse sample {path:?}");
 
             if name.contains("hac") {
                 parse_hac(&xml).unwrap();
             } else if name.contains("camt") {
                 parse_camt(&xml).unwrap();
             } else if name.contains("pain002") {
                 parse_pain002(&xml).unwrap();
             } else if name.contains("pain001") {
                 // Ignore
             } else {
                 panic!("Unsupported file type {name}")
             }
         }
     }
 
     #[test]
     pub fn logs() {
         taler_test_utils::setup_tracing();
 
         if !std::fs::exists("testbench/test").unwrap() {
             return;
         }
         for platform in std::fs::read_dir("testbench/test")
             .unwrap()
             .map(Result::unwrap)
         {
             let path = platform.path();
             if !path.is_dir() || platform.file_name() == "platform" {
                 continue;
             }
 
             // List logs
             let mut logs = Vec::new();
             for date in std::fs::read_dir(path).unwrap().map(Result::unwrap) {
                 let path = date.path();
                 if !path.is_dir() {
                     continue;
                 }
                 for tx in std::fs::read_dir(path).unwrap().map(Result::unwrap) {
                     let payload = tx.path().join("payload");
                     if payload.exists() {
                         logs.extend(
                             std::fs::read_dir(payload)
                                 .unwrap()
                                 .map(|it| it.unwrap().path()),
                         );
                     }
                     let payload = tx.path().join("payload.xml");
                     if payload.exists() {
                         logs.push(payload);
                     }
                 }
             }
             for path in logs {
                 let xml = std::fs::read(&path).unwrap();
                 let path = path.to_string_lossy();
 
                 info!("Parse sample {path:?}");
 
                 if path.contains("HAC") {
                     parse_hac(&xml).unwrap();
                 } else if path.contains("HKD") {
                     parse_hkd(&xml).unwrap();
                 } else if path.contains("HAA") {
                     parse_haa(&xml).unwrap();
                 } else if path.contains("camt") {
                     parse_camt(&xml).unwrap();
                 } else if path.contains("pain.002") {
                     parse_pain002(&xml).unwrap();
                 } else if path.contains("pain.001") {
                     // Ignore
                 } else {
                     panic!("Unsupported file type {path}")
                 }
             }
         }
     }
 }