argoflows 0.1.1

Argoflows lets you seamlessly integrate and manage Argo Workflows directly from your Rust applications.
Documentation 
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::config::Config;
use crate::error::{
    info::{CollectEventError, GetInfoError, GetUserInfoError, GetVersionError},
    Error,
};
use crate::types::{
    info::{CollectEventRequest, Info, UserInfo, Version},
    ResponseContent,
};

pub fn collect_event(
    config: &Config,
    body: CollectEventRequest,
) -> Result<serde_json::Value, Error<CollectEventError>> {
    let uri = format!("{}/api/v1/tracking/event", config.host);
    let mut req_builder = config.client.request(reqwest::Method::POST, uri.as_str());

    if let Some(bearer_token) = &config.bearer_token {
        req_builder = req_builder.bearer_auth(bearer_token);
    }

    req_builder = req_builder.json(&body);
    let req = req_builder.build()?;
    let res = config.client.execute(req)?;
    let status = res.status();
    let content = res.text()?;

    if !status.is_client_error() && !status.is_server_error() {
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let entity: Option<CollectEventError> = serde_json::from_str(&content).ok();
        let err = ResponseContent {
            status,
            content,
            entity,
        };

        Err(Error::Response(err))
    }
}

pub fn get_info(config: &Config) -> Result<Info, Error<GetInfoError>> {
    let uri = format!("{}/api/v1/info", config.host);
    let mut req_builder = config.client.request(reqwest::Method::GET, uri.as_str());

    if let Some(bearer_token) = &config.bearer_token {
        req_builder = req_builder.bearer_auth(bearer_token);
    }

    let req = req_builder.build()?;
    let res = config.client.execute(req)?;
    let status = res.status();
    let content = res.text()?;

    if !status.is_client_error() && !status.is_server_error() {
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let entity: Option<GetInfoError> = serde_json::from_str(&content).ok();
        let err = ResponseContent {
            status,
            content,
            entity,
        };

        Err(Error::Response(err))
    }
}

pub fn get_user_info(config: &Config) -> Result<UserInfo, Error<GetUserInfoError>> {
    let uri = format!("{}/api/v1/userinfo", config.host);
    let mut req_builder = config.client.request(reqwest::Method::GET, uri.as_str());

    if let Some(bearer_token) = &config.bearer_token {
        req_builder = req_builder.bearer_auth(bearer_token);
    }

    let req = req_builder.build()?;
    let res = config.client.execute(req)?;
    let status = res.status();
    let content = res.text()?;

    if !status.is_client_error() && !status.is_server_error() {
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let entity: Option<GetUserInfoError> = serde_json::from_str(&content).ok();
        let err = ResponseContent {
            status,
            content,
            entity,
        };

        Err(Error::Response(err))
    }
}

pub fn get_version(config: &Config) -> Result<Version, Error<GetVersionError>> {
    let uri = format!("{}/api/v1/version", config.host);

    let mut req_builder = config.client.request(reqwest::Method::GET, uri.as_str());

    if let Some(bearer_token) = &config.bearer_token {
        req_builder = req_builder.bearer_auth(bearer_token);
    }

    let req = req_builder.build()?;
    let resp = config.client.execute(req)?;
    let status = resp.status();
    let content = resp.text()?;

    if !status.is_client_error() && !status.is_server_error() {
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let entity: Option<GetVersionError> = serde_json::from_str(&content).ok();
        let error = ResponseContent {
            status,
            content,
            entity,
        };
        Err(Error::Response(error))
    }
}