libquarkpan 0.4.0

Async Rust client library for Quark Drive upload, download, listing, and folder creation
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

mod api;
mod download;
mod error;
mod folder;
mod list;
mod model;
mod rename;
mod transfer;
mod upload;

#[cfg(not(any(
    feature = "default-tls",
    feature = "native-tls",
    feature = "native-tls-vendored",
    feature = "rustls",
    feature = "rustls-no-provider",
)))]
compile_error!("enable exactly one TLS backend feature for libquarkpan");

#[cfg(any(
    all(feature = "default-tls", feature = "native-tls"),
    all(feature = "default-tls", feature = "native-tls-vendored"),
    all(feature = "default-tls", feature = "rustls"),
    all(feature = "default-tls", feature = "rustls-no-provider"),
    all(feature = "native-tls", feature = "native-tls-vendored"),
    all(feature = "native-tls", feature = "rustls"),
    all(feature = "native-tls", feature = "rustls-no-provider"),
    all(feature = "native-tls-vendored", feature = "rustls"),
    all(feature = "native-tls-vendored", feature = "rustls-no-provider"),
    all(feature = "rustls", feature = "rustls-no-provider"),
))]
compile_error!("enable only one TLS backend feature for libquarkpan");

pub use crate::download::{DownloadBuilder, DownloadRequest};
pub use crate::error::{QuarkPanError, Result};
pub use crate::folder::CreateFolderBuilder;
pub use crate::list::{ListBuilder, ListRequest};
pub use crate::model::{
    DownloadInfo, Fid, ListPage, QuarkEntry, UploadComplete, UploadPrepareResult, UploadResume,
    UploadResumeState, UploadSession,
};
pub use crate::rename::{RenameBuilder, RenameRequest};
pub use crate::transfer::{ProgressStream, TransferControl, TransferProgress};
pub use crate::upload::UploadBuilder;

use std::sync::Arc;

use api::{ApiClient, ApiConfig};
use dashmap::DashMap;

#[derive(Clone)]
pub struct QuarkPan {
    inner: Arc<QuarkPanInner>,
}

struct QuarkPanInner {
    api: ApiClient,
}

impl QuarkPan {
    /// Creates a builder for constructing a [`QuarkPan`] client.
    pub fn builder() -> QuarkPanBuilder {
        QuarkPanBuilder::default()
    }

    /// Creates a builder for downloading by fid.
    pub fn download(&self) -> DownloadBuilder {
        DownloadBuilder::new(self.inner.clone())
    }

    /// Creates a builder for preparing a file upload.
    pub fn upload(&self) -> UploadBuilder {
        UploadBuilder::new(self.inner.clone())
    }

    /// Creates a builder for creating a folder in Quark Drive.
    pub fn create_folder(&self) -> CreateFolderBuilder {
        CreateFolderBuilder::new(self.inner.clone())
    }

    /// Creates a builder for listing entries by parent directory fid.
    pub fn list(&self) -> ListBuilder {
        ListBuilder::new(self.inner.clone())
    }

    /// Creates a builder for renaming an entry by fid.
    pub fn rename(&self) -> RenameBuilder {
        RenameBuilder::new(self.inner.clone())
    }

    /// Deletes one or more entries by fid.
    pub async fn delete<S>(&self, fids: &[S]) -> Result<()>
    where
        S: AsRef<str>,
    {
        self.inner.api.delete(fids).await
    }
}

#[derive(Default)]
pub struct QuarkPanBuilder {
    cookie: Option<String>,
    api_base_url: Option<String>,
}

impl QuarkPanBuilder {
    /// Sets the Quark cookie used for all authenticated requests.
    pub fn cookie(mut self, cookie: impl Into<String>) -> Self {
        self.cookie = Some(cookie.into());
        self
    }

    /// Overrides the default Quark Drive API base url.
    pub fn api_base_url(mut self, api_base_url: impl Into<String>) -> Self {
        self.api_base_url = Some(api_base_url.into());
        self
    }

    /// Prepares the final [`QuarkPan`] client.
    pub fn prepare(self) -> Result<QuarkPan> {
        let cookie = self
            .cookie
            .ok_or_else(|| QuarkPanError::missing_field("cookie"))?;
        let cookie_map = Arc::new(DashMap::new());
        for pair in cookie.split(';') {
            if let Some((k, v)) = pair.trim().split_once('=') {
                cookie_map.insert(k.trim().to_string(), v.trim().to_string());
            }
        }
        if cookie_map.is_empty() {
            return Err(QuarkPanError::invalid_argument(
                "cookie must contain at least one key=value pair",
            ));
        }
        let api = ApiClient::new(ApiConfig {
            api_base_url: self
                .api_base_url
                .unwrap_or_else(|| "https://drive.quark.cn".to_string()),
            cookie: cookie_map,
        })?;
        Ok(QuarkPan {
            inner: Arc::new(QuarkPanInner { api }),
        })
    }
}