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

dropbox_sdk/generated/types/
openid.rs
