1use serde::{Deserialize, Serialize};
2use thiserror::Error;
3
4use crate::TicketID;
5
6#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8pub(crate) enum SdpErrorCode {
9 Success = 2000,
10 InvalidValue = 4001,
11 Forbidden = 4002,
12 ClosureRuleViolation = 4003,
13 Internal = 4004,
14 ReferenceExists = 4005,
15 NotFound = 4007,
16 NotUnique = 4008,
17 NonEditableField = 4009,
18 InternalField = 4010,
19 NoSuchField = 4011,
20 MissingMandatoryField = 4012,
21 UnsupportedContentType = 4013,
22 ReadOnlyField = 4014,
23 RateLimitExceeded = 4015,
24 AlreadyInTrash = 4016,
25 NotInTrash = 4017,
26 LicenseRestriction = 7001,
27 Unknown = 0,
28}
29
30impl From<u32> for SdpErrorCode {
31 fn from(code: u32) -> Self {
32 match code {
33 2000 => SdpErrorCode::Success,
34 4001 => SdpErrorCode::InvalidValue,
35 4002 => SdpErrorCode::Forbidden,
36 4003 => SdpErrorCode::ClosureRuleViolation,
37 4004 => SdpErrorCode::Internal,
38 4005 => SdpErrorCode::ReferenceExists,
39 4007 => SdpErrorCode::NotFound,
40 4008 => SdpErrorCode::NotUnique,
41 4009 => SdpErrorCode::NonEditableField,
42 4010 => SdpErrorCode::InternalField,
43 4011 => SdpErrorCode::NoSuchField,
44 4012 => SdpErrorCode::MissingMandatoryField,
45 4013 => SdpErrorCode::UnsupportedContentType,
46 4014 => SdpErrorCode::ReadOnlyField,
47 4015 => SdpErrorCode::RateLimitExceeded,
48 4016 => SdpErrorCode::AlreadyInTrash,
49 4017 => SdpErrorCode::NotInTrash,
50 7001 => SdpErrorCode::LicenseRestriction,
51 _ => SdpErrorCode::Unknown,
52 }
53 }
54}
55
56#[derive(Debug, Error)]
57pub enum Error {
58 #[error("HTTP error: {0}")]
59 Http(#[from] reqwest::Error),
60 #[error("Authentication failed: invalid or expired token")]
61 Unauthorized,
62 #[error("Permission denied: {0}")]
63 Forbidden(String),
64 #[error("Resource not found: {0}")]
65 NotFound(String),
66 #[error("request has been merged into parent {parent_request_id}: {message}")]
67 RequestMerged {
68 parent_request_id: TicketID,
69 message: String,
70 },
71 #[error("Invalid value: {0}")]
72 InvalidValue(String),
73 #[error("Resource already exists (not unique): {0}")]
74 NotUnique(String),
75 #[error("Cannot delete: resource is referenced elsewhere")]
76 ReferenceExists,
77 #[error("Missing mandatory field: {0}")]
78 MissingField(String),
79 #[error("Field is not editable: {0}")]
80 NotEditable(String),
81 #[error("Field does not exist: {0}")]
82 NoSuchField(String),
83 #[error("Closure rule violation: {0}")]
84 ClosureRuleViolation(String),
85 #[error("Rate limit exceeded")]
86 RateLimited,
87 #[error("License restriction: operation not allowed")]
88 LicenseRestricted,
89 #[error("SDP internal error")]
90 Internal,
91 #[error("Serialization error: {0}")]
92 Serialization(#[from] serde_json::Error),
93 #[error("URL parsing error: {0}")]
94 UrlParse(#[from] url::ParseError),
95 #[error("Form encoding error: {0}")]
96 FormEncoding(#[from] serde_urlencoded::ser::Error),
97 #[error("SDP error (code {code}): {message}")]
98 Sdp { code: u32, message: String },
99 #[error("Required field missing: {0}")]
100 FieldRequired(String),
101 #[error("{0}")]
102 Other(String),
103 #[error("io error: {0}")]
104 Io(#[from] std::io::Error),
105}
106
107#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
108#[serde(untagged)]
109pub(crate) enum SdpErrorMessage {
110 Merged {
111 parent_request: ParentRequest,
112 message: String,
113 },
114 Text(String),
115 Other(serde_json::Value),
116}
117
118impl SdpErrorMessage {
119 fn into_text(self) -> String {
120 match self {
121 Self::Merged { message, .. } | Self::Text(message) => message,
122 Self::Other(value) => value.to_string(),
123 }
124 }
125}
126
127#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
128pub(crate) struct ParentRequest {
129 id: TicketID,
130}
131
132impl Error {
133 pub(crate) fn from_sdp_message(code: u32, response: SdpErrorMessage) -> Self {
134 if let SdpErrorMessage::Merged {
135 parent_request,
136 message,
137 } = response
138 {
139 return Self::RequestMerged {
140 parent_request_id: parent_request.id,
141 message,
142 };
143 }
144
145 Self::from_sdp(code, response.into_text(), None)
146 }
147
148 pub fn from_sdp(code: u32, message: String, field: Option<String>) -> Self {
150 let field_info = field.clone().unwrap_or_else(|| message.clone());
151
152 match SdpErrorCode::from(code) {
153 SdpErrorCode::InvalidValue => Error::InvalidValue(field_info),
154 SdpErrorCode::Forbidden => Error::Forbidden(field_info),
155 SdpErrorCode::ClosureRuleViolation => Error::ClosureRuleViolation(field_info),
156 SdpErrorCode::Internal => Error::Internal,
157 SdpErrorCode::ReferenceExists => Error::ReferenceExists,
158 SdpErrorCode::NotFound => Error::NotFound(field_info),
159 SdpErrorCode::NotUnique => Error::NotUnique(field_info),
160 SdpErrorCode::NonEditableField | SdpErrorCode::ReadOnlyField => {
161 Error::NotEditable(field_info)
162 }
163 SdpErrorCode::InternalField => {
164 Error::NotEditable(format!("internal field: {}", field_info))
165 }
166 SdpErrorCode::NoSuchField => Error::NoSuchField(field_info),
167 SdpErrorCode::MissingMandatoryField => Error::MissingField(field_info),
168 SdpErrorCode::RateLimitExceeded => Error::RateLimited,
169 SdpErrorCode::LicenseRestriction => Error::LicenseRestricted,
170 SdpErrorCode::AlreadyInTrash | SdpErrorCode::NotInTrash => Error::Sdp { code, message },
171 SdpErrorCode::UnsupportedContentType => Error::Sdp { code, message },
172 SdpErrorCode::Success => Error::Other("Unexpected success code in error path".into()),
173 SdpErrorCode::Unknown => Error::Sdp { code, message },
174 }
175 }
176}
177
178#[cfg(test)]
179mod tests {
180 use super::*;
181
182 #[test]
183 fn sdp_error_code_from_u32() {
184 assert_eq!(SdpErrorCode::from(2000), SdpErrorCode::Success);
185 assert_eq!(SdpErrorCode::from(4001), SdpErrorCode::InvalidValue);
186 assert_eq!(SdpErrorCode::from(4002), SdpErrorCode::Forbidden);
187 assert_eq!(SdpErrorCode::from(4003), SdpErrorCode::ClosureRuleViolation);
188 assert_eq!(SdpErrorCode::from(4004), SdpErrorCode::Internal);
189 assert_eq!(SdpErrorCode::from(4005), SdpErrorCode::ReferenceExists);
190 assert_eq!(SdpErrorCode::from(4007), SdpErrorCode::NotFound);
191 assert_eq!(SdpErrorCode::from(4008), SdpErrorCode::NotUnique);
192 assert_eq!(SdpErrorCode::from(4009), SdpErrorCode::NonEditableField);
193 assert_eq!(SdpErrorCode::from(4010), SdpErrorCode::InternalField);
194 assert_eq!(SdpErrorCode::from(4011), SdpErrorCode::NoSuchField);
195 assert_eq!(
196 SdpErrorCode::from(4012),
197 SdpErrorCode::MissingMandatoryField
198 );
199 assert_eq!(
200 SdpErrorCode::from(4013),
201 SdpErrorCode::UnsupportedContentType
202 );
203 assert_eq!(SdpErrorCode::from(4014), SdpErrorCode::ReadOnlyField);
204 assert_eq!(SdpErrorCode::from(4015), SdpErrorCode::RateLimitExceeded);
205 assert_eq!(SdpErrorCode::from(4016), SdpErrorCode::AlreadyInTrash);
206 assert_eq!(SdpErrorCode::from(4017), SdpErrorCode::NotInTrash);
207 assert_eq!(SdpErrorCode::from(7001), SdpErrorCode::LicenseRestriction);
208 assert_eq!(SdpErrorCode::from(9999), SdpErrorCode::Unknown);
209 assert_eq!(SdpErrorCode::from(0), SdpErrorCode::Unknown);
210 }
211
212 #[test]
213 fn error_from_sdp_maps_correctly() {
214 assert!(matches!(
215 Error::from_sdp(4001, "msg".into(), None),
216 Error::InvalidValue(_)
217 ));
218 assert!(matches!(
219 Error::from_sdp(4002, "msg".into(), None),
220 Error::Forbidden(_)
221 ));
222 assert!(matches!(
223 Error::from_sdp(4004, "msg".into(), None),
224 Error::Internal
225 ));
226 assert!(matches!(
227 Error::from_sdp(4005, "msg".into(), None),
228 Error::ReferenceExists
229 ));
230 assert!(matches!(
231 Error::from_sdp(4007, "msg".into(), None),
232 Error::NotFound(_)
233 ));
234 assert!(matches!(
235 Error::from_sdp(4009, "msg".into(), None),
236 Error::NotEditable(_)
237 ));
238 assert!(matches!(
239 Error::from_sdp(4014, "msg".into(), None),
240 Error::NotEditable(_)
241 ));
242 assert!(matches!(
243 Error::from_sdp(4012, "msg".into(), None),
244 Error::MissingField(_)
245 ));
246 assert!(matches!(
247 Error::from_sdp(4015, "msg".into(), None),
248 Error::RateLimited
249 ));
250 assert!(matches!(
251 Error::from_sdp(7001, "msg".into(), None),
252 Error::LicenseRestricted
253 ));
254 assert!(matches!(
255 Error::from_sdp(9999, "msg".into(), None),
256 Error::Sdp { .. }
257 ));
258 }
259
260 #[test]
261 fn error_from_sdp_uses_field_when_provided() {
262 let err = Error::from_sdp(4001, "message".into(), Some("field_name".into()));
263 match err {
264 Error::InvalidValue(s) => assert_eq!(s, "field_name"),
265 _ => panic!("expected InvalidValue"),
266 }
267 }
268
269 #[test]
270 fn error_from_sdp_uses_message_when_no_field() {
271 let err = Error::from_sdp(4001, "message".into(), None);
272 match err {
273 Error::InvalidValue(s) => assert_eq!(s, "message"),
274 _ => panic!("expected InvalidValue"),
275 }
276 }
277
278 #[test]
279 fn structured_merged_response_maps_to_request_merged() {
280 let response: SdpErrorMessage = serde_json::from_value(serde_json::json!({
281 "parent_request": { "id": 583415 },
282 "message": "Request Id(s) 583550 has been Merged with Parent Request 583415."
283 }))
284 .unwrap();
285
286 let error = Error::from_sdp_message(4007, response);
287
288 assert!(matches!(
289 error,
290 Error::RequestMerged {
291 parent_request_id: TicketID(583415),
292 message
293 } if message.contains("583550")
294 ));
295 }
296}