oxyde-cloud-common 0.2.0

Shared code for the oxyde-cloud crates
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

use headers_core::{Header, HeaderName, HeaderValue};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LoginResponse {
    pub username: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Team {
    pub slug: String,
    pub name: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct NewAppRequest {
    pub team_slug: String,
    pub app_slug: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct NewTeamRequest {
    pub team_slug: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CheckAvailabilityResponse {
    pub available: bool,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SetTeamNameRequest {
    pub team_slug: String,
    pub team_name: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LogRequest {
    pub name: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LogResponse {
    pub log: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AppMeta {
    pub app_slug: String,
}

static NAME: HeaderName = HeaderName::from_static("app-meta");

impl AppMeta {
    pub fn to_string_value(&self) -> String {
        self.app_slug.clone()
    }
}

impl Header for AppMeta {
    fn name() -> &'static HeaderName {
        &NAME
    }

    fn decode<'i, I>(values: &mut I) -> Result<Self, headers_core::Error>
    where
        Self: Sized,
        I: Iterator<Item = &'i HeaderValue>,
    {
        values
            .next()
            .and_then(|v| v.to_str().ok())
            .map(|v| Self {
                app_slug: v.to_string(),
            })
            .ok_or_else(headers_core::Error::invalid)
    }

    fn encode<E: Extend<HeaderValue>>(&self, values: &mut E) {
        values.extend([
            HeaderValue::from_str(&self.to_string_value()).expect("invalid header value")
        ]);
    }
}

#[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum DeploymentStatus {
    Pending = 0,
    Success = 1,
    Failure = 2,
}

impl From<i16> for DeploymentStatus {
    fn from(value: i16) -> Self {
        match value {
            0 => DeploymentStatus::Pending,
            1 => DeploymentStatus::Success,
            _ => DeploymentStatus::Failure,
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SuccessResponse {
    pub success: bool,
}

impl Default for SuccessResponse {
    fn default() -> Self {
        Self { success: true }
    }
}