harbor-api 2.0.0

/*
 * Harbor API
 *
 * These APIs provide services for manipulating Harbor project.
 *
 * The version of the OpenAPI document: 2.0
 * 
 * Generated by: https://openapi-generator.tech
 */


use reqwest;
use serde::{Deserialize, Serialize, de::Error as _};
use crate::{apis::ResponseContent, models};
use super::{Error, configuration, ContentType};

/// struct for passing parameters to the method [`get_cert`]
#[derive(Clone, Debug)]
pub struct GetCertParams {
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`get_system_info`]
#[derive(Clone, Debug)]
pub struct GetSystemInfoParams {
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`get_volumes`]
#[derive(Clone, Debug)]
pub struct GetVolumesParams {
    /// An unique ID for the request
    pub x_request_id: Option<String>
}


/// struct for typed errors of method [`get_cert`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCertError {
    Status404(),
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_system_info`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSystemInfoError {
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_volumes`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetVolumesError {
    Status401(models::Errors),
    Status403(models::Errors),
    Status404(models::Errors),
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}


/// This endpoint is for downloading a default root certificate. 
pub async fn get_cert(configuration: &configuration::Configuration, params: GetCertParams) -> Result<reqwest::Response, Error<GetCertError>> {

    let uri_str = format!("{}/systeminfo/getcert", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(resp)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCertError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// This API is for retrieving general system info, this can be called by anonymous request.  Some attributes will be omitted in the response when this API is called by anonymous request. 
pub async fn get_system_info(configuration: &configuration::Configuration, params: GetSystemInfoParams) -> Result<models::GeneralInfo, Error<GetSystemInfoError>> {

    let uri_str = format!("{}/systeminfo", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GeneralInfo`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GeneralInfo`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSystemInfoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// This endpoint is for retrieving system volume info that only provides for admin user.  Note that the response only reflects the storage status of local disk. 
pub async fn get_volumes(configuration: &configuration::Configuration, params: GetVolumesParams) -> Result<models::SystemInfo, Error<GetVolumesError>> {

    let uri_str = format!("{}/systeminfo/volumes", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SystemInfo`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SystemInfo`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetVolumesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}