libeufin

payto.rs (6057B)

---

 /*
 * 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 compact_str::CompactString;
 use sqlx::{Row as _, postgres::PgRow};
 use taler_api::{
     db::TypeHelper as _,
     error::{ApiResult, bad_request},
 };
 use taler_common::types::{
     iban::{BIC, IBAN},
     payto::{
         BankID, FullIbanPayto, FullPayto, IbanPayto, Payto, PaytoErr, PaytoImpl, PaytoURI,
         TransferPayto,
     },
 };
 
 const X_TALER_BANK: &str = "x-taler-bank";
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct XTalerBank {
     pub hostname: CompactString,
     pub username: CompactString,
 }
 
 impl PaytoImpl for XTalerBank {
     fn as_uri(&self) -> PaytoURI {
         PaytoURI::from_parts(
             X_TALER_BANK,
             format_args!("/{}/{}", self.hostname, self.username),
         )
     }
 
     fn parse(raw: &PaytoURI) -> Result<Self, PaytoErr> {
         let url = raw.as_ref();
         if url.domain() != Some(X_TALER_BANK) {
             return Err(PaytoErr::UnsupportedKind(
                 X_TALER_BANK,
                 url.domain().unwrap_or_default().into(),
             ));
         }
         let Some(mut segments) = url.path_segments() else {
             return Err(PaytoErr::MissingSegment("hostname"));
         };
         let Some(hostname) = segments.next() else {
             return Err(PaytoErr::MissingSegment("hostname"));
         };
         let Some(username) = segments.next() else {
             return Err(PaytoErr::MissingSegment("username"));
         };
 
         Ok(Self {
             hostname: hostname.into(),
             username: username.into(),
         })
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum LibeufinId {
     IBAN(BankID),
     XTalerBank(XTalerBank),
 }
 
 pub type BankPayto = Payto<LibeufinId>;
 pub type FullBankPayto = FullPayto<LibeufinId>;
 pub type TransferBankPayto = TransferPayto<LibeufinId>;
 
 impl LibeufinId {
     pub fn canonical(&self) -> String {
         match self {
             LibeufinId::IBAN(BankID { iban, .. }) => format!("payto://iban/{iban}"),
             LibeufinId::XTalerBank(XTalerBank { username, .. }) => {
                 format!("payto://{X_TALER_BANK}/localhost/{username}")
             }
         }
     }
 
     pub fn bank(mut self, ctx: &PaytoCtx) -> BankPayto {
         match &mut self {
             LibeufinId::IBAN(bank_id) => bank_id.bic = ctx.bic,
             LibeufinId::XTalerBank(xtaler_bank) => xtaler_bank.hostname = ctx.hostname.clone(),
         };
         Payto::new(self)
     }
 
     pub fn expect_iban(&self) -> ApiResult<&BankID> {
         match self {
             LibeufinId::IBAN(bank_id) => Ok(bank_id),
             LibeufinId::XTalerBank(_) => Err(bad_request(format_args!(
                 "expected an IBAN payto URI got '{X_TALER_BANK}'"
             ))),
         }
     }
 
     pub fn expect_xtaler_bank(&self) -> ApiResult<&XTalerBank> {
         match self {
             LibeufinId::IBAN(_) => Err(bad_request(format_args!(
                 "expected a {X_TALER_BANK} payto URI got 'iban'"
             ))),
             LibeufinId::XTalerBank(xtaler_bank) => Ok(xtaler_bank),
         }
     }
 }
 
 impl PaytoImpl for LibeufinId {
     fn as_uri(&self) -> PaytoURI {
         match self {
             LibeufinId::IBAN(bank_id) => bank_id.as_uri(),
             LibeufinId::XTalerBank(x_taler_bank) => x_taler_bank.as_uri(),
         }
     }
 
     fn parse(uri: &PaytoURI) -> Result<Self, PaytoErr> {
         let url = uri.as_ref();
 
         Ok(if url.domain() == Some(X_TALER_BANK) {
             Self::XTalerBank(XTalerBank::parse(uri)?)
         } else {
             Self::IBAN(BankID::parse(uri)?)
         })
     }
 }
 
 impl From<BankID> for LibeufinId {
     fn from(value: BankID) -> Self {
         Self::IBAN(value)
     }
 }
 
 impl From<IBAN> for LibeufinId {
     fn from(value: IBAN) -> Self {
         Self::IBAN(BankID {
             iban: value,
             bic: None,
         })
     }
 }
 
 impl From<XTalerBank> for LibeufinId {
     fn from(value: XTalerBank) -> Self {
         Self::XTalerBank(value)
     }
 }
 
 pub struct PaytoCtx {
     pub bic: Option<BIC>,
     pub hostname: CompactString,
 }
 
 pub fn sql_bank_simple_payto(
     r: &PgRow,
     ctx: &PaytoCtx,
     payto_idx: &str,
 ) -> sqlx::Result<BankPayto> {
     let payto: BankPayto = r.try_get_parse(payto_idx)?;
     Ok(payto.into_inner().bank(ctx))
 }
 
 pub fn sql_bank_payto(
     r: &PgRow,
     ctx: &PaytoCtx,
     payto_idx: &str,
     name_idx: &str,
 ) -> sqlx::Result<FullBankPayto> {
     let payto: BankPayto = r.try_get_parse(payto_idx)?;
     let name = r.try_get(name_idx)?;
     let payto = payto.into_inner().bank(ctx);
     Ok(payto.into_inner().full(name))
 }
 
 pub fn sql_opt_bank_payto(
     r: &PgRow,
     ctx: &PaytoCtx,
     payto_idx: &str,
     name_idx: &str,
 ) -> sqlx::Result<Option<FullBankPayto>> {
     let payto: Option<BankPayto> = r.try_get_opt_parse(payto_idx)?;
     if let Some(payto) = payto {
         let name = r.try_get(name_idx)?;
         let payto = payto.into_inner().bank(ctx);
         Ok(Some(payto.into_inner().full(name)))
     } else {
         Ok(None)
     }
 }
 
 pub fn sql_opt_iban_payto(
     r: &PgRow,
     payto_idx: &str,
     name_idx: &str,
 ) -> sqlx::Result<Option<FullIbanPayto>> {
     let payto: Option<IbanPayto> = r.try_get_opt_parse(payto_idx)?;
     if let Some(payto) = payto {
         let name = r.try_get(name_idx)?;
         Ok(Some(FullPayto::new(payto.into_inner(), name)))
     } else {
         Ok(None)
     }
 }