1use thiserror::Error;
2
3#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5pub(crate) enum SdpErrorCode {
6 Success = 2000,
7 InvalidValue = 4001,
8 Forbidden = 4002,
9 ClosureRuleViolation = 4003,
10 Internal = 4004,
11 ReferenceExists = 4005,
12 NotFound = 4007,
13 NotUnique = 4008,
14 NonEditableField = 4009,
15 InternalField = 4010,
16 NoSuchField = 4011,
17 MissingMandatoryField = 4012,
18 UnsupportedContentType = 4013,
19 ReadOnlyField = 4014,
20 RateLimitExceeded = 4015,
21 AlreadyInTrash = 4016,
22 NotInTrash = 4017,
23 LicenseRestriction = 7001,
24 Unknown = 0,
25}
26
27impl From<u32> for SdpErrorCode {
28 fn from(code: u32) -> Self {
29 match code {
30 2000 => SdpErrorCode::Success,
31 4001 => SdpErrorCode::InvalidValue,
32 4002 => SdpErrorCode::Forbidden,
33 4003 => SdpErrorCode::ClosureRuleViolation,
34 4004 => SdpErrorCode::Internal,
35 4005 => SdpErrorCode::ReferenceExists,
36 4007 => SdpErrorCode::NotFound,
37 4008 => SdpErrorCode::NotUnique,
38 4009 => SdpErrorCode::NonEditableField,
39 4010 => SdpErrorCode::InternalField,
40 4011 => SdpErrorCode::NoSuchField,
41 4012 => SdpErrorCode::MissingMandatoryField,
42 4013 => SdpErrorCode::UnsupportedContentType,
43 4014 => SdpErrorCode::ReadOnlyField,
44 4015 => SdpErrorCode::RateLimitExceeded,
45 4016 => SdpErrorCode::AlreadyInTrash,
46 4017 => SdpErrorCode::NotInTrash,
47 7001 => SdpErrorCode::LicenseRestriction,
48 _ => SdpErrorCode::Unknown,
49 }
50 }
51}
52
53#[derive(Debug, Error)]
54pub enum Error {
55 #[error("HTTP error: {0}")]
56 Http(#[from] reqwest::Error),
57 #[error("Authentication failed: invalid or expired token")]
58 Unauthorized,
59 #[error("Permission denied: {0}")]
60 Forbidden(String),
61 #[error("Resource not found: {0}")]
62 NotFound(String),
63 #[error("Invalid value: {0}")]
64 InvalidValue(String),
65 #[error("Resource already exists (not unique): {0}")]
66 NotUnique(String),
67 #[error("Cannot delete: resource is referenced elsewhere")]
68 ReferenceExists,
69 #[error("Missing mandatory field: {0}")]
70 MissingField(String),
71 #[error("Field is not editable: {0}")]
72 NotEditable(String),
73 #[error("Field does not exist: {0}")]
74 NoSuchField(String),
75 #[error("Closure rule violation: {0}")]
76 ClosureRuleViolation(String),
77 #[error("Rate limit exceeded")]
78 RateLimited,
79 #[error("License restriction: operation not allowed")]
80 LicenseRestricted,
81 #[error("SDP internal error")]
82 Internal,
83 #[error("Serialization error: {0}")]
84 Serialization(#[from] serde_json::Error),
85 #[error("URL parsing error: {0}")]
86 UrlParse(#[from] url::ParseError),
87 #[error("Form encoding error: {0}")]
88 FormEncoding(#[from] serde_urlencoded::ser::Error),
89 #[error("SDP error (code {code}): {message}")]
90 Sdp { code: u32, message: String },
91 #[error("Required field missing: {0}")]
92 FieldRequired(String),
93 #[error("{0}")]
94 Other(String),
95}
96
97impl Error {
98 pub fn from_sdp(code: u32, message: String, field: Option<String>) -> Self {
100 let field_info = field.clone().unwrap_or_else(|| message.clone());
101
102 match SdpErrorCode::from(code) {
103 SdpErrorCode::InvalidValue => Error::InvalidValue(field_info),
104 SdpErrorCode::Forbidden => Error::Forbidden(field_info),
105 SdpErrorCode::ClosureRuleViolation => Error::ClosureRuleViolation(field_info),
106 SdpErrorCode::Internal => Error::Internal,
107 SdpErrorCode::ReferenceExists => Error::ReferenceExists,
108 SdpErrorCode::NotFound => Error::NotFound(field_info),
109 SdpErrorCode::NotUnique => Error::NotUnique(field_info),
110 SdpErrorCode::NonEditableField | SdpErrorCode::ReadOnlyField => {
111 Error::NotEditable(field_info)
112 }
113 SdpErrorCode::InternalField => {
114 Error::NotEditable(format!("internal field: {}", field_info))
115 }
116 SdpErrorCode::NoSuchField => Error::NoSuchField(field_info),
117 SdpErrorCode::MissingMandatoryField => Error::MissingField(field_info),
118 SdpErrorCode::RateLimitExceeded => Error::RateLimited,
119 SdpErrorCode::LicenseRestriction => Error::LicenseRestricted,
120 SdpErrorCode::AlreadyInTrash | SdpErrorCode::NotInTrash => Error::Sdp { code, message },
121 SdpErrorCode::UnsupportedContentType => Error::Sdp { code, message },
122 SdpErrorCode::Success => Error::Other("Unexpected success code in error path".into()),
123 SdpErrorCode::Unknown => Error::Sdp { code, message },
124 }
125 }
126}
127
128#[cfg(test)]
129mod tests {
130 use super::*;
131
132 #[test]
133 fn sdp_error_code_from_u32() {
134 assert_eq!(SdpErrorCode::from(2000), SdpErrorCode::Success);
135 assert_eq!(SdpErrorCode::from(4001), SdpErrorCode::InvalidValue);
136 assert_eq!(SdpErrorCode::from(4002), SdpErrorCode::Forbidden);
137 assert_eq!(SdpErrorCode::from(4003), SdpErrorCode::ClosureRuleViolation);
138 assert_eq!(SdpErrorCode::from(4004), SdpErrorCode::Internal);
139 assert_eq!(SdpErrorCode::from(4005), SdpErrorCode::ReferenceExists);
140 assert_eq!(SdpErrorCode::from(4007), SdpErrorCode::NotFound);
141 assert_eq!(SdpErrorCode::from(4008), SdpErrorCode::NotUnique);
142 assert_eq!(SdpErrorCode::from(4009), SdpErrorCode::NonEditableField);
143 assert_eq!(SdpErrorCode::from(4010), SdpErrorCode::InternalField);
144 assert_eq!(SdpErrorCode::from(4011), SdpErrorCode::NoSuchField);
145 assert_eq!(
146 SdpErrorCode::from(4012),
147 SdpErrorCode::MissingMandatoryField
148 );
149 assert_eq!(
150 SdpErrorCode::from(4013),
151 SdpErrorCode::UnsupportedContentType
152 );
153 assert_eq!(SdpErrorCode::from(4014), SdpErrorCode::ReadOnlyField);
154 assert_eq!(SdpErrorCode::from(4015), SdpErrorCode::RateLimitExceeded);
155 assert_eq!(SdpErrorCode::from(4016), SdpErrorCode::AlreadyInTrash);
156 assert_eq!(SdpErrorCode::from(4017), SdpErrorCode::NotInTrash);
157 assert_eq!(SdpErrorCode::from(7001), SdpErrorCode::LicenseRestriction);
158 assert_eq!(SdpErrorCode::from(9999), SdpErrorCode::Unknown);
159 assert_eq!(SdpErrorCode::from(0), SdpErrorCode::Unknown);
160 }
161
162 #[test]
163 fn error_from_sdp_maps_correctly() {
164 assert!(matches!(
165 Error::from_sdp(4001, "msg".into(), None),
166 Error::InvalidValue(_)
167 ));
168 assert!(matches!(
169 Error::from_sdp(4002, "msg".into(), None),
170 Error::Forbidden(_)
171 ));
172 assert!(matches!(
173 Error::from_sdp(4004, "msg".into(), None),
174 Error::Internal
175 ));
176 assert!(matches!(
177 Error::from_sdp(4005, "msg".into(), None),
178 Error::ReferenceExists
179 ));
180 assert!(matches!(
181 Error::from_sdp(4007, "msg".into(), None),
182 Error::NotFound(_)
183 ));
184 assert!(matches!(
185 Error::from_sdp(4009, "msg".into(), None),
186 Error::NotEditable(_)
187 ));
188 assert!(matches!(
189 Error::from_sdp(4014, "msg".into(), None),
190 Error::NotEditable(_)
191 ));
192 assert!(matches!(
193 Error::from_sdp(4012, "msg".into(), None),
194 Error::MissingField(_)
195 ));
196 assert!(matches!(
197 Error::from_sdp(4015, "msg".into(), None),
198 Error::RateLimited
199 ));
200 assert!(matches!(
201 Error::from_sdp(7001, "msg".into(), None),
202 Error::LicenseRestricted
203 ));
204 assert!(matches!(
205 Error::from_sdp(9999, "msg".into(), None),
206 Error::Sdp { .. }
207 ));
208 }
209
210 #[test]
211 fn error_from_sdp_uses_field_when_provided() {
212 let err = Error::from_sdp(4001, "message".into(), Some("field_name".into()));
213 match err {
214 Error::InvalidValue(s) => assert_eq!(s, "field_name"),
215 _ => panic!("expected InvalidValue"),
216 }
217 }
218
219 #[test]
220 fn error_from_sdp_uses_message_when_no_field() {
221 let err = Error::from_sdp(4001, "message".into(), None);
222 match err {
223 Error::InvalidValue(s) => assert_eq!(s, "message"),
224 _ => panic!("expected InvalidValue"),
225 }
226 }
227}