1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
use crate::api::ApiClient;
use serde_json::Value;
/// Loading state management for UI views
#[derive(Default)]
pub struct LoadingState {
pub is_loading: bool,
pub last_error: Option<String>,
pub last_load_time: Option<std::time::Instant>,
}
impl LoadingState {
pub fn new() -> Self {
Self::default()
}
pub fn start_loading(&mut self) {
self.is_loading = true;
self.last_error = None;
self.last_load_time = Some(std::time::Instant::now());
}
pub fn finish_loading(&mut self, error: Option<String>) {
self.is_loading = false;
self.last_error = error;
}
pub fn finish_success(&mut self) {
self.finish_loading(None);
}
pub fn finish_error(&mut self, error: String) {
self.finish_loading(Some(error));
}
#[allow(dead_code)]
pub fn has_error(&self) -> bool {
self.last_error.is_some()
}
pub fn get_error(&self) -> Option<&str> {
self.last_error.as_deref()
}
#[allow(dead_code)]
pub fn should_auto_retry(&self, retry_after_seconds: u64) -> bool {
if let (Some(error), Some(load_time)) = (&self.last_error, self.last_load_time) {
!error.is_empty() && load_time.elapsed().as_secs() > retry_after_seconds
} else {
false
}
}
}
/// Data loader for assets
pub struct DataLoader;
impl DataLoader {
pub fn load_assets(
api_client: &ApiClient,
limit: Option<u32>,
where_clause: Option<Value>,
filter: Option<Value>,
) -> Result<Vec<Value>, String> {
log::info!(
"Loading inventory assets (limit={:?}, where={:?}, filter={:?})...",
limit,
where_clause,
filter
);
// Use select_with_joins to load assets with zone and category data
let response = api_client
.select_with_joins(
"assets",
None, // columns (None = all)
where_clause,
filter,
None, // order_by
limit,
None, // joins (None = use default joins)
)
.map_err(|e| format!("Failed to load assets: {}", e))?;
if !response.success {
// Check if this is a database timeout error
if ApiClient::is_database_timeout_error(&response.error) {
log::warn!("Database timeout detected while loading assets");
}
let error_msg = format!("API error: {:?}", response.error);
log::error!("{}", error_msg);
return Err(error_msg);
}
let assets = response.data.unwrap_or_default();
log::info!("Loaded {} assets successfully (with JOINs)", assets.len());
Ok(assets)
}
}
|
