libeufin

cashout.rs (6312B)

---

 /*
 * 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 jiff::Timestamp;
 use sqlx::{
     Arguments, PgPool, QueryBuilder, Row,
     postgres::{PgArguments, PgRow},
 };
 use taler_api::{
     db::{BindHelper, TypeHelper, page},
     serialized,
 };
 use taler_common::{
     api::{ShortHashCode, params::Page},
     types::amount::{Amount, Currency},
 };
 
 use crate::api::cashout::{CashoutInfo, CashoutStatus, CashoutStatusResponse, GlobalCashoutInfo};
 
 /** Result of cashout operation creation */
 pub enum CreationResult {
     Success(u64),
     UnderMin,
     BadConversion,
     AccountNotFound,
     AccountIsExchange,
     BalanceInsufficient,
     RequestUidReuse,
     NoCashoutPayto,
     TanRequired,
 }
 
 /** Create a new cashout operation */
 pub async fn create(
     db: &PgPool,
     username: &str,
     request_uid: &ShortHashCode,
     debit: &Amount,
     credit: &Amount,
     subject: &str,
     timestamp: &Timestamp,
     is2fa: bool,
 ) -> sqlx::Result<CreationResult> {
     serialized!(
         sqlx::query(
             "
     SELECT
         out_bad_conversion,
         out_account_not_found,
         out_account_is_exchange,
         out_balance_insufficient,
         out_request_uid_reuse,
         out_no_cashout_payto,
         out_tan_required,
         out_cashout_id,
         out_under_min
     FROM cashout_create($1,$2,$3,$4,$5,$6,$7)
     ",
         )
         .bind(username)
         .bind(request_uid)
         .bind(debit)
         .bind(credit)
         .bind(subject)
         .bind_timestamp(timestamp)
         .bind(is2fa)
         .try_map(|r: PgRow| {
             Ok(if r.try_get_flag("out_under_min")? {
                 CreationResult::UnderMin
             } else if r.try_get_flag("out_bad_conversion")? {
                 CreationResult::BadConversion
             } else if r.try_get_flag("out_account_not_found")? {
                 CreationResult::AccountNotFound
             } else if r.try_get_flag("out_account_is_exchange")? {
                 CreationResult::AccountIsExchange
             } else if r.try_get_flag("out_balance_insufficient")? {
                 CreationResult::BalanceInsufficient
             } else if r.try_get_flag("out_request_uid_reuse")? {
                 CreationResult::RequestUidReuse
             } else if r.try_get_flag("out_no_cashout_payto")? {
                 CreationResult::NoCashoutPayto
             } else if r.try_get_flag("out_tan_required")? {
                 CreationResult::TanRequired
             } else {
                 CreationResult::Success(r.try_get_u64("out_cashout_id")?)
             })
         })
         .fetch_one(db)
     )
 }
 
 /** Get status of cashout operation [id] owned by [username] */
 pub async fn get_for_user(
     db: &PgPool,
     regional: &Currency,
     fiat: &Currency,
     username: &str,
     id: u64,
 ) -> sqlx::Result<Option<CashoutStatusResponse>> {
     serialized!(
         sqlx::query(
             "
     SELECT
         amount_debit
         ,amount_credit
         ,cashout_operations.subject
         ,creation_time
         ,transaction_date as confirmation_date
     FROM cashout_operations
         JOIN bank_accounts ON bank_account=bank_account_id
         JOIN customers ON owning_customer_id=customer_id
         LEFT JOIN bank_account_transactions ON local_transaction=bank_transaction_id
     WHERE cashout_id=$1 AND username=$2
     ",
         )
         .bind(id as i64)
         .bind(username)
         .try_map(|r: PgRow| {
             Ok(CashoutStatusResponse {
                 amount_debit: r.try_get_amount("amount_debit", regional)?,
                 amount_credit: r.try_get_amount("amount_credit", fiat)?,
                 subject: r.try_get("subject")?,
                 creation_time: r.try_get_timestamp("creation_time")?.into(),
                 confirmation_time: r
                     .try_get_opt_timestamp("confirmation_date")?
                     .map(Into::into),
             })
         })
         .fetch_optional(db)
     )
 }
 
 /** Get a page of all cashout operations */
 pub async fn page_all(db: &PgPool, params: &Page) -> sqlx::Result<Vec<GlobalCashoutInfo>> {
     page(
         db,
         params,
         "cashout_id",
         || {
             QueryBuilder::new(
                 "
         SELECT cashout_id, username
     FROM cashout_operations
         JOIN bank_accounts ON bank_account=bank_account_id
         JOIN customers ON owning_customer_id=customer_id
     WHERE
     ",
             )
         },
         |r| {
             Ok(GlobalCashoutInfo {
                 cashout_id: r.try_get_u64("cashout_id")?,
                 username: r.try_get("username")?,
                 status: CashoutStatus::confirmed,
             })
         },
     )
     .await
 }
 
 /** Get a page of all cashout operations */
 pub async fn page_for_user(
     db: &PgPool,
     username: &str,
     params: &Page,
 ) -> sqlx::Result<Vec<CashoutInfo>> {
     page(
         db,
         params,
         "cashout_id",
         || {
             let mut params = PgArguments::default();
             params.add(username).unwrap();
             QueryBuilder::with_arguments(
                 "
                 SELECT cashout_id
                 FROM cashout_operations
                 WHERE bank_account=(
                     SELECT bank_account_id
                     FROM bank_accounts JOIN customers ON owning_customer_id=customer_id
                     WHERE deleted_at IS NULL AND username = $1
                 ) AND
                 ",
                 params,
             )
         },
         |r| {
             Ok(CashoutInfo {
                 cashout_id: r.try_get_u64("cashout_id")?,
                 status: CashoutStatus::confirmed,
             })
         },
     )
     .await
 }