cloudreve-api 0.9.0

A Rust library for interacting with Cloudreve API
Documentation 
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

//! User management for CloudreveAPI

use crate::Error;
use crate::client::UnifiedClient;
use log::debug;

/// Unified user information
#[derive(Debug, Clone)]
pub struct UserInfo {
    pub id: String,
    pub email: String,
    pub nickname: String,
    pub group: Option<String>,
    pub status: Option<String>,
}

/// Unified storage quota
#[derive(Debug, Clone)]
pub struct StorageQuota {
    pub used: u64,
    pub total: u64,
    pub free: u64,
}

/// User management methods for CloudreveAPI
impl super::CloudreveAPI {
    /// Get user information
    ///
    /// Returns unified user information regardless of API version.
    pub async fn get_user_info(&self) -> Result<UserInfo, Error> {
        debug!("Getting user info");

        match &self.inner {
            UnifiedClient::V3(client) => {
                // V3: Get user info from site config
                let config = client.get_site_config().await?;
                if let Some(user) = config.user {
                    Ok(UserInfo {
                        id: user.id,
                        email: user.user_name,
                        nickname: user.nickname,
                        group: Some(user.group.name),
                        status: Some(user.status.to_string()),
                    })
                } else {
                    Err(Error::InvalidResponse(
                        "No user info in site config".to_string(),
                    ))
                }
            }
            UnifiedClient::V4(_client) => {
                // V4: Use a placeholder - actual implementation would call user endpoint
                Err(Error::InvalidResponse(
                    "User info endpoint not yet implemented for V4".to_string(),
                ))
            }
        }
    }

    /// Get storage quota information
    ///
    /// Returns unified storage quota regardless of API version.
    pub async fn get_storage_quota(&self) -> Result<StorageQuota, Error> {
        debug!("Getting storage quota");

        match &self.inner {
            UnifiedClient::V3(client) => {
                let storage = client.get_user_storage().await?;
                let used = storage.used as u64;
                let total = storage.total as u64;
                Ok(StorageQuota {
                    used,
                    total,
                    free: total.saturating_sub(used),
                })
            }
            UnifiedClient::V4(client) => {
                let quota = client.get_user_capacity().await?;
                Ok(StorageQuota {
                    used: quota.used,
                    total: quota.total,
                    free: quota.total.saturating_sub(quota.used),
                })
            }
        }
    }
}