Struct MailAccounts 

pub struct MailAccounts {
    pub client: Client,
}

Available on crate feature requests only.

Fields

client: Client

Implementations

impl MailAccounts

pub async fn list<'a>( &'a self, page: Option<i64>, page_size: Option<i64>, ) -> Result<PaginatedMailAccountList, Error>

Perform a GET request to /api/mail_accounts/.

Parameters:

• page: Option<i64>: A page number within the paginated result set.
• page_size: Option<i64>: Number of results to return per page.

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

    Ok(())
}

pub async fn create<'a>( &'a self, body: &MailAccountRequest, ) -> Result<MailAccount, Error>

Perform a POST request to /api/mail_accounts/.

async fn example_mail_accounts_create() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: paperless_api_client::types::MailAccount = client
        .mail_accounts()
        .create(&paperless_api_client::types::MailAccountRequest {
            name: "some-string".to_string(),
            imap_server: "some-string".to_string(),
            imap_port: Some(4 as i64),
            imap_security: Some(4 as i64),
            username: "some-string".to_string(),
            password: "some-string".to_string(),
            character_set: Some("some-string".to_string()),
            is_token: Some(true),
            owner: Some(4 as i64),
            set_permissions: Some(paperless_api_client::types::SetPermissions {
                view: Some(paperless_api_client::types::View {
                    users: Some(vec![4 as i64]),
                    groups: Some(vec![4 as i64]),
                }),
                change: Some(paperless_api_client::types::Change {
                    users: Some(vec![4 as i64]),
                    groups: Some(vec![4 as i64]),
                }),
            }),
            account_type: Some(4 as i64),
            expiration: Some(chrono::Utc::now()),
        })
        .await?;
    println!("{:?}", result);
    Ok(())
}

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

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

Parameters:

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

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

pub async fn update<'a>( &'a self, id: i64, body: &MailAccountRequest, ) -> Result<MailAccount, Error>

Perform a PUT request to /api/mail_accounts/{id}/.

Parameters:

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

async fn example_mail_accounts_update() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: paperless_api_client::types::MailAccount = client
        .mail_accounts()
        .update(
            4 as i64,
            &paperless_api_client::types::MailAccountRequest {
                name: "some-string".to_string(),
                imap_server: "some-string".to_string(),
                imap_port: Some(4 as i64),
                imap_security: Some(4 as i64),
                username: "some-string".to_string(),
                password: "some-string".to_string(),
                character_set: Some("some-string".to_string()),
                is_token: Some(true),
                owner: Some(4 as i64),
                set_permissions: Some(paperless_api_client::types::SetPermissions {
                    view: Some(paperless_api_client::types::View {
                        users: Some(vec![4 as i64]),
                        groups: Some(vec![4 as i64]),
                    }),
                    change: Some(paperless_api_client::types::Change {
                        users: Some(vec![4 as i64]),
                        groups: Some(vec![4 as i64]),
                    }),
                }),
                account_type: Some(4 as i64),
                expiration: Some(chrono::Utc::now()),
            },
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

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

Perform a DELETE request to /api/mail_accounts/{id}/.

Parameters:

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

async fn example_mail_accounts_destroy() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    client.mail_accounts().destroy(4 as i64).await?;
    Ok(())
}

pub async fn partial_update<'a>( &'a self, id: i64, body: &PatchedMailAccountRequest, ) -> Result<MailAccount, Error>

Perform a PATCH request to /api/mail_accounts/{id}/.

Parameters:

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

async fn example_mail_accounts_partial_update() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: paperless_api_client::types::MailAccount = client
        .mail_accounts()
        .partial_update(
            4 as i64,
            &paperless_api_client::types::PatchedMailAccountRequest {
                name: Some("some-string".to_string()),
                imap_server: Some("some-string".to_string()),
                imap_port: Some(4 as i64),
                imap_security: Some(4 as i64),
                username: Some("some-string".to_string()),
                password: Some("some-string".to_string()),
                character_set: Some("some-string".to_string()),
                is_token: Some(true),
                owner: Some(4 as i64),
                set_permissions: Some(paperless_api_client::types::SetPermissions {
                    view: Some(paperless_api_client::types::View {
                        users: Some(vec![4 as i64]),
                        groups: Some(vec![4 as i64]),
                    }),
                    change: Some(paperless_api_client::types::Change {
                        users: Some(vec![4 as i64]),
                        groups: Some(vec![4 as i64]),
                    }),
                }),
                account_type: Some(4 as i64),
                expiration: Some(chrono::Utc::now()),
            },
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn process<'a>( &'a self, id: i64, body: &MailAccountRequest, ) -> Result<MailAccountProcessResponse, Error>

Perform a POST request to /api/mail_accounts/{id}/process/.

Manually process the selected mail account for new messages.

Parameters:

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

async fn example_mail_accounts_process() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: paperless_api_client::types::MailAccountProcessResponse = client
        .mail_accounts()
        .process(
            4 as i64,
            &paperless_api_client::types::MailAccountRequest {
                name: "some-string".to_string(),
                imap_server: "some-string".to_string(),
                imap_port: Some(4 as i64),
                imap_security: Some(4 as i64),
                username: "some-string".to_string(),
                password: "some-string".to_string(),
                character_set: Some("some-string".to_string()),
                is_token: Some(true),
                owner: Some(4 as i64),
                set_permissions: Some(paperless_api_client::types::SetPermissions {
                    view: Some(paperless_api_client::types::View {
                        users: Some(vec![4 as i64]),
                        groups: Some(vec![4 as i64]),
                    }),
                    change: Some(paperless_api_client::types::Change {
                        users: Some(vec![4 as i64]),
                        groups: Some(vec![4 as i64]),
                    }),
                }),
                account_type: Some(4 as i64),
                expiration: Some(chrono::Utc::now()),
            },
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn test<'a>( &'a self, body: &MailAccountRequest, ) -> Result<MailAccountTestResponse, Error>

Perform a POST request to /api/mail_accounts/test/.

Test a mail account

async fn example_mail_accounts_test() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: paperless_api_client::types::MailAccountTestResponse = client
        .mail_accounts()
        .test(&paperless_api_client::types::MailAccountRequest {
            name: "some-string".to_string(),
            imap_server: "some-string".to_string(),
            imap_port: Some(4 as i64),
            imap_security: Some(4 as i64),
            username: "some-string".to_string(),
            password: "some-string".to_string(),
            character_set: Some("some-string".to_string()),
            is_token: Some(true),
            owner: Some(4 as i64),
            set_permissions: Some(paperless_api_client::types::SetPermissions {
                view: Some(paperless_api_client::types::View {
                    users: Some(vec![4 as i64]),
                    groups: Some(vec![4 as i64]),
                }),
                change: Some(paperless_api_client::types::Change {
                    users: Some(vec![4 as i64]),
                    groups: Some(vec![4 as i64]),
                }),
            }),
            account_type: Some(4 as i64),
            expiration: Some(chrono::Utc::now()),
        })
        .await?;
    println!("{:?}", result);
    Ok(())
}

Trait Implementations

impl Clone for MailAccounts

fn clone(&self) -> MailAccounts

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MailAccounts

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

Formats the value using the given formatter.