golem-client 0.0.63

use async_trait::async_trait;
use crate::Context;
use crate::Error;
use crate::model::ApiDefinition;
use crate::model::MessageBody;
use crate::model::WorkerServiceErrorBody;
use crate::model::WorkerServiceErrorsBody;

pub enum ApiDefinitionError {
    Error400(WorkerServiceErrorsBody),
    Error401(WorkerServiceErrorBody),
    Error403(WorkerServiceErrorBody),
    Error404(MessageBody),
    Error409(String),
    Error500(WorkerServiceErrorBody),
}

#[async_trait]
pub trait ApiDefinitionClient {
    async fn oas_put(&self) -> Result<ApiDefinition, Error<ApiDefinitionError>>;
    async fn get(&self, api_definition_id: &str, version: &str) -> Result<Vec<ApiDefinition>, Error<ApiDefinitionError>>;
    async fn put(&self, value: &ApiDefinition) -> Result<ApiDefinition, Error<ApiDefinitionError>>;
    async fn delete(&self, api_definition_id: &str, version: &str) -> Result<String, Error<ApiDefinitionError>>;
    async fn all_get(&self) -> Result<Vec<ApiDefinition>, Error<ApiDefinitionError>>;
}

pub struct ApiDefinitionClientLive {
    pub context: Context,
}

#[async_trait]
impl ApiDefinitionClient for ApiDefinitionClientLive {
    async fn oas_put(&self) -> Result<ApiDefinition, Error<ApiDefinitionError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v1")
            .push("api")
            .push("definitions")
            .push("oas");

        let mut request = self
            .context
            .client
            .put(url.clone());

        {
            tracing::info!(method="put", endpoint="/v1/api/definitions/oas", url=url.to_string(), "oas_put");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<ApiDefinition>().await?)
            }
            400 => {
                let body = response.json::<WorkerServiceErrorsBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error400(body)))
            }
            401 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error401(body)))
            }
            403 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error403(body)))
            }
            404 => {
                let body = response.json::<MessageBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error404(body)))
            }
            409 => {
                let body = response.json::<String>().await?;
                Err(Error::Item(ApiDefinitionError::Error409(body)))
            }
            500 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn get(&self, api_definition_id: &str, version: &str) -> Result<Vec<ApiDefinition>, Error<ApiDefinitionError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v1")
            .push("api")
            .push("definitions");

        url.query_pairs_mut().append_pair("api-definition-id", &api_definition_id);

        url.query_pairs_mut().append_pair("version", &version);

        let mut request = self
            .context
            .client
            .get(url.clone());

        {
            tracing::info!(method="get", endpoint="/v1/api/definitions", url=url.to_string(), "get");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<Vec<ApiDefinition>>().await?)
            }
            400 => {
                let body = response.json::<WorkerServiceErrorsBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error400(body)))
            }
            401 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error401(body)))
            }
            403 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error403(body)))
            }
            404 => {
                let body = response.json::<MessageBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error404(body)))
            }
            409 => {
                let body = response.json::<String>().await?;
                Err(Error::Item(ApiDefinitionError::Error409(body)))
            }
            500 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn put(&self, value: &ApiDefinition) -> Result<ApiDefinition, Error<ApiDefinitionError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v1")
            .push("api")
            .push("definitions");

        let mut request = self
            .context
            .client
            .put(url.clone());

        {
            tracing::info!(method="put", endpoint="/v1/api/definitions", url=url.to_string(), body=serde_json::to_string(value)?, "put");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        request = request.json(value);

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<ApiDefinition>().await?)
            }
            400 => {
                let body = response.json::<WorkerServiceErrorsBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error400(body)))
            }
            401 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error401(body)))
            }
            403 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error403(body)))
            }
            404 => {
                let body = response.json::<MessageBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error404(body)))
            }
            409 => {
                let body = response.json::<String>().await?;
                Err(Error::Item(ApiDefinitionError::Error409(body)))
            }
            500 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn delete(&self, api_definition_id: &str, version: &str) -> Result<String, Error<ApiDefinitionError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v1")
            .push("api")
            .push("definitions");

        url.query_pairs_mut().append_pair("api-definition-id", &api_definition_id);

        url.query_pairs_mut().append_pair("version", &version);

        let mut request = self
            .context
            .client
            .delete(url.clone());

        {
            tracing::info!(method="delete", endpoint="/v1/api/definitions", url=url.to_string(), "delete");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<String>().await?)
            }
            400 => {
                let body = response.json::<WorkerServiceErrorsBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error400(body)))
            }
            401 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error401(body)))
            }
            403 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error403(body)))
            }
            404 => {
                let body = response.json::<MessageBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error404(body)))
            }
            409 => {
                let body = response.json::<String>().await?;
                Err(Error::Item(ApiDefinitionError::Error409(body)))
            }
            500 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn all_get(&self) -> Result<Vec<ApiDefinition>, Error<ApiDefinitionError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v1")
            .push("api")
            .push("definitions")
            .push("all");

        let mut request = self
            .context
            .client
            .get(url.clone());

        {
            tracing::info!(method="get", endpoint="/v1/api/definitions/all", url=url.to_string(), "all_get");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<Vec<ApiDefinition>>().await?)
            }
            400 => {
                let body = response.json::<WorkerServiceErrorsBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error400(body)))
            }
            401 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error401(body)))
            }
            403 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error403(body)))
            }
            404 => {
                let body = response.json::<MessageBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error404(body)))
            }
            409 => {
                let body = response.json::<String>().await?;
                Err(Error::Item(ApiDefinitionError::Error409(body)))
            }
            500 => {
                let body = response.json::<WorkerServiceErrorBody>().await?;
                Err(Error::Item(ApiDefinitionError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }
}