one_doc 0.1.1

#![recursion_limit = "1024"]
/// Generated by Sideko (sideko.dev)
mod auth;
pub mod blocking;
pub mod error_enums;
pub mod request_types;
pub mod result;
pub mod schemas;
use request_types::*;
use schemas::*;
use reqwest::Client as ReqwestClient;
use reqwest::RequestBuilder as ReqwestRequestBuilder;
use reqwest::multipart as reqwest_multipart;
use std::collections::BTreeMap;
#[derive(Clone, Debug)]
pub struct SidekoClient {
    pub base_url: String,
    auth: BTreeMap<String, auth::AuthProvider>,
}
impl Default for SidekoClient {
    fn default() -> Self {
        Self {
            base_url: "https://app.onedoclabs.com".to_string(),
            auth: BTreeMap::new(),
        }
    }
}
impl SidekoClient {
    /// Authentication  builder function to store api-key credentials in the client
    pub fn with_api_key_auth(mut self, val: &str) -> Self {
        self.auth
            .insert(
                "ApiKeyAuth".to_string(),
                auth::AuthProvider::KeyHeader("x-api-key".to_string(), val.to_string()),
            );
        self
    }
    fn builder_with_auth(
        &self,
        mut req_builder: ReqwestRequestBuilder,
        auth_names: &[&str],
    ) -> ReqwestRequestBuilder {
        for auth_name in auth_names {
            if let Some(provider) = self.auth.get(&auth_name.to_string()) {
                req_builder = provider.add_auth(req_builder);
            }
        }
        req_builder
    }
    fn async_multipart_file(
        &self,
        path: &str,
    ) -> std::io::Result<reqwest_multipart::Part> {
        let path: &std::path::Path = path.as_ref();
        let file_name = path
            .file_name()
            .map(|filename| filename.to_string_lossy().into_owned());
        let file_bytes = std::fs::read(path)?;
        Ok(
            reqwest_multipart::Part::bytes(file_bytes)
                .file_name(file_name.unwrap_or_default()),
        )
    }
    /// This route is responsible for generating a PDF from a bucket.  It expects a JSON body with details of the bucket, user credentials, and PDF generation options.
    pub async fn post_api_docs_generate(
        &self,
        request: PostApiDocsGenerateRequest,
    ) -> result::Result<BinaryResponse, error_enums::PostApiDocsGenerateErrors> {
        let endpoint = "/api/docs/generate";
        let url = format!("{}{}", self.base_url, endpoint);
        let query_params: Vec<(&str, String)> = vec![];
        let unauthed_builder = ReqwestClient::default().post(&url).query(&query_params);
        let authed_builder = self.builder_with_auth(unauthed_builder, &["ApiKeyAuth"]);
        let request_body: serde_json::Value = serde_json::to_value(request.data)
            .map_err(result::Error::Serialize)?;
        let response = authed_builder
            .json(&request_body)
            .send()
            .await
            .map_err(result::Error::Dispatch)?;
        let status_code = response.status().as_u16();
        match status_code {
            200 => {
                let res_bytes = response
                    .bytes()
                    .await
                    .map_err(result::Error::ResponseBytes)?;
                let data = BinaryResponse {
                    content: res_bytes,
                };
                Ok(data)
            }
            400 => {
                let response_text = response.text().await.unwrap_or_default();
                let data = serde_json::from_str::<serde_json::Value>(&response_text)
                    .map_err(|serde_err| result::Error::UnexpectedResponseBody {
                        status_code,
                        method: "POST".to_string(),
                        url: url.to_string(),
                        response_text,
                        expected_signature: "serde_json::Value".to_string(),
                        serde_err,
                    })?;
                Err(result::Error::Response {
                    status_code,
                    method: "POST".to_string(),
                    url: url.to_string(),
                    data: error_enums::PostApiDocsGenerateErrors::Status400(data),
                })
            }
            401 => {
                let response_text = response.text().await.unwrap_or_default();
                let data = serde_json::from_str::<serde_json::Value>(&response_text)
                    .map_err(|serde_err| result::Error::UnexpectedResponseBody {
                        status_code,
                        method: "POST".to_string(),
                        url: url.to_string(),
                        response_text,
                        expected_signature: "serde_json::Value".to_string(),
                        serde_err,
                    })?;
                Err(result::Error::Response {
                    status_code,
                    method: "POST".to_string(),
                    url: url.to_string(),
                    data: error_enums::PostApiDocsGenerateErrors::Status401(data),
                })
            }
            404 => {
                let response_text = response.text().await.unwrap_or_default();
                let data = serde_json::from_str::<serde_json::Value>(&response_text)
                    .map_err(|serde_err| result::Error::UnexpectedResponseBody {
                        status_code,
                        method: "POST".to_string(),
                        url: url.to_string(),
                        response_text,
                        expected_signature: "serde_json::Value".to_string(),
                        serde_err,
                    })?;
                Err(result::Error::Response {
                    status_code,
                    method: "POST".to_string(),
                    url: url.to_string(),
                    data: error_enums::PostApiDocsGenerateErrors::Status404(data),
                })
            }
            500 => {
                let response_text = response.text().await.unwrap_or_default();
                let data = serde_json::from_str::<serde_json::Value>(&response_text)
                    .map_err(|serde_err| result::Error::UnexpectedResponseBody {
                        status_code,
                        method: "POST".to_string(),
                        url: url.to_string(),
                        response_text,
                        expected_signature: "serde_json::Value".to_string(),
                        serde_err,
                    })?;
                Err(result::Error::Response {
                    status_code,
                    method: "POST".to_string(),
                    url: url.to_string(),
                    data: error_enums::PostApiDocsGenerateErrors::Status500(data),
                })
            }
            _ => {
                let expected_status_codes: Vec<String> = vec![
                    "200".to_string(), "400".to_string(), "401".to_string(), "404"
                    .to_string(), "500".to_string(),
                ];
                Err(result::Error::UnexpectedStatus {
                    status_code,
                    method: "".to_string(),
                    url: url.to_string(),
                    response,
                    expected_status_codes,
                })
            }
        }
    }
    /// This endpoint creates a bucket for the html and all specified assets. It returns signed urls to the buckets.
    pub async fn post_api_docs_initiate(
        &self,
        request: PostApiDocsInitiateRequest,
    ) -> result::Result<
        PostApiDocsInitiateResponse,
        error_enums::PostApiDocsInitiateErrors,
    > {
        let endpoint = "/api/docs/initiate";
        let url = format!("{}{}", self.base_url, endpoint);
        let query_params: Vec<(&str, String)> = vec![];
        let unauthed_builder = ReqwestClient::default().post(&url).query(&query_params);
        let authed_builder = self.builder_with_auth(unauthed_builder, &["ApiKeyAuth"]);
        let request_body: serde_json::Value = serde_json::to_value(request.data)
            .map_err(result::Error::Serialize)?;
        let response = authed_builder
            .json(&request_body)
            .send()
            .await
            .map_err(result::Error::Dispatch)?;
        let status_code = response.status().as_u16();
        match status_code {
            200 => {
                let response_text = response.text().await.unwrap_or_default();
                let data = serde_json::from_str::<
                    PostApiDocsInitiateResponse,
                >(&response_text)
                    .map_err(|serde_err| result::Error::UnexpectedResponseBody {
                        status_code,
                        method: "POST".to_string(),
                        url: url.to_string(),
                        response_text,
                        expected_signature: "PostApiDocsInitiateResponse".to_string(),
                        serde_err,
                    })?;
                Ok(data)
            }
            401 => {
                let response_text = response.text().await.unwrap_or_default();
                let data = serde_json::from_str::<serde_json::Value>(&response_text)
                    .map_err(|serde_err| result::Error::UnexpectedResponseBody {
                        status_code,
                        method: "POST".to_string(),
                        url: url.to_string(),
                        response_text,
                        expected_signature: "serde_json::Value".to_string(),
                        serde_err,
                    })?;
                Err(result::Error::Response {
                    status_code,
                    method: "POST".to_string(),
                    url: url.to_string(),
                    data: error_enums::PostApiDocsInitiateErrors::Status401(data),
                })
            }
            500 => {
                let response_text = response.text().await.unwrap_or_default();
                let data = serde_json::from_str::<serde_json::Value>(&response_text)
                    .map_err(|serde_err| result::Error::UnexpectedResponseBody {
                        status_code,
                        method: "POST".to_string(),
                        url: url.to_string(),
                        response_text,
                        expected_signature: "serde_json::Value".to_string(),
                        serde_err,
                    })?;
                Err(result::Error::Response {
                    status_code,
                    method: "POST".to_string(),
                    url: url.to_string(),
                    data: error_enums::PostApiDocsInitiateErrors::Status500(data),
                })
            }
            _ => {
                let expected_status_codes: Vec<String> = vec![
                    "200".to_string(), "401".to_string(), "500".to_string(),
                ];
                Err(result::Error::UnexpectedStatus {
                    status_code,
                    method: "".to_string(),
                    url: url.to_string(),
                    response,
                    expected_status_codes,
                })
            }
        }
    }
}