eskom_se_push-api 0.2.0

API Bindings to the Eskom-se-Push API
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

use std::collections::HashMap;

use chrono::DateTime;
use chrono::Utc;
use derive_builder::Builder;
use serde::Deserialize;
use serde::Serialize;

use crate::traits::Endpoint;
#[cfg(any(feature = "async", doc))]
use crate::traits::EndpointAsync;

pub enum Stage {
  NoLoadShedding,
  Stage1,
  Stage2,
  Stage3,
  Stage4,
  Stage5,
  Stage6,
  Stage7,
  Stage8,
  /// Able to check any stage (Also future proofing). String should be a whole number.
  /// "0" is no loadshedding. "1" is Stage 1 etc.
  Stage(String),
}

impl PartialEq<String> for Stage {
  fn eq(&self, other: &String) -> bool {
    match self {
      Stage::NoLoadShedding => "0" == other,
      Stage::Stage1 => "1" == other,
      Stage::Stage2 => "2" == other,
      Stage::Stage3 => "3" == other,
      Stage::Stage4 => "4" == other,
      Stage::Stage5 => "5" == other,
      Stage::Stage6 => "6" == other,
      Stage::Stage7 => "7" == other,
      Stage::Stage8 => "8" == other,
      Stage::Stage(stage) => stage == other,
    }
  }
}

impl From<String> for Stage {
  fn from(stage: String) -> Self {
    match stage.as_str() {
      "0" => Self::NoLoadShedding,
      "1" => Self::Stage1,
      "2" => Self::Stage2,
      "3" => Self::Stage3,
      "4" => Self::Stage4,
      "5" => Self::Stage5,
      "6" => Self::Stage6,
      "7" => Self::Stage7,
      "8" => Self::Stage8,
      new_stage => Self::Stage(new_stage.to_string()),
    }
  }
}

#[derive(Default, Builder, Debug)]
#[builder(setter(into))]
pub struct EskomStatusUrl {}

impl Endpoint for EskomStatusUrl {
  type Output = EskomStatus;

  fn endpoint(&self) -> std::borrow::Cow<'static, str> {
    std::borrow::Cow::Borrowed("https://developer.sepush.co.za/business/2.0/status")
  }

  fn url(&self) -> Result<url::Url, crate::errors::HttpError> {
    Ok(url::Url::parse(&self.endpoint()).unwrap())
  }
}

#[cfg(any(feature = "async", doc))]
impl EndpointAsync for EskomStatusUrl {}

/// The status of load shedding nation wide and certain areas if they don't follow the
/// nation wide status
#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EskomStatus {
  pub status: HashMap<String, LoadsheddingStatus>,
}

impl EskomStatus {
  /// Gets the nation-wide load shedding status
  pub fn eskom(&self) -> &LoadsheddingStatus {
    self.status.get("eskom").unwrap()
  }

  /// Gets the status for a specific area
  /// `Note` the area needs to match the case of key
  pub fn area(&self, area: &str) -> Option<&LoadsheddingStatus> {
    self.status.get(area.to_lowercase().as_str())
  }

  /// Returns all the area keys
  pub fn keys(&mut self) -> Vec<String> {
    self.status.clone().into_keys().collect()
  }
}

#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LoadsheddingStatus {
  pub name: String,
  #[serde(rename = "next_stages")]
  pub next_stages: Vec<NextStage>,
  pub stage: String,
  #[serde(rename = "stage_updated")]
  pub stage_updated: String,
}

impl LoadsheddingStatus {
  pub fn is_it_stage(&self, stage: Stage) -> bool {
    stage == self.stage
  }

  pub fn get_stage(&self) -> Stage {
    self.stage.clone().into()
  }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NextStage {
  pub stage: String,
  #[serde(rename = "stage_start_timestamp")]
  pub stage_start_timestamp: DateTime<Utc>,
}

impl NextStage {
  pub fn is_it_stage(&self, stage: Stage) -> bool {
    stage == self.stage
  }

  pub fn get_stage(&self) -> Stage {
    self.stage.clone().into()
  }
}