modio/request/files/
add_file.rs

1use std::future::IntoFuture;
2use std::path::Path;
3
4use serde_derive::Serialize;
5
6use crate::client::Client;
7use crate::error;
8use crate::request::multipart::{Form, Part};
9use crate::request::{Output, RequestBuilder, Route};
10use crate::response::ResponseFuture;
11use crate::types::files::File;
12use crate::types::id::{GameId, ModId};
13
14/// Upload a file for a mod.
15pub struct AddFile<'a> {
16    http: &'a Client,
17    game_id: GameId,
18    mod_id: ModId,
19    filedata: Option<Part>,
20    fields: AddFileFields<'a>,
21}
22
23#[derive(Serialize)]
24struct AddFileFields<'a> {
25    #[serde(skip_serializing_if = "Option::is_none")]
26    active: Option<bool>,
27    #[serde(skip_serializing_if = "Option::is_none")]
28    changelog: Option<&'a str>,
29    #[serde(skip_serializing_if = "Option::is_none")]
30    filehash: Option<&'a str>,
31    #[serde(skip_serializing_if = "Option::is_none")]
32    metadata_blob: Option<&'a str>,
33    #[serde(skip_serializing_if = "Option::is_none")]
34    version: Option<&'a str>,
35}
36
37impl<'a> AddFile<'a> {
38    pub(crate) const fn new(http: &'a Client, game_id: GameId, mod_id: ModId) -> Self {
39        Self {
40            http,
41            game_id,
42            mod_id,
43            filedata: None,
44            fields: AddFileFields {
45                active: None,
46                changelog: None,
47                filehash: None,
48                metadata_blob: None,
49                version: None,
50            },
51        }
52    }
53
54    pub fn file<P: AsRef<Path>>(self, file: P) -> Self {
55        self.file_with_name(file, "modfile.zip")
56    }
57
58    pub fn file_with_name<P: AsRef<Path>>(mut self, file: P, filename: &str) -> Self {
59        let part = Part::file(file, filename).mime(mime::APPLICATION_OCTET_STREAM);
60        self.filedata = Some(part);
61        self
62    }
63
64    pub const fn active(mut self, active: bool) -> Self {
65        self.fields.active = Some(active);
66        self
67    }
68
69    pub const fn changelog(mut self, changelog: &'a str) -> Self {
70        self.fields.changelog = Some(changelog);
71        self
72    }
73
74    pub const fn filehash(mut self, filehash: &'a str) -> Self {
75        self.fields.filehash = Some(filehash);
76        self
77    }
78
79    pub const fn metadata_blob(mut self, metadata: &'a str) -> Self {
80        self.fields.metadata_blob = Some(metadata);
81        self
82    }
83
84    pub const fn version(mut self, version: &'a str) -> Self {
85        self.fields.version = Some(version);
86        self
87    }
88}
89
90impl IntoFuture for AddFile<'_> {
91    type Output = Output<File>;
92    type IntoFuture = ResponseFuture<File>;
93
94    fn into_future(self) -> Self::IntoFuture {
95        let route = Route::AddFile {
96            game_id: self.game_id,
97            mod_id: self.mod_id,
98        };
99
100        let mut form = Form::new();
101        if let Some(value) = self.filedata {
102            form = form.part("filedata", value);
103        }
104        if let Some(value) = self.fields.active {
105            form = form.text("active", value.to_string());
106        }
107        if let Some(value) = self.fields.changelog {
108            form = form.text("changelog", value.to_owned());
109        }
110        if let Some(value) = self.fields.metadata_blob {
111            form = form.text("metadata_blob", value.to_owned());
112        }
113        if let Some(value) = self.fields.version {
114            form = form.text("version", value.to_owned());
115        }
116
117        form = match serde_json::to_vec(&self.fields) {
118            Ok(json) => form.part("input_json", Part::bytes(json.into())),
119            Err(err) => return ResponseFuture::failed(error::builder(err)),
120        };
121
122        match RequestBuilder::from_route(&route).multipart(form) {
123            Ok(req) => self.http.request(req),
124            Err(err) => ResponseFuture::failed(err),
125        }
126    }
127}