neolite 0.1.5

NEO Lite SDK
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use std::sync::Arc;

use serde::{Deserialize, Serialize};
use serde_aux::field_attributes::deserialize_number_from_string;
use serde_json as json;

use crate::client::Client;

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub enum AccountStatus {
    Active,
    Pending,
    Suspended,
    Terminated,
}

impl AccountStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Active => "Active",
            Self::Pending => "Pending",
            Self::Suspended => "Suspended",
            Self::Terminated => "Terminated",
        }
    }
}

pub struct Account {
    client: Arc<Client>,
}

impl Account {
    pub fn new(client: Arc<Client>) -> Self {
        Self { client }
    }
    pub async fn list(&self) -> Result<Vec<AccountResource>, crate::Error> {
        let response = self.client.get("/accounts").await?;
        let response: Vec<AccountResource> = json::from_value(response)?;
        Ok(response)
    }
    pub async fn list_with_status(
        &self,
        status: AccountStatus,
    ) -> Result<Vec<AccountResource>, crate::Error> {
        let response = self
            .client
            .get(&format!("/accounts?status={}", status.as_str()))
            .await?;
        let response: Vec<AccountResource> = json::from_value(response)?;
        Ok(response)
    }
    // pub async fn get(&self, id: u32) -> Result<AccountResource, crate::Error> {
    //     let response = self.client.get(&format!("/accounts/{id}")).await;
    //     match response {
    //         Ok(response) => {
    //             let response: AccountResource = json::from_value(response)?;
    //             Ok(response)
    //         }
    //         Err(e) => match e {
    //             crate::Error::NotFound(_) => {
    //                 Err(crate::Error::NotFound("Account not found".into()))
    //             }
    //             _ => Err(e),
    //         },
    //     }
    // }

    //
    // Snapshots
    //
    pub async fn list_snapshot(&self) -> Result<Vec<SnapshotAccountResource>, crate::Error> {
        let response = self.client.get("/snapshots/accounts").await?;
        let response: Vec<SnapshotAccountResource> = json::from_value(response)?;
        Ok(response)
    }

    pub async fn get_snapshot(&self, id: u32) -> Result<SnapshotAccountResource, crate::Error> {
        let response = self.client.get(&format!("/snapshots/accounts/{id}")).await;
        match response {
            Ok(response) => {
                let response: SnapshotAccountResource = json::from_value(response)?;
                Ok(response)
            }
            Err(e) => match e {
                crate::Error::NotFound(_) => {
                    Err(crate::Error::NotFound("Snapshot not found".into()))
                }
                _ => Err(e),
            },
        }
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct AccountResource {
    #[serde(deserialize_with = "deserialize_number_from_string")]
    #[serde(rename = "account_id")]
    pub id: u32,
    pub domain: String,
    pub status: AccountStatus,
    pub billingcycle: String,
    pub date_created: String,
    pub next_due: String,
    pub recurring_amount: i32,
    pub extra_details: ExtraDetails,
    pub product_id: u32,
    pub product_name: String,
    pub description: String,
    pub category_id: u32,
    pub category_name: String,
    pub last_invoice: LastInvoice,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LastInvoice {
    pub id: u32,
    pub paid_id: u32,
    pub status: String,
    pub date: String,
    pub duedate: String,
    pub paybefore: String,
    pub datepaid: String,
    pub invoice_type: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ExtraDetails {
    pub region: String,
    pub region_label: String,
    pub description: String,
    pub name: String,
    pub tenant_id: Option<String>,
    pub ciuser: String,
    pub cipassword: String,
    #[serde(rename = "neosshkey_id")]
    pub keypair_id: u32,
    // pub keypair_name: String,
    pub sshkeys: String,
    pub osname: String,
    pub disk_size: String,
}

//
// Snapshots
//

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct SnapshotAccountResource {
    #[serde(rename = "account_id")]
    pub id: u32,
    pub status: AccountStatus,
    pub extra_details: SnapshotExtraDetails,
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct SnapshotExtraDetails {
    pub name: String,
    pub description: String,
    pub region: String,
}