1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use crate::{
    config::RabbitMqConfiguration, errors::RabbitMqClientError,
    middlewares::authentication::AuthenticationMiddleware,
};
use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};

pub mod api;
pub mod config;
pub mod errors;
mod middlewares;

#[derive(Clone)]
pub struct RabbitMqClient {
    pub api_url: String,
    pub client: ClientWithMiddleware,
}

pub struct RabbitMqClientBuilder {
    config: RabbitMqConfiguration,
    preset_client: Option<ClientWithMiddleware>,
}

impl RabbitMqClientBuilder {
    pub fn new(config: RabbitMqConfiguration) -> Self {
        Self {
            config,
            preset_client: None,
        }
    }

    pub fn preset_client(mut self, client: ClientWithMiddleware) -> Self {
        self.preset_client = Some(client);
        self
    }

    #[tracing::instrument(skip(self))]
    pub fn build(self) -> Result<RabbitMqClient, RabbitMqClientError> {
        let client_builder = match self.preset_client {
            None => ClientBuilder::new(reqwest::Client::new()),
            Some(c) => ClientBuilder::from_client(c),
        };

        if self.config.rabbitmq_username.is_empty() || self.config.rabbitmq_password.is_empty() {
            return Err(RabbitMqClientError::MissingCredentials);
        }

        let client = client_builder
            .with(AuthenticationMiddleware {
                username: self.config.rabbitmq_username,
                password: self.config.rabbitmq_password,
            })
            .build();

        Ok(RabbitMqClient {
            api_url: self.config.rabbitmq_api_url,
            client,
        })
    }
}