Struct Tasks 

pub struct Tasks {
    pub client: Client,
}

Available on crate feature requests only.

Fields

client: Client

Implementations

impl Tasks

pub async fn list<'a>( &'a self, acknowledged: Option<bool>, ordering: Option<String>, status: Option<Status>, task_id: Option<String>, task_name: Option<ListTaskName>, type_: Option<Type>, ) -> Result<Vec<TasksView>, Error>

Perform a GET request to /api/tasks/.

Parameters:

• acknowledged: Option<bool>: Acknowledged
• ordering: Option<String>: Which field to use when ordering the results.
• status: Option<crate::types::Status>: Current state of the task being run

• FAILURE - FAILURE
• PENDING - PENDING
• RECEIVED - RECEIVED
• RETRY - RETRY
• REVOKED - REVOKED
• STARTED - STARTED
• SUCCESS - SUCCESS

• task_id: Option<String>: Filter tasks by Celery UUID
• task_name: Option<crate::types::ListTaskName>: Name of the task that was run

• consume_file - Consume File
• train_classifier - Train Classifier
• check_sanity - Check Sanity
• index_optimize - Index Optimize

• type_: Option<crate::types::Type>: The type of task that was run

• auto_task - Auto Task
• scheduled_task - Scheduled Task
• manual_task - Manual Task

async fn example_tasks_list() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: Vec<paperless_api_client::types::TasksView> = client
        .tasks()
        .list(
            Some(true),
            Some("some-string".to_string()),
            Some(paperless_api_client::types::Status::Revoked),
            Some("some-string".to_string()),
            Some(paperless_api_client::types::OptionListTaskName::IndexOptimize),
            Some(paperless_api_client::types::Type::ManualTask),
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn retrieve<'a>( &'a self, id: i64, task_id: Option<String>, ) -> Result<TasksView, Error>

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

Parameters:

• id: i64: A unique integer value identifying this paperless task. (required)
• task_id: Option<String>: Filter tasks by Celery UUID

async fn example_tasks_retrieve() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: paperless_api_client::types::TasksView = client
        .tasks()
        .retrieve(4 as i64, Some("some-string".to_string()))
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn acknowledge<'a>( &'a self, task_id: Option<String>, body: &AcknowledgeTasksRequestBody, ) -> Result<AcknowledgeTasks, Error>

Perform a POST request to /api/tasks/acknowledge/.

Acknowledge a list of tasks

Parameters:

• task_id: Option<String>: Filter tasks by Celery UUID

async fn example_tasks_acknowledge() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: paperless_api_client::types::AcknowledgeTasks = client
        .tasks()
        .acknowledge(
            Some("some-string".to_string()),
            &paperless_api_client::types::AcknowledgeTasksRequestBody {
                tasks: vec![4 as i64],
            },
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn run_create<'a>( &'a self, task_id: Option<String>, body: &TasksViewRequest, ) -> Result<TasksView, Error>

Perform a POST request to /api/tasks/run/.

Parameters:

• task_id: Option<String>: Filter tasks by Celery UUID

async fn example_tasks_run_create() -> anyhow::Result<()> {
    let client = paperless_api_client::Client::new_from_env();
    let result: paperless_api_client::types::TasksView = client
        .tasks()
        .run_create(
            Some("some-string".to_string()),
            &paperless_api_client::types::TasksViewRequest {
                task_id: "some-string".to_string(),
                task_name: Some(paperless_api_client::types::TaskName::CheckSanity),
                task_file_name: Some("some-string".to_string()),
                date_created: Some(chrono::Utc::now()),
                date_done: Some(chrono::Utc::now()),
                type_: Some(paperless_api_client::types::TasksViewTypeEnum::ScheduledTask),
                status: Some(paperless_api_client::types::StatusEnum::Revoked),
                result: Some("some-string".to_string()),
                acknowledged: Some(true),
                owner: Some(4 as i64),
            },
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

Trait Implementations

impl Clone for Tasks

fn clone(&self) -> Tasks

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tasks

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

Formats the value using the given formatter.