Struct PaymentApi 

pub struct PaymentApi { /* private fields */ }

Implementations

impl PaymentApi

pub fn new(client: &WebClient, config: ApiConfig) -> Self

pub async fn get_requestor_accounts(&self) -> Result<Vec<Account>>

pub async fn get_provider_accounts(&self) -> Result<Vec<Account>>

pub async fn create_allocation( &self, allocation: &NewAllocation, ) -> Result<Allocation>

pub async fn get_allocations<Tz>( &self, after_timestamp: Option<DateTime<Tz>>, max_items: Option<u32>, ) -> Result<Vec<Allocation>>

where Tz: TimeZone, Tz::Offset: Display,

pub async fn get_allocation(&self, allocation_id: &str) -> Result<Allocation>

pub async fn amend_allocation( &self, allocation_id: &str, allocation: &AllocationUpdate, ) -> Result<Allocation>

pub async fn release_allocation(&self, allocation_id: &str) -> Result<()>

pub async fn get_demand_decorations( &self, allocation_ids: Vec<String>, ) -> Result<MarketDecoration>

pub async fn get_debit_notes<Tz>( &self, after_timestamp: Option<DateTime<Tz>>, max_items: Option<u32>, ) -> Result<Vec<DebitNote>>

where Tz: TimeZone, Tz::Offset: Display,

pub async fn get_debit_note(&self, debit_note_id: &str) -> Result<DebitNote>

pub async fn get_payments_for_debit_note<Tz>( &self, debit_note_id: &str, after_timestamp: Option<DateTime<Tz>>, max_items: Option<u32>, ) -> Result<Vec<Payment>>

where Tz: TimeZone, Tz::Offset: Display,

pub fn events<Evtype: PaymentEvent>(&self) -> EventsBuilder<'_, Evtype>

Example

use std::time::Duration;
use chrono::{DateTime, Utc};
use ya_client::payment::PaymentApi;
use ya_client_model::payment::{DebitNoteEvent, DebitNoteEventType, InvoiceEvent};

async fn my_get_events(payment_api : PaymentApi) -> anyhow::Result<Vec<DebitNoteEvent>> {
    let ts = Utc::now() - chrono::Duration::days(1);

    let events = payment_api.events()
        .after_timestamp(&ts)
        .timeout(Duration::from_secs(60))
        .max_events(100)
        .provider_events(&[
            DebitNoteEventType::DebitNoteReceivedEvent,
            DebitNoteEventType::DebitNoteAcceptedEvent,
            DebitNoteEventType::DebitNoteSettledEvent])
        .requestor_events(vec![
             DebitNoteEventType::DebitNoteReceivedEvent,
            DebitNoteEventType::DebitNoteAcceptedEvent,
            DebitNoteEventType::DebitNoteSettledEvent])
        .get().await?;
    Ok(events)
}

async fn my_last_invoice(payment_api : PaymentApi) {
    if let Some(invoiceEvent)  = payment_api.events::<InvoiceEvent>()
        .max_events(1)
        .get().await
        .unwrap().into_iter().next() {
        eprintln!("first invoice id: {}", invoiceEvent.invoice_id);
    }
}

pub async fn get_debit_note_events<Tz>( &self, after_timestamp: Option<&DateTime<Tz>>, timeout: Option<Duration>, max_events: Option<u32>, app_session_id: Option<String>, ) -> Result<Vec<DebitNoteEvent>>

where Tz: TimeZone, Tz::Offset: Display,

pub async fn issue_debit_note( &self, debit_note: &NewDebitNote, ) -> Result<DebitNote>

pub async fn send_debit_note(&self, debit_note_id: &str) -> Result<()>

pub async fn cancel_debit_note(&self, debit_note_id: &str) -> Result<()>

pub async fn accept_debit_note( &self, debit_note_id: &str, acceptance: &Acceptance, ) -> Result<()>

pub async fn reject_debit_note( &self, debit_note_id: &str, rejection: &Rejection, ) -> Result<()>

pub async fn get_invoices<Tz>( &self, after_timestamp: Option<DateTime<Tz>>, max_items: Option<u32>, ) -> Result<Vec<Invoice>>

where Tz: TimeZone, Tz::Offset: Display,

pub async fn get_invoice(&self, invoice_id: &str) -> Result<Invoice>

pub async fn get_payments_for_invoice<Tz>( &self, invoice_id: &str, after_timestamp: Option<DateTime<Tz>>, max_items: Option<u32>, ) -> Result<Vec<Payment>>

where Tz: TimeZone, Tz::Offset: Display,

pub async fn get_invoice_events<Tz>( &self, after_timestamp: Option<&DateTime<Tz>>, timeout: Option<Duration>, max_events: Option<u32>, app_session_id: Option<String>, ) -> Result<Vec<InvoiceEvent>>

where Tz: TimeZone, Tz::Offset: Display,

pub async fn issue_invoice(&self, invoice: &NewInvoice) -> Result<Invoice>

pub async fn send_invoice(&self, invoice_id: &str) -> Result<()>

pub async fn cancel_invoice(&self, invoice_id: &str) -> Result<()>

pub async fn accept_invoice( &self, invoice_id: &str, acceptance: &Acceptance, ) -> Result<()>

pub async fn reject_invoice( &self, invoice_id: &str, rejection: &Rejection, ) -> Result<()>

pub async fn get_payments<Tz>( &self, after_timestamp: Option<&DateTime<Tz>>, timeout: Option<Duration>, max_events: Option<u32>, app_session_id: Option<String>, ) -> Result<Vec<Payment>>

where Tz: TimeZone, Tz::Offset: Display,

pub async fn get_signed_payments<Tz>( &self, after_timestamp: Option<&DateTime<Tz>>, timeout: Option<Duration>, max_events: Option<u32>, app_session_id: Option<String>, ) -> Result<Vec<Signed<Payment>>>

where Tz: TimeZone, Tz::Offset: Display,

pub async fn get_payment(&self, payment_id: &str) -> Result<Payment>

pub async fn driver_status( &self, driver: Option<String>, network: Option<String>, ) -> Result<Vec<DriverStatusProperty>>

Trait Implementations

impl Clone for PaymentApi

fn clone(&self) -> PaymentApi

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl WebInterface for PaymentApi

const API_URL_ENV_VAR: &'static str = crate::payment::PAYMENT_URL_ENV_VAR

const API_SUFFIX: &'static str = ya_client_model::payment::PAYMENT_API_PATH

fn from_client(client: WebClient) -> Self

fn rebase_service_url(base_url: Rc<Url>) -> Result<Rc<Url>>