dropbox_sdk/generated/types/
openid.rs

1// DO NOT EDIT
2// This file was @generated by Stone
3
4#![allow(
5    clippy::too_many_arguments,
6    clippy::large_enum_variant,
7    clippy::result_large_err,
8    clippy::doc_markdown,
9    clippy::doc_lazy_continuation,
10)]
11
12#[derive(Debug, Clone, PartialEq, Eq)]
13#[non_exhaustive] // variants may be added in the future
14pub enum OpenIdError {
15    /// Missing openid claims for the associated access token.
16    IncorrectOpenidScopes,
17    /// Catch-all used for unrecognized values returned from the server. Encountering this value
18    /// typically indicates that this SDK version is out of date.
19    Other,
20}
21
22impl<'de> ::serde::de::Deserialize<'de> for OpenIdError {
23    fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
24        // union deserializer
25        use serde::de::{self, MapAccess, Visitor};
26        struct EnumVisitor;
27        impl<'de> Visitor<'de> for EnumVisitor {
28            type Value = OpenIdError;
29            fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
30                f.write_str("a OpenIdError structure")
31            }
32            fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
33                let tag: &str = match map.next_key()? {
34                    Some(".tag") => map.next_value()?,
35                    _ => return Err(de::Error::missing_field(".tag"))
36                };
37                let value = match tag {
38                    "incorrect_openid_scopes" => OpenIdError::IncorrectOpenidScopes,
39                    _ => OpenIdError::Other,
40                };
41                crate::eat_json_fields(&mut map)?;
42                Ok(value)
43            }
44        }
45        const VARIANTS: &[&str] = &["incorrect_openid_scopes",
46                                    "other"];
47        deserializer.deserialize_struct("OpenIdError", VARIANTS, EnumVisitor)
48    }
49}
50
51impl ::serde::ser::Serialize for OpenIdError {
52    fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
53        // union serializer
54        use serde::ser::SerializeStruct;
55        match self {
56            OpenIdError::IncorrectOpenidScopes => {
57                // unit
58                let mut s = serializer.serialize_struct("OpenIdError", 1)?;
59                s.serialize_field(".tag", "incorrect_openid_scopes")?;
60                s.end()
61            }
62            OpenIdError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
63        }
64    }
65}
66
67impl ::std::error::Error for OpenIdError {
68}
69
70impl ::std::fmt::Display for OpenIdError {
71    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
72        match self {
73            OpenIdError::IncorrectOpenidScopes => f.write_str("Missing openid claims for the associated access token."),
74            _ => write!(f, "{:?}", *self),
75        }
76    }
77}
78
79/// No Parameters
80#[derive(Debug, Clone, PartialEq, Eq, Default)]
81#[non_exhaustive] // structs may have more fields added in the future.
82pub struct UserInfoArgs {
83}
84
85const USER_INFO_ARGS_FIELDS: &[&str] = &[];
86impl UserInfoArgs {
87    // no _opt deserializer
88    pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
89        mut map: V,
90    ) -> Result<UserInfoArgs, V::Error> {
91        // ignore any fields found; none are presently recognized
92        crate::eat_json_fields(&mut map)?;
93        Ok(UserInfoArgs {})
94    }
95}
96
97impl<'de> ::serde::de::Deserialize<'de> for UserInfoArgs {
98    fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
99        // struct deserializer
100        use serde::de::{MapAccess, Visitor};
101        struct StructVisitor;
102        impl<'de> Visitor<'de> for StructVisitor {
103            type Value = UserInfoArgs;
104            fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
105                f.write_str("a UserInfoArgs struct")
106            }
107            fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
108                UserInfoArgs::internal_deserialize(map)
109            }
110        }
111        deserializer.deserialize_struct("UserInfoArgs", USER_INFO_ARGS_FIELDS, StructVisitor)
112    }
113}
114
115impl ::serde::ser::Serialize for UserInfoArgs {
116    fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
117        // struct serializer
118        use serde::ser::SerializeStruct;
119        serializer.serialize_struct("UserInfoArgs", 0)?.end()
120    }
121}
122
123#[derive(Debug, Clone, PartialEq, Eq)]
124#[non_exhaustive] // variants may be added in the future
125pub enum UserInfoError {
126    OpenidError(OpenIdError),
127    /// Catch-all used for unrecognized values returned from the server. Encountering this value
128    /// typically indicates that this SDK version is out of date.
129    Other,
130}
131
132impl<'de> ::serde::de::Deserialize<'de> for UserInfoError {
133    fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
134        // union deserializer
135        use serde::de::{self, MapAccess, Visitor};
136        struct EnumVisitor;
137        impl<'de> Visitor<'de> for EnumVisitor {
138            type Value = UserInfoError;
139            fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
140                f.write_str("a UserInfoError structure")
141            }
142            fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
143                let tag: &str = match map.next_key()? {
144                    Some(".tag") => map.next_value()?,
145                    _ => return Err(de::Error::missing_field(".tag"))
146                };
147                let value = match tag {
148                    "openid_error" => {
149                        match map.next_key()? {
150                            Some("openid_error") => UserInfoError::OpenidError(map.next_value()?),
151                            None => return Err(de::Error::missing_field("openid_error")),
152                            _ => return Err(de::Error::unknown_field(tag, VARIANTS))
153                        }
154                    }
155                    _ => UserInfoError::Other,
156                };
157                crate::eat_json_fields(&mut map)?;
158                Ok(value)
159            }
160        }
161        const VARIANTS: &[&str] = &["openid_error",
162                                    "other"];
163        deserializer.deserialize_struct("UserInfoError", VARIANTS, EnumVisitor)
164    }
165}
166
167impl ::serde::ser::Serialize for UserInfoError {
168    fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
169        // union serializer
170        use serde::ser::SerializeStruct;
171        match self {
172            UserInfoError::OpenidError(x) => {
173                // union or polymporphic struct
174                let mut s = serializer.serialize_struct("UserInfoError", 2)?;
175                s.serialize_field(".tag", "openid_error")?;
176                s.serialize_field("openid_error", x)?;
177                s.end()
178            }
179            UserInfoError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
180        }
181    }
182}
183
184impl ::std::error::Error for UserInfoError {
185    fn source(&self) -> Option<&(dyn ::std::error::Error + 'static)> {
186        match self {
187            UserInfoError::OpenidError(inner) => Some(inner),
188            _ => None,
189        }
190    }
191}
192
193impl ::std::fmt::Display for UserInfoError {
194    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
195        match self {
196            UserInfoError::OpenidError(inner) => write!(f, "UserInfoError: {}", inner),
197            _ => write!(f, "{:?}", *self),
198        }
199    }
200}
201
202#[derive(Debug, Clone, PartialEq, Eq, Default)]
203#[non_exhaustive] // structs may have more fields added in the future.
204pub struct UserInfoResult {
205    /// Last name of user.
206    pub family_name: Option<String>,
207    /// First name of user.
208    pub given_name: Option<String>,
209    /// Email address of user.
210    pub email: Option<String>,
211    /// If user is email verified.
212    pub email_verified: Option<bool>,
213    /// Issuer of token (in this case Dropbox).
214    pub iss: String,
215    /// An identifier for the user. This is the Dropbox account_id, a string value such as
216    /// dbid:AAH4f99T0taONIb-OurWxbNQ6ywGRopQngc.
217    pub sub: String,
218}
219
220impl UserInfoResult {
221    pub fn with_family_name(mut self, value: String) -> Self {
222        self.family_name = Some(value);
223        self
224    }
225
226    pub fn with_given_name(mut self, value: String) -> Self {
227        self.given_name = Some(value);
228        self
229    }
230
231    pub fn with_email(mut self, value: String) -> Self {
232        self.email = Some(value);
233        self
234    }
235
236    pub fn with_email_verified(mut self, value: bool) -> Self {
237        self.email_verified = Some(value);
238        self
239    }
240
241    pub fn with_iss(mut self, value: String) -> Self {
242        self.iss = value;
243        self
244    }
245
246    pub fn with_sub(mut self, value: String) -> Self {
247        self.sub = value;
248        self
249    }
250}
251
252const USER_INFO_RESULT_FIELDS: &[&str] = &["family_name",
253                                           "given_name",
254                                           "email",
255                                           "email_verified",
256                                           "iss",
257                                           "sub"];
258impl UserInfoResult {
259    // no _opt deserializer
260    pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
261        mut map: V,
262    ) -> Result<UserInfoResult, V::Error> {
263        let mut field_family_name = None;
264        let mut field_given_name = None;
265        let mut field_email = None;
266        let mut field_email_verified = None;
267        let mut field_iss = None;
268        let mut field_sub = None;
269        while let Some(key) = map.next_key::<&str>()? {
270            match key {
271                "family_name" => {
272                    if field_family_name.is_some() {
273                        return Err(::serde::de::Error::duplicate_field("family_name"));
274                    }
275                    field_family_name = Some(map.next_value()?);
276                }
277                "given_name" => {
278                    if field_given_name.is_some() {
279                        return Err(::serde::de::Error::duplicate_field("given_name"));
280                    }
281                    field_given_name = Some(map.next_value()?);
282                }
283                "email" => {
284                    if field_email.is_some() {
285                        return Err(::serde::de::Error::duplicate_field("email"));
286                    }
287                    field_email = Some(map.next_value()?);
288                }
289                "email_verified" => {
290                    if field_email_verified.is_some() {
291                        return Err(::serde::de::Error::duplicate_field("email_verified"));
292                    }
293                    field_email_verified = Some(map.next_value()?);
294                }
295                "iss" => {
296                    if field_iss.is_some() {
297                        return Err(::serde::de::Error::duplicate_field("iss"));
298                    }
299                    field_iss = Some(map.next_value()?);
300                }
301                "sub" => {
302                    if field_sub.is_some() {
303                        return Err(::serde::de::Error::duplicate_field("sub"));
304                    }
305                    field_sub = Some(map.next_value()?);
306                }
307                _ => {
308                    // unknown field allowed and ignored
309                    map.next_value::<::serde_json::Value>()?;
310                }
311            }
312        }
313        let result = UserInfoResult {
314            family_name: field_family_name.and_then(Option::flatten),
315            given_name: field_given_name.and_then(Option::flatten),
316            email: field_email.and_then(Option::flatten),
317            email_verified: field_email_verified.and_then(Option::flatten),
318            iss: field_iss.unwrap_or_default(),
319            sub: field_sub.unwrap_or_default(),
320        };
321        Ok(result)
322    }
323
324    pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
325        &self,
326        s: &mut S::SerializeStruct,
327    ) -> Result<(), S::Error> {
328        use serde::ser::SerializeStruct;
329        if let Some(val) = &self.family_name {
330            s.serialize_field("family_name", val)?;
331        }
332        if let Some(val) = &self.given_name {
333            s.serialize_field("given_name", val)?;
334        }
335        if let Some(val) = &self.email {
336            s.serialize_field("email", val)?;
337        }
338        if let Some(val) = &self.email_verified {
339            s.serialize_field("email_verified", val)?;
340        }
341        if !self.iss.is_empty() {
342            s.serialize_field("iss", &self.iss)?;
343        }
344        if !self.sub.is_empty() {
345            s.serialize_field("sub", &self.sub)?;
346        }
347        Ok(())
348    }
349}
350
351impl<'de> ::serde::de::Deserialize<'de> for UserInfoResult {
352    fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
353        // struct deserializer
354        use serde::de::{MapAccess, Visitor};
355        struct StructVisitor;
356        impl<'de> Visitor<'de> for StructVisitor {
357            type Value = UserInfoResult;
358            fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
359                f.write_str("a UserInfoResult struct")
360            }
361            fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
362                UserInfoResult::internal_deserialize(map)
363            }
364        }
365        deserializer.deserialize_struct("UserInfoResult", USER_INFO_RESULT_FIELDS, StructVisitor)
366    }
367}
368
369impl ::serde::ser::Serialize for UserInfoResult {
370    fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
371        // struct serializer
372        use serde::ser::SerializeStruct;
373        let mut s = serializer.serialize_struct("UserInfoResult", 6)?;
374        self.internal_serialize::<S>(&mut s)?;
375        s.end()
376    }
377}
378
dropbox_sdk/generated/types/openid.rs

dropbox_sdk/generated/types/
openid.rs
