Struct AutomationHandler 

pub struct AutomationHandler { /* private fields */ }

Handler for automation operations

Implementations

impl AutomationHandler

pub fn new(client: FilesClient) -> Self

Create a new automation handler

pub async fn list( &self, cursor: Option<&str>, per_page: Option<i64>, automation: Option<&str>, ) -> Result<(Vec<AutomationEntity>, PaginationInfo)>

List all automations

Returns a paginated list of automation workflows with optional filtering by automation type.

Arguments

• cursor - Pagination cursor from previous response
• per_page - Number of results per page (max 10,000)
• automation - Filter by automation type (e.g., “copy_file”, “move_file”)

Returns

A tuple containing:

• Vector of AutomationEntity objects
• PaginationInfo with cursors for next/previous pages

Example

use files_sdk::{FilesClient, AutomationHandler};

let client = FilesClient::builder().api_key("key").build()?;
let handler = AutomationHandler::new(client);

// List all automations
let (automations, pagination) = handler.list(None, Some(50), None).await?;

for automation in automations {
    println!("{}: {} - Disabled: {}",
        automation.name.unwrap_or_default(),
        automation.automation.unwrap_or_default(),
        automation.disabled.unwrap_or(false));
}

// Filter by type
let (copy_automations, _) = handler.list(None, None, Some("copy_file")).await?;

pub async fn get(&self, id: i64) -> Result<AutomationEntity>

Get details of a specific automation

Arguments

• id - Automation ID

Returns

An AutomationEntity with complete automation configuration

Example

use files_sdk::{FilesClient, AutomationHandler};

let client = FilesClient::builder().api_key("key").build()?;
let handler = AutomationHandler::new(client);

let automation = handler.get(12345).await?;
println!("Automation: {}", automation.name.unwrap_or_default());
println!("Schedule: {}", automation.human_readable_schedule.unwrap_or_default());

pub async fn create( &self, automation: &str, source: Option<&str>, destination: Option<&str>, destinations: Option<Vec<String>>, interval: Option<&str>, path: Option<&str>, trigger: Option<&str>, ) -> Result<AutomationEntity>

Create a new automation workflow

Creates an automation that performs file operations automatically based on schedules or triggers.

Arguments

• automation - Type of automation: “copy_file”, “move_file”, “delete_file”, “create_folder”, “run_sync”, “import_file” (required)
• source - Source path or glob pattern (e.g., “/uploads/*.pdf”)
• destination - Single destination path
• destinations - Multiple destination paths (use instead of destination)
• interval - Schedule interval: “day”, “week”, “month”, “year”
• path - Base path where automation operates
• trigger - Trigger type: “daily”, “custom”, “webhook”, “email”, “action”, “interval”

Returns

The newly created AutomationEntity

Example

use files_sdk::{FilesClient, AutomationHandler};

let client = FilesClient::builder().api_key("key").build()?;
let handler = AutomationHandler::new(client);

// Create daily automation to archive PDFs
let automation = handler.create(
    "copy_file",
    Some("/uploads/*.pdf"),
    Some("/archive/daily/"),
    None,
    Some("day"),
    Some("/uploads"),
    Some("daily")
).await?;

println!("Created automation: {}", automation.id.unwrap());

pub async fn update( &self, id: i64, source: Option<&str>, destination: Option<&str>, interval: Option<&str>, disabled: Option<bool>, ) -> Result<AutomationEntity>

Update an existing automation

Modifies automation configuration. Only provided fields are updated; omitted fields remain unchanged.

Arguments

• id - Automation ID to update
• source - New source path or glob pattern
• destination - New destination path
• interval - New schedule interval
• disabled - Enable (false) or disable (true) the automation

Returns

The updated AutomationEntity

Example

use files_sdk::{FilesClient, AutomationHandler};

let client = FilesClient::builder().api_key("key").build()?;
let handler = AutomationHandler::new(client);

// Disable an automation temporarily
let automation = handler.update(
    12345,
    None,
    None,
    None,
    Some(true)
).await?;

println!("Automation disabled");

pub async fn delete(&self, id: i64) -> Result<()>

Delete an automation permanently

Removes the automation and stops all scheduled or triggered executions. This operation cannot be undone.

Arguments

• id - Automation ID to delete

Example

use files_sdk::{FilesClient, AutomationHandler};

let client = FilesClient::builder().api_key("key").build()?;
let handler = AutomationHandler::new(client);

handler.delete(12345).await?;
println!("Automation deleted");

pub async fn manual_run(&self, id: i64) -> Result<Value>

Manually trigger an automation execution

Immediately executes the automation regardless of its schedule or trigger settings. Useful for testing or running an automation on-demand.

Arguments

• id - Automation ID to execute

Returns

JSON response with execution details and status

Example

use files_sdk::{FilesClient, AutomationHandler};

let client = FilesClient::builder().api_key("key").build()?;
let handler = AutomationHandler::new(client);

// Manually trigger the automation to run now
let result = handler.manual_run(12345).await?;
println!("Automation executed: {:?}", result);