use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RenameResult {
pub original_filename: String,
pub suggested_filename: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub folder_path: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub confidence: Option<f64>,
}
#[derive(Debug, Clone, Default)]
pub struct RenameOptions {
pub template: Option<String>,
}
impl RenameOptions {
pub fn new() -> Self {
Self::default()
}
pub fn with_template(mut self, template: impl Into<String>) -> Self {
self.template = Some(template.into());
self
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum SplitMode {
#[default]
Auto,
Pages,
Blank,
}
impl std::fmt::Display for SplitMode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
SplitMode::Auto => write!(f, "auto"),
SplitMode::Pages => write!(f, "pages"),
SplitMode::Blank => write!(f, "blank"),
}
}
}
#[derive(Debug, Clone, Default)]
pub struct PdfSplitOptions {
pub mode: Option<SplitMode>,
pub pages_per_split: Option<u32>,
}
impl PdfSplitOptions {
pub fn new() -> Self {
Self::default()
}
pub fn with_mode(mut self, mode: SplitMode) -> Self {
self.mode = Some(mode);
self
}
pub fn with_pages_per_split(mut self, pages: u32) -> Self {
self.pages_per_split = Some(pages);
self
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SplitDocument {
pub index: u32,
pub filename: String,
pub pages: String,
pub download_url: String,
pub size: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PdfSplitResult {
pub original_filename: String,
pub documents: Vec<SplitDocument>,
pub total_pages: u32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum JobStatus {
Pending,
Processing,
Completed,
Failed,
}
impl JobStatus {
pub fn is_in_progress(&self) -> bool {
matches!(self, JobStatus::Pending | JobStatus::Processing)
}
pub fn is_finished(&self) -> bool {
matches!(self, JobStatus::Completed | JobStatus::Failed)
}
}
impl std::fmt::Display for JobStatus {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
JobStatus::Pending => write!(f, "pending"),
JobStatus::Processing => write!(f, "processing"),
JobStatus::Completed => write!(f, "completed"),
JobStatus::Failed => write!(f, "failed"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct JobStatusResponse {
pub job_id: String,
pub status: JobStatus,
#[serde(skip_serializing_if = "Option::is_none")]
pub progress: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub error: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub result: Option<PdfSplitResult>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct PdfSplitResponse {
pub status_url: String,
}
#[derive(Debug, Clone, Default)]
pub struct ExtractOptions {
pub schema: Option<HashMap<String, serde_json::Value>>,
pub prompt: Option<String>,
}
impl ExtractOptions {
pub fn new() -> Self {
Self::default()
}
pub fn with_schema(mut self, schema: HashMap<String, serde_json::Value>) -> Self {
self.schema = Some(schema);
self
}
pub fn with_prompt(mut self, prompt: impl Into<String>) -> Self {
self.prompt = Some(prompt.into());
self
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExtractResult {
pub data: HashMap<String, serde_json::Value>,
pub confidence: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Team {
pub id: String,
pub name: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct User {
pub id: String,
pub email: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub credits: Option<i32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub team: Option<Team>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_rename_result_deserialization() {
let json = r#"{
"originalFilename": "document.pdf",
"suggestedFilename": "Invoice_2024_001.pdf",
"folderPath": "Invoices/2024",
"confidence": 0.95
}"#;
let result: RenameResult = serde_json::from_str(json).unwrap();
assert_eq!(result.original_filename, "document.pdf");
assert_eq!(result.suggested_filename, "Invoice_2024_001.pdf");
assert_eq!(result.folder_path, Some("Invoices/2024".to_string()));
assert_eq!(result.confidence, Some(0.95));
}
#[test]
fn test_job_status_is_in_progress() {
assert!(JobStatus::Pending.is_in_progress());
assert!(JobStatus::Processing.is_in_progress());
assert!(!JobStatus::Completed.is_in_progress());
assert!(!JobStatus::Failed.is_in_progress());
}
#[test]
fn test_split_mode_display() {
assert_eq!(SplitMode::Auto.to_string(), "auto");
assert_eq!(SplitMode::Pages.to_string(), "pages");
assert_eq!(SplitMode::Blank.to_string(), "blank");
}
}