libeufin

administrative.rs (7454B)

---

 /*
 * 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 std::fmt::Display;
 
 use compact_str::CompactString;
 use taler_common::types::{
     amount::Currency,
     iban::{BIC, IBAN},
 };
 use taler_macros::EnumMeta;
 
 use crate::{
     config::EbicsHostCfg,
     ebics::{
         EbicsResponse,
         ebics_code::EbicsReturnCode,
         order::{BTF, Order},
     },
     xml,
     xml::{Xml, XmlAccess as _},
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct VersionNumber {
     pub number: CompactString,
     pub schema: CompactString,
 }
 
 impl Display for VersionNumber {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let Self { number, schema } = self;
         write!(f, "{number}:{schema}")
     }
 }
 
 pub struct HKD {
     pub partner: PartnerInfo,
     pub users: Box<[UserInfo]>,
 }
 pub struct PartnerInfo {
     pub name: Option<CompactString>,
     pub accounts: Box<[AccountInfo]>,
     pub orders: Vec<OrderInfo>,
 }
 pub struct OrderInfo {
     pub order: Order,
     pub description: String,
 }
 pub struct AccountInfo {
     pub currency: Currency,
     pub iban: IBAN,
     pub bic: BIC,
 }
 pub struct UserInfo {
     pub id: CompactString,
     pub status: UserStatus,
     pub permissions: Box<[Order]>,
 }
 
 pub struct HAA {
     pub orders: Vec<Order>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, EnumMeta)]
 #[enum_meta(Description)]
 pub enum UserStatus {
     /// "Subscriber is permitted access"
     Ready,
     /// "Subscriber is established, pending access permission"
     New,
     /// "Subscriber has sent INI file, but no HIA file yet"
     INI,
     /// "Subscriber has sent HIA order, but no INI file yet"
     HIA,
     /// "Subscriber has sent both HIA order and INI file"
     Initialised,
     /// "Suspended after several failed attempts, new initialisation via INI and HIA possible"
     SuspendedFailedAttempts,
     /// "Suspended after SPR order, new initialisation via INI and HIA possible"
     SuspendedSPR,
     /// "Suspended by bank, new initialisation via INI and HIA is not possible, suspension can only be revoked by the bank"
     SuspendedBank,
 }
 
 pub fn hev_msg(cfg: &EbicsHostCfg) -> String {
     xml!(
         "ebicsHEVRequest" "xmlns"="http://www.ebics.org/H000" {
             "HostID": &cfg.host_id
         }
     )
 }
 
 pub fn parse_hev(xml: &[u8]) -> xml::Result<EbicsResponse<Box<[VersionNumber]>>> {
     Xml::parse(xml, "ebicsHEVResponse", |root| {
         let s = root.one("SystemReturnCode")?;
         Ok(EbicsResponse {
             technical_code: s.one("ReturnCode").parse()?,
             technical_text: s.one("ReportText").parse()?,
             bank_code: EbicsReturnCode::EBICS_OK,
             content: Some(
                 root.many("VersionNumber")
                     .map(|n| {
                         Ok(VersionNumber {
                             number: n.parse()?,
                             schema: n.attr("ProtocolVersion")?.into(),
                         })
                     })
                     .collect::<xml::Result<_>>()?,
             ),
         })
     })
 }
 
 fn service(n: Xml) -> xml::Result<BTF> {
     let msg = n.one("MsgName")?;
     Ok(BTF {
         service: n.one("ServiceName").parse()?,
         scope: n.opt("Scope").parse()?,
         option: n.opt("ServiceOption").parse()?,
         container: n.opt("Container").parse_attr("containerType")?,
         msg: msg.parse()?,
         version: msg.parse_opt_attr("version")?,
     })
 }
 
 pub fn parse_hkd(xml: &[u8]) -> xml::Result<HKD> {
     fn order(n: Xml) -> xml::Result<Order> {
         let ty = n.one("AdminOrderType")?.text();
         Order::from_parts(ty, n.opt("Service")?.map(service).transpose()?)
             .ok_or_else(|| n.parse_err(format_args!("Unknown order type {ty}")))
     }
     Xml::parse(xml, "HKDResponseOrderData", |root| {
         let partner = root.one("PartnerInfo")?;
 
         Ok(HKD {
             partner: PartnerInfo {
                 name: partner.one("AddressInfo").opt("Name").parse()?,
                 accounts: partner
                     .many("AccountInfo")
                     .map(|account| {
                         let currency = account.parse_attr("Currency")?;
                         let iban = account
                             .many("AccountNumber")
                             .find(|nb| nb.opt_attr("international") == Some("true"))
                             .unwrap()
                             .parse()?;
                         let bic = account
                             .many("BankCode")
                             .find(|nb| nb.opt_attr("international") == Some("true"))
                             .unwrap()
                             .parse()?;
                         Ok(AccountInfo {
                             currency,
                             iban,
                             bic,
                         })
                     })
                     .collect::<xml::Result<_>>()?,
                 orders: partner
                     .many("OrderInfo")
                     .map(|n| {
                         Ok(OrderInfo {
                             order: order(n)?,
                             description: n.one("Description").parse()?,
                         })
                     })
                     .collect::<xml::Result<_>>()?,
             },
             users: root
                 .many("UserInfo")
                 .map(|n| {
                     let id = n.one("UserID")?;
                     Ok(UserInfo {
                         id: id.parse()?,
                         status: match id.attr("Status")? {
                             "1" => UserStatus::Ready,
                             "2" => UserStatus::New,
                             "3" => UserStatus::INI,
                             "4" => UserStatus::HIA,
                             "5" => UserStatus::Initialised,
                             "6" => UserStatus::SuspendedFailedAttempts,
                             // 7 is not applicable per spec
                             "8" => UserStatus::SuspendedSPR,
                             "9" => UserStatus::SuspendedBank,
                             s => return Err(id.parse_err(format_args!("Unknown user status {s}"))),
                         },
                         permissions: n
                             .many("Permission")
                             .map(|p| order(p))
                             .collect::<xml::Result<_>>()?,
                     })
                 })
                 .collect::<xml::Result<_>>()?,
         })
     })
 }
 
 pub fn parse_haa(xml: &[u8]) -> xml::Result<HAA> {
     Xml::parse(xml, "HAAResponseOrderData", |root| {
         Ok(HAA {
             orders: root
                 .many("Service")
                 .map(|n| Ok(Order::BTD(service(n)?)))
                 .collect::<xml::Result<_>>()?,
         })
     })
 }