simbld_http/responses/
mod.rs

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
pub mod actix_responder;
pub mod client;
pub mod crawler;
pub mod informational;
pub mod local;
pub mod redirection;
pub mod server;
pub mod service;
pub mod success;
pub mod wrapper;

pub use actix_responder::CustomResponse;
pub use client::ResponsesClientCodes;
pub use crawler::ResponsesCrawlerCodes;
pub use informational::ResponsesInformationalCodes;
pub use local::ResponsesLocalApiCodes;
pub use redirection::ResponsesRedirectionCodes;
pub use server::ResponsesServerCodes;
pub use service::ResponsesServiceCodes;
pub use success::ResponsesSuccessCodes;
pub use wrapper::ResponseWrapper;

use crate::helpers::{from_u16_helper::FromU16, to_u16_helper::ToU16};
use strum::EnumProperty;
use strum::IntoEnumIterator;
use strum_macros::EnumProperty;

/// Enum representing all HTTP response families.
#[derive(Debug, Clone, Copy, EnumProperty)]
pub enum ResponsesTypes {
  Informational(ResponsesInformationalCodes),
  Success(ResponsesSuccessCodes),
  Redirection(ResponsesRedirectionCodes),
  ClientError(ResponsesClientCodes),
  ServerError(ResponsesServerCodes),
  ServiceError(ResponsesServiceCodes),
  CrawlerError(ResponsesCrawlerCodes),
  LocalApiError(ResponsesLocalApiCodes),
}

generate_http_response_functions!(
  ResponsesClientCodes,
  ResponsesCrawlerCodes,
  ResponsesInformationalCodes,
  ResponsesLocalApiCodes,
  ResponsesRedirectionCodes,
  ResponsesServerCodes,
  ResponsesServiceCodes,
  ResponsesSuccessCodes
);

impl ResponsesTypes {
  /// Converts a `u16` to a `ResponsesTypes` corresponding to one of the families.
  pub fn from_u16(code: u16) -> Option<Self> {
    if let Some(info_code) = ResponsesInformationalCodes::from_u16(code) {
      return Some(ResponsesTypes::Informational(info_code));
    }
    if let Some(success_code) = ResponsesSuccessCodes::from_u16(code) {
      return Some(ResponsesTypes::Success(success_code));
    }
    if let Some(redirect_code) = ResponsesRedirectionCodes::from_u16(code) {
      return Some(ResponsesTypes::Redirection(redirect_code));
    }
    if let Some(client_error) = ResponsesClientCodes::from_u16(code) {
      return Some(ResponsesTypes::ClientError(client_error));
    }
    if let Some(server_error) = ResponsesServerCodes::from_u16(code) {
      return Some(ResponsesTypes::ServerError(server_error));
    }
    if let Some(service_error) = ResponsesServiceCodes::from_u16(code) {
      return Some(ResponsesTypes::ServiceError(service_error));
    }
    if let Some(crawler_error) = ResponsesCrawlerCodes::from_u16(code) {
      return Some(ResponsesTypes::CrawlerError(crawler_error));
    }
    if let Some(local_api_error) = ResponsesLocalApiCodes::from_u16(code) {
      return Some(ResponsesTypes::LocalApiError(local_api_error));
    }
    None
  }

  /// Returns the description associated with a response code.
  pub fn description(&self) -> &'static str {
    match self {
      ResponsesTypes::Informational(code_enum) => {
        code_enum.get_str("Description").unwrap_or("No description")
      },
      ResponsesTypes::Success(code_enum) => {
        code_enum.get_str("Description").unwrap_or("No description")
      },
      ResponsesTypes::Redirection(code_enum) => {
        code_enum.get_str("Description").unwrap_or("No description")
      },
      ResponsesTypes::ClientError(code_enum) => {
        code_enum.get_str("Description").unwrap_or("No description")
      },
      ResponsesTypes::ServerError(code_enum) => {
        code_enum.get_str("Description").unwrap_or("No description")
      },
      ResponsesTypes::ServiceError(code_enum) => {
        code_enum.get_str("Description").unwrap_or("No description")
      },
      ResponsesTypes::CrawlerError(code_enum) => {
        code_enum.get_str("Description").unwrap_or("No description")
      },
      ResponsesTypes::LocalApiError(code_enum) => {
        code_enum.get_str("Description").unwrap_or("No description")
      },
    }
  }

  pub fn get_response_description(&self) -> (u16, &'static str) {
    match self {
      ResponsesTypes::Informational(code) => {
        (code.to_u16(), code.get_str("Description").unwrap_or(""))
      },
      ResponsesTypes::Success(code) => (code.to_u16(), code.get_str("Description").unwrap_or("")),
      ResponsesTypes::Redirection(code) => {
        (code.to_u16(), code.get_str("Description").unwrap_or(""))
      },
      ResponsesTypes::ClientError(code) => {
        (code.to_u16(), code.get_str("Description").unwrap_or(""))
      },
      ResponsesTypes::ServerError(code) => {
        (code.to_u16(), code.get_str("Description").unwrap_or(""))
      },
      ResponsesTypes::ServiceError(code) => {
        (code.to_u16(), code.get_str("Description").unwrap_or(""))
      },
      ResponsesTypes::CrawlerError(code) => {
        (code.to_u16(), code.get_str("Description").unwrap_or(""))
      },
      ResponsesTypes::LocalApiError(code) => {
        (code.to_u16(), code.get_str("Description").unwrap_or(""))
      },
    }
  }
}

/// Implementation to convert a `ResponsesTypes` to `u16`.
impl ToU16 for ResponsesTypes {
  fn to_u16(self) -> u16 {
    match self {
      ResponsesTypes::Informational(code_enum) => code_enum.to_u16(),
      ResponsesTypes::Success(code_enum) => code_enum.to_u16(),
      ResponsesTypes::Redirection(code_enum) => code_enum.to_u16(),
      ResponsesTypes::ClientError(code_enum) => code_enum.to_u16(),
      ResponsesTypes::ServerError(code_enum) => code_enum.to_u16(),
      ResponsesTypes::ServiceError(code_enum) => code_enum.to_u16(),
      ResponsesTypes::CrawlerError(code_enum) => code_enum.to_u16(),
      ResponsesTypes::LocalApiError(code_enum) => code_enum.to_u16(),
    }
  }
}