misskey_api/endpoint/drive/files/
create.rs

1use crate::model::{
2    drive::{DriveFile, DriveFolder},
3    id::Id,
4};
5
6use serde::ser::Serializer;
7use serde::Serialize;
8use typed_builder::TypedBuilder;
9
10fn bool_string_option<S: Serializer>(
11    input: &Option<bool>,
12    serializer: S,
13) -> Result<S::Ok, S::Error> {
14    match input {
15        Some(true) => serializer.serialize_some("true"),
16        Some(false) => serializer.serialize_some("false"),
17        None => serializer.serialize_none(),
18    }
19}
20
21#[derive(Serialize, Default, Debug, Clone, TypedBuilder)]
22#[serde(rename_all = "camelCase")]
23#[builder(doc)]
24pub struct Request {
25    #[serde(skip_serializing_if = "Option::is_none")]
26    #[builder(default, setter(strip_option))]
27    pub folder_id: Option<Id<DriveFolder>>,
28    #[serde(skip_serializing_if = "Option::is_none")]
29    #[builder(default, setter(strip_option, into))]
30    pub name: Option<String>,
31    #[serde(
32        skip_serializing_if = "Option::is_none",
33        serialize_with = "bool_string_option"
34    )]
35    #[builder(default, setter(strip_option))]
36    pub is_sensitive: Option<bool>,
37    #[serde(
38        skip_serializing_if = "Option::is_none",
39        serialize_with = "bool_string_option"
40    )]
41    #[builder(default, setter(strip_option))]
42    pub force: Option<bool>,
43}
44
45impl misskey_core::Request for Request {
46    type Response = DriveFile;
47    const ENDPOINT: &'static str = "drive/files/create";
48}
49
50impl misskey_core::UploadFileRequest for Request {}
51
52#[cfg(test)]
53mod tests {
54    use super::Request;
55    use crate::test::{ClientExt, HttpClientExt, TestClient};
56
57    #[tokio::test]
58    async fn request() {
59        let client = TestClient::new();
60        client
61            .test_with_file(Request::default(), mime::TEXT_PLAIN, "test.txt", "hello")
62            .await;
63    }
64
65    #[tokio::test]
66    async fn request_image() {
67        use futures::io::AsyncReadExt;
68
69        let client = TestClient::new();
70        let image_url = client.avatar_url().await;
71        let mut image_data = Vec::new();
72        // TODO: uncomfortable conversion from `Url` to `Uri`
73        isahc::get_async(image_url.to_string())
74            .await
75            .unwrap()
76            .body_mut()
77            .read_to_end(&mut image_data)
78            .await
79            .unwrap();
80
81        client
82            .test_with_file(
83                Request {
84                    folder_id: None,
85                    name: None,
86                    is_sensitive: None,
87                    force: None,
88                },
89                mime::IMAGE_PNG,
90                "icon.png",
91                image_data,
92            )
93            .await;
94    }
95
96    #[tokio::test]
97    async fn request_with_options() {
98        let client = TestClient::new();
99        let folder = client
100            .test(crate::endpoint::drive::folders::create::Request {
101                name: None,
102                parent_id: None,
103            })
104            .await;
105        client
106            .test_with_file(
107                Request {
108                    folder_id: Some(folder.id),
109                    name: Some("hello.txt".to_string()),
110                    is_sensitive: Some(true),
111                    force: Some(true),
112                },
113                mime::TEXT_PLAIN,
114                "test.txt",
115                "hello",
116            )
117            .await;
118    }
119}