octocrate_core/
no_content_request.rs

1#[cfg(feature = "file-body")]
2use crate::utils::file_to_body;
3use crate::{
4  api_config::SharedAPIConfig,
5  error::{APIErrorResponse, Error},
6  no_content_request_builder::NoContentRequestBuilder,
7};
8#[cfg(feature = "multipart")]
9use reqwest::multipart::Form;
10use std::marker::PhantomData;
11#[cfg(feature = "file-body")]
12use tokio::fs::File;
13
14pub struct NoContentRequest<Body, Query> {
15  pub(crate) builder: reqwest::RequestBuilder,
16  pub(crate) api_config: SharedAPIConfig,
17  pub(crate) _body: PhantomData<Body>,
18  pub(crate) _query: PhantomData<Query>,
19}
20
21impl<Body, Query> NoContentRequest<Body, Query>
22where
23  Body: serde::Serialize,
24  Query: serde::Serialize,
25{
26  pub fn builder(config: &SharedAPIConfig) -> NoContentRequestBuilder<Body, Query> {
27    NoContentRequestBuilder::new(config)
28  }
29
30  pub fn query(mut self, query: &Query) -> Self {
31    self.builder = self.builder.query(query);
32
33    self
34  }
35
36  #[cfg(feature = "multipart")]
37  pub fn multipart(mut self, form: Form) -> Self {
38    self.builder = self.builder.multipart(form);
39
40    self
41  }
42
43  pub fn header<K, V>(mut self, key: K, value: V) -> Self
44  where
45    K: Into<String>,
46    V: Into<String>,
47  {
48    let key = key.into();
49    let value = value.into();
50    self.builder = self.builder.header(key, value);
51
52    self
53  }
54
55  #[cfg(feature = "file-body")]
56  pub fn file(mut self, file: File) -> Self {
57    self.builder = self.builder.body(file_to_body(file));
58
59    self
60  }
61
62  pub fn body(mut self, body: &Body) -> Self {
63    self.builder = self.builder.json(body);
64
65    self
66  }
67
68  pub async fn send(self) -> Result<(), Error> {
69    let mut builder = self
70      .builder
71      .header("User-Agent", "octocrate")
72      .header("Accept", "application/vnd.github+json");
73
74    if let Some(token) = &self.api_config.token {
75      if let Some(token) = token.get_token() {
76        builder = builder.header("Authorization", format!("Bearer {}", token));
77      }
78    }
79
80    let res = builder.send().await;
81    match res {
82      Ok(res) => {
83        let status = res.status();
84        if !status.is_success() {
85          if let Ok(error_response) = res.json::<APIErrorResponse>().await {
86            return Err(Error::RequestFailed(error_response));
87          }
88
89          let err_msg = format!("Request failed with {}", status);
90          return Err(Error::Error(err_msg));
91        }
92
93        Ok(())
94      }
95      Err(err) => Err(Error::Error(err.to_string())),
96    }
97  }
98}