taler-rust

api.rs (8640B)

---

 /*
   This file is part of TALER
   Copyright (C) 2024, 2025, 2026 Taler Systems SA
 
   TALER 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.
 
   TALER 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
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use jiff::Timestamp;
 use sqlx::PgPool;
 use taler_common::{
     api_params::{History, Page},
     api_revenue::RevenueIncomingHistory,
     api_transfer::{
         RegistrationRequest, RegistrationResponse, SubjectFormat, TransferSubject, Unregistration,
     },
     api_wire::{
         AddIncomingRequest, AddIncomingResponse, AddKycauthRequest, AddMappedRequest,
         IncomingHistory, OutgoingHistory, TransferList, TransferRequest, TransferResponse,
         TransferState, TransferStatus,
     },
     db::IncomingType,
     error_code::ErrorCode,
     types::{
         amount::Currency,
         payto::{FullQuery, payto},
         timestamp::TalerTimestamp,
     },
 };
 use tokio::sync::watch::Sender;
 
 use crate::{
     api::{TalerApi, revenue::Revenue, transfer::PreparedTransfer, wire::WireGateway},
     error::{ApiResult, failure, failure_code},
     subject::fmt_in_subject,
     test::db::{self, AddIncomingResult},
 };
 
 /// Taler API implementation for tests
 pub struct TestApi {
     pub currency: Currency,
     pub pool: PgPool,
     pub outgoing_channel: Sender<i64>,
     pub incoming_channel: Sender<i64>,
 }
 
 impl TalerApi for TestApi {
     fn currency(&self) -> &str {
         self.currency.as_ref()
     }
 
     fn implementation(&self) -> &'static str {
         "urn:net:taler:specs:taler-test-api:taler-rust"
     }
 }
 
 impl WireGateway for TestApi {
     async fn transfer(&self, req: TransferRequest) -> ApiResult<TransferResponse> {
         req.credit_account.query::<FullQuery>()?;
         let result = db::transfer(&self.pool, &req).await?;
         match result {
             db::TransferResult::Success(transfer_response) => Ok(transfer_response),
             db::TransferResult::RequestUidReuse => {
                 Err(failure_code(ErrorCode::BANK_TRANSFER_REQUEST_UID_REUSED))
             }
             db::TransferResult::WtidReuse => {
                 Err(failure_code(ErrorCode::BANK_TRANSFER_WTID_REUSED))
             }
         }
     }
 
     async fn transfer_page(
         &self,
         page: Page,
         status: Option<TransferState>,
     ) -> ApiResult<TransferList> {
         Ok(TransferList {
             transfers: db::transfer_page(&self.pool, &status, &page, &self.currency).await?,
             debit_account: payto("payto://test"),
         })
     }
 
     async fn transfer_by_id(&self, id: u64) -> ApiResult<Option<TransferStatus>> {
         Ok(db::transfer_by_id(&self.pool, id, &self.currency).await?)
     }
 
     async fn outgoing_history(&self, params: History) -> ApiResult<OutgoingHistory> {
         let txs = db::outgoing_revenue(&self.pool, &params, &self.currency, || {
             self.outgoing_channel.subscribe()
         })
         .await?;
         Ok(OutgoingHistory {
             outgoing_transactions: txs,
             debit_account: payto("payto://test"),
         })
     }
 
     async fn incoming_history(&self, params: History) -> ApiResult<IncomingHistory> {
         let txs = db::incoming_history(&self.pool, &params, &self.currency, || {
             self.incoming_channel.subscribe()
         })
         .await?;
         Ok(IncomingHistory {
             incoming_transactions: txs,
             credit_account: payto("payto://test"),
         })
     }
 
     async fn add_incoming_reserve(
         &self,
         req: AddIncomingRequest,
     ) -> ApiResult<AddIncomingResponse> {
         let res = db::add_incoming(
             &self.pool,
             &req.amount,
             &req.debit_account,
             "",
             &Timestamp::now(),
             IncomingType::reserve,
             &req.reserve_pub,
         )
         .await?;
         match res {
             AddIncomingResult::Success { id, created_at } => Ok(AddIncomingResponse {
                 timestamp: created_at.into(),
                 row_id: id,
             }),
             AddIncomingResult::ReservePubReuse => {
                 Err(failure_code(ErrorCode::BANK_DUPLICATE_RESERVE_PUB_SUBJECT))
             }
             AddIncomingResult::UnknownMapping | AddIncomingResult::MappingReuse => {
                 unreachable!("mapping not used")
             }
         }
     }
 
     async fn add_incoming_kyc(&self, req: AddKycauthRequest) -> ApiResult<AddIncomingResponse> {
         let res = db::add_incoming(
             &self.pool,
             &req.amount,
             &req.debit_account,
             "",
             &Timestamp::now(),
             IncomingType::kyc,
             &req.account_pub,
         )
         .await?;
         match res {
             AddIncomingResult::Success { id, created_at } => Ok(AddIncomingResponse {
                 timestamp: created_at.into(),
                 row_id: id,
             }),
             AddIncomingResult::ReservePubReuse => {
                 Err(failure_code(ErrorCode::BANK_DUPLICATE_RESERVE_PUB_SUBJECT))
             }
             AddIncomingResult::UnknownMapping | AddIncomingResult::MappingReuse => {
                 unreachable!("mapping not used")
             }
         }
     }
 
     async fn add_incoming_mapped(&self, req: AddMappedRequest) -> ApiResult<AddIncomingResponse> {
         let res = db::add_incoming(
             &self.pool,
             &req.amount,
             &req.debit_account,
             "",
             &Timestamp::now(),
             IncomingType::map,
             &req.authorization_pub,
         )
         .await?;
         match res {
             AddIncomingResult::Success { id, created_at } => Ok(AddIncomingResponse {
                 timestamp: created_at.into(),
                 row_id: id,
             }),
             AddIncomingResult::ReservePubReuse => {
                 Err(failure_code(ErrorCode::BANK_DUPLICATE_RESERVE_PUB_SUBJECT))
             }
             AddIncomingResult::UnknownMapping => {
                 Err(failure_code(ErrorCode::BANK_TRANSFER_MAPPING_UNKNOWN))
             }
             AddIncomingResult::MappingReuse => {
                 Err(failure_code(ErrorCode::BANK_TRANSFER_MAPPING_REUSED))
             }
         }
     }
 
     fn support_account_check(&self) -> bool {
         false
     }
 }
 
 impl Revenue for TestApi {
     async fn history(&self, params: History) -> ApiResult<RevenueIncomingHistory> {
         let txs = db::revenue_history(&self.pool, &params, &self.currency, || {
             self.incoming_channel.subscribe()
         })
         .await?;
         Ok(RevenueIncomingHistory {
             incoming_transactions: txs,
             credit_account: payto("payto://test"),
         })
     }
 }
 
 impl PreparedTransfer for TestApi {
     fn supported_formats(&self) -> &[SubjectFormat] {
         &[SubjectFormat::SIMPLE]
     }
 
     async fn registration(&self, req: RegistrationRequest) -> ApiResult<RegistrationResponse> {
         match db::transfer_register(&self.pool, &req).await? {
             db::RegistrationResult::Success => {
                 let simple = TransferSubject::Simple {
                     credit_amount: req.credit_amount,
                     subject: if req.authorization_pub == req.account_pub && !req.recurrent {
                         fmt_in_subject(req.r#type.into(), &req.account_pub)
                     } else {
                         fmt_in_subject(IncomingType::map, &req.authorization_pub)
                     },
                 };
                 ApiResult::Ok(RegistrationResponse {
                     subjects: vec![simple],
                     expiration: TalerTimestamp::Never,
                 })
             }
             db::RegistrationResult::ReservePubReuse => {
                 ApiResult::Err(failure_code(ErrorCode::BANK_DUPLICATE_RESERVE_PUB_SUBJECT))
             }
         }
     }
 
     async fn unregistration(&self, req: Unregistration) -> ApiResult<()> {
         if !db::transfer_unregister(&self.pool, &req).await? {
             Err(failure(
                 ErrorCode::BANK_TRANSACTION_NOT_FOUND,
                 format!("Prepared transfer '{}' not found", req.authorization_pub),
             ))
         } else {
             Ok(())
         }
     }
 }