Struct Profile 

pub struct Profile {
    pub client: Client,
}

Available on crate feature requests only.

Fields

client: Client

Implementations

impl Profile

pub async fn retrieve<'a>(&'a self) -> Result<Profile, Error>

Perform a GET request to /api/profile/.

User profile view, only available when logged in

async fn example_profile_retrieve() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: paperless_api_client::types::Profile = client.profile().retrieve().await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn partial_update<'a>( &'a self, body: &PatchedProfileRequest, ) -> Result<Profile, Error>

Perform a PATCH request to /api/profile/.

User profile view, only available when logged in

async fn example_profile_partial_update() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: paperless_api_client::types::Profile = client
        .profile()
        .partial_update(&paperless_api_client::types::PatchedProfileRequest {
            email: Some("email@example.com".to_string()),
            password: Some("some-string".to_string()),
            first_name: Some("some-string".to_string()),
            last_name: Some("some-string".to_string()),
        })
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn disconnect_social_account_create<'a>( &'a self, body: &ProfileDisconnectSocialAccountCreateRequestBody, ) -> Result<i64, Error>

Perform a POST request to /api/profile/disconnect_social_account/.

Disconnects a social account provider from the user account

async fn example_profile_disconnect_social_account_create() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: i64 = client
        .profile()
        .disconnect_social_account_create(
            &paperless_api_client::types::ProfileDisconnectSocialAccountCreateRequestBody { id: 4 as i64 },
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn generate_auth_token_create<'a>(&'a self) -> Result<String, Error>

Perform a POST request to /api/profile/generate_auth_token/.

Generates (or re-generates) an auth token, requires a logged in user unlike the default DRF endpoint

async fn example_profile_generate_auth_token_create() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: String = client.profile().generate_auth_token_create().await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn social_account_providers_retrieve<'a>( &'a self, ) -> Result<HashMap<String, Value>, Error>

Perform a GET request to /api/profile/social_account_providers/.

List of social account providers

async fn example_profile_social_account_providers_retrieve() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: std::collections::HashMap<String, serde_json::Value> =
        client.profile().social_account_providers_retrieve().await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn totp_retrieve<'a>( &'a self, ) -> Result<HashMap<String, Value>, Error>

Perform a GET request to /api/profile/totp/.

Generates a new TOTP secret and returns the URL and SVG

async fn example_profile_totp_retrieve() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: std::collections::HashMap<String, serde_json::Value> =
        client.profile().totp_retrieve().await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn totp_create<'a>( &'a self, body: &ProfileTotpCreateRequestBody, ) -> Result<HashMap<String, Value>, Error>

Perform a POST request to /api/profile/totp/.

Validates a TOTP code and activates the TOTP authenticator

async fn example_profile_totp_create() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: std::collections::HashMap<String, serde_json::Value> = client
        .profile()
        .totp_create(&paperless_api_client::types::ProfileTotpCreateRequestBody {
            secret: "some-string".to_string(),
            code: "some-string".to_string(),
        })
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn totp_destroy<'a>(&'a self) -> Result<bool, Error>

Perform a DELETE request to /api/profile/totp/.

Deactivates the TOTP authenticator

async fn example_profile_totp_destroy() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: bool = client.profile().totp_destroy().await?;
    println!("{:?}", result);
    Ok(())
}

Trait Implementations

impl Clone for Profile

fn clone(&self) -> Profile

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Profile

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

Formats the value using the given formatter.