category_list/
category_list.rs

1use baidu_netdisk_sdk::{
2    BaiduNetDiskClient, BtListOptions, DocumentListOptions, ImageListOptions, VideoListOptions,
3};
4use log::info;
5use tokio::time::{sleep, Duration};
6
7async fn wait_for_rate_limit() {
8    sleep(Duration::from_millis(500)).await;
9}
10
11fn format_size(bytes: u64) -> String {
12    if bytes < 1024 {
13        format!("{} B", bytes)
14    } else if bytes < 1024 * 1024 {
15        format!("{:.2} KB", bytes as f64 / 1024.0)
16    } else if bytes < 1024 * 1024 * 1024 {
17        format!("{:.2} MB", bytes as f64 / (1024.0 * 1024.0))
18    } else {
19        format!("{:.2} GB", bytes as f64 / (1024.0 * 1024.0 * 1024.0))
20    }
21}
22
23#[tokio::main]
24async fn main() -> Result<(), Box<dyn std::error::Error>> {
25    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
26
27    let client = BaiduNetDiskClient::builder().build()?;
28    info!("Client created successfully");
29
30    client.load_token_from_env()?;
31    info!("Token loaded successfully");
32
33    let test_dir = "/apps/product";
34    let num_per_page = 5;
35
36    println!("=== Baidu NetDisk Fixed Category List Test ===");
37    println!("Directory: {}", test_dir);
38    println!("Items per page: {}\n", num_per_page);
39
40    println!("--- Part 1: Document List (doclist) ---");
41    match client
42        .file()
43        .list_documents(test_dir, 1, num_per_page)
44        .await
45    {
46        Ok(files) => {
47            println!("Found {} documents", files.len());
48            for file in &files {
49                let size_str = file
50                    .size
51                    .map(|s| format_size(s))
52                    .unwrap_or_else(|| "N/A".to_string());
53                println!("  - {} ({})", file.name, size_str);
54            }
55        }
56        Err(e) => {
57            println!("Error: {}", e);
58        }
59    }
60    wait_for_rate_limit().await;
61
62    println!("\n--- Part 2: Image List (imagelist) ---");
63    match client.file().list_images(test_dir, 1, num_per_page).await {
64        Ok(files) => {
65            println!("Found {} images", files.len());
66            for file in &files {
67                let size_str = file
68                    .size
69                    .map(|s| format_size(s))
70                    .unwrap_or_else(|| "N/A".to_string());
71                println!("  - {} ({})", file.name, size_str);
72            }
73        }
74        Err(e) => {
75            println!("Error: {}", e);
76        }
77    }
78    wait_for_rate_limit().await;
79
80    println!("\n--- Part 3: Video List (videolist) ---");
81    match client.file().list_videos(test_dir, 1, num_per_page).await {
82        Ok(files) => {
83            println!("Found {} videos", files.len());
84            for file in &files {
85                let size_str = file
86                    .size
87                    .map(|s| format_size(s))
88                    .unwrap_or_else(|| "N/A".to_string());
89                println!("  - {} ({})", file.name, size_str);
90            }
91        }
92        Err(e) => {
93            println!("Error: {}", e);
94        }
95    }
96    wait_for_rate_limit().await;
97
98    println!("\n--- Part 4: BT List (btlist) ---");
99    match client.file().list_torrents(test_dir, 1, num_per_page).await {
100        Ok(files) => {
101            println!("Found {} torrent files", files.len());
102            for file in &files {
103                let size_str = file
104                    .size
105                    .map(|s| format_size(s))
106                    .unwrap_or_else(|| "N/A".to_string());
107                println!("  - {} ({})", file.name, size_str);
108            }
109        }
110        Err(e) => {
111            println!("Error: {}", e);
112        }
113    }
114    wait_for_rate_limit().await;
115
116    println!("\n=== Test with Options (recursion=1) ===");
117    println!("Directory: {}\n", test_dir);
118
119    println!("--- Document List with recursion ---");
120    let options = DocumentListOptions::new(test_dir)
121        .recursion(1)
122        .num(num_per_page);
123    match client.file().list_documents_with_options(options).await {
124        Ok(files) => {
125            println!("Found {} documents", files.len());
126            for file in &files {
127                let size_str = file
128                    .size
129                    .map(|s| format_size(s))
130                    .unwrap_or_else(|| "N/A".to_string());
131                println!("  - {} ({})", file.name, size_str);
132            }
133        }
134        Err(e) => {
135            println!("Error: {}", e);
136        }
137    }
138    wait_for_rate_limit().await;
139
140    println!("\n--- Image List with recursion ---");
141    let options = ImageListOptions::new(test_dir)
142        .recursion(1)
143        .num(num_per_page);
144    match client.file().list_images_with_options(options).await {
145        Ok(files) => {
146            println!("Found {} images", files.len());
147            for file in &files {
148                let size_str = file
149                    .size
150                    .map(|s| format_size(s))
151                    .unwrap_or_else(|| "N/A".to_string());
152                println!("  - {} ({})", file.name, size_str);
153            }
154        }
155        Err(e) => {
156            println!("Error: {}", e);
157        }
158    }
159    wait_for_rate_limit().await;
160
161    println!("\n--- Video List with recursion ---");
162    let options = VideoListOptions::new(test_dir)
163        .recursion(1)
164        .num(num_per_page);
165    match client.file().list_videos_with_options(options).await {
166        Ok(files) => {
167            println!("Found {} videos", files.len());
168            for file in &files {
169                let size_str = file
170                    .size
171                    .map(|s| format_size(s))
172                    .unwrap_or_else(|| "N/A".to_string());
173                println!("  - {} ({})", file.name, size_str);
174            }
175        }
176        Err(e) => {
177            println!("Error: {}", e);
178        }
179    }
180    wait_for_rate_limit().await;
181
182    println!("\n--- BT List with recursion ---");
183    let options = BtListOptions::new(test_dir).recursion(1).num(num_per_page);
184    match client.file().list_torrents_with_options(options).await {
185        Ok(files) => {
186            println!("Found {} torrent files", files.len());
187            for file in &files {
188                let size_str = file
189                    .size
190                    .map(|s| format_size(s))
191                    .unwrap_or_else(|| "N/A".to_string());
192                println!("  - {} ({})", file.name, size_str);
193            }
194        }
195        Err(e) => {
196            println!("Error: {}", e);
197        }
198    }
199
200    println!("\n=== Test Completed ===");
201
202    Ok(())
203}
category_list/category_list.rs

category_list/
category_list.rs
