Struct ProcessedMail 

pub struct ProcessedMail {
    pub client: Client,
}

Available on crate feature requests only.

Fields

client: Client

Implementations

impl ProcessedMail

pub async fn list<'a>( &'a self, ordering: Option<String>, page: Option<i64>, page_size: Option<i64>, rule: Option<i64>, status: Option<String>, ) -> Result<PaginatedProcessedMailList, Error>

Perform a GET request to /api/processed_mail/.

Parameters:

• ordering: Option<String>: Which field to use when ordering the results.
• page: Option<i64>: A page number within the paginated result set.
• page_size: Option<i64>: Number of results to return per page.
• rule: Option<i64>
• status: Option<String>

use futures_util::TryStreamExt;
async fn example_processed_mail_list_stream() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let mut processed_mail = client.processed_mail();
    let mut stream = processed_mail.list_stream(
        Some("some-string".to_string()),
        Some(4 as i64),
        Some(4 as i64),
        Some("some-string".to_string()),
    );
    loop {
        match stream.try_next().await {
            Ok(Some(item)) => {
                println!("{:?}", item);
            }
            Ok(None) => {
                break;
            }
            Err(err) => {
                return Err(err.into());
            }
        }
    }

    Ok(())
}

pub async fn retrieve<'a>(&'a self, id: i64) -> Result<ProcessedMail, Error>

Perform a GET request to /api/processed_mail/{id}/.

Parameters:

• id: i64: A unique integer value identifying this processed mail. (required)

async fn example_processed_mail_retrieve() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: paperless_api_client::types::ProcessedMail = client.processed_mail().retrieve(4 as i64).await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn bulk_delete_create<'a>( &'a self, body: &ProcessedMailRequest, ) -> Result<ProcessedMail, Error>

Perform a POST request to /api/processed_mail/bulk_delete/.

async fn example_processed_mail_bulk_delete_create() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: paperless_api_client::types::ProcessedMail = client
        .processed_mail()
        .bulk_delete_create(&paperless_api_client::types::ProcessedMailRequest {
            owner: Some(4 as i64),
        })
        .await?;
    println!("{:?}", result);
    Ok(())
}

Trait Implementations

impl Clone for ProcessedMail

fn clone(&self) -> ProcessedMail

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessedMail

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.