facebook_access_token_api/objects/
debug_token.rs1use chrono::{
2 serde::{ts_seconds, ts_seconds_option},
3 DateTime, Utc,
4};
5use facebook_graph_api_object_error::Error;
6use facebook_permission::FacebookPermission;
7use serde::{Deserialize, Deserializer, Serialize};
8use serde_aux::field_attributes::deserialize_number_from_string;
9use serde_json::Value;
10
11#[derive(Deserialize, Serialize, Debug, Clone)]
13pub struct DebugTokenResult {
14 pub is_valid: bool,
15 pub scopes: Vec<String>,
16 pub error: Option<Error>,
17 #[serde(flatten)]
18 pub type_extra: Option<DebugTokenResultTypeExtra>,
19}
20
21#[derive(Deserialize, Serialize, Debug, Clone)]
22#[serde(tag = "type")]
23pub enum DebugTokenResultTypeExtra {
24 #[serde(rename = "APP")]
25 App(DebugTokenResultAppTypeExtra),
26 #[serde(rename = "USER")]
27 User(DebugTokenResultUserTypeExtra),
28 #[serde(rename = "PAGE")]
29 Page(DebugTokenResultPageTypeExtra),
30}
31
32#[derive(Deserialize, Serialize, Debug, Clone)]
33pub struct DebugTokenResultAppTypeExtra {
34 #[serde(deserialize_with = "deserialize_number_from_string")]
35 pub app_id: u64,
36 pub application: String,
37}
38
39#[derive(Deserialize, Serialize, Debug, Clone)]
40pub struct DebugTokenResultUserTypeExtra {
41 #[serde(deserialize_with = "deserialize_number_from_string")]
42 pub app_id: u64,
43 pub application: String,
44 #[serde(deserialize_with = "deserialize_number_from_string")]
46 pub user_id: u64,
47 #[serde(default, with = "ts_seconds_option")]
48 pub issued_at: Option<DateTime<Utc>>,
49 #[serde(default, with = "ts_seconds")]
50 pub expires_at: DateTime<Utc>,
51 #[serde(default, with = "ts_seconds")]
52 pub data_access_expires_at: DateTime<Utc>,
53 pub metadata: Option<Value>,
55 pub granular_scopes: Option<Vec<DebugTokenResultUserTypeExtraGranularScope>>,
56}
57
58impl DebugTokenResultUserTypeExtra {
59 pub fn expires(&self) -> DebugTokenResultExpires {
60 if self.expires_at.timestamp() == 0 {
61 DebugTokenResultExpires::Never
62 } else {
63 DebugTokenResultExpires::Date(self.expires_at)
64 }
65 }
66}
67
68#[derive(Deserialize, Serialize, Debug, Clone)]
69pub struct DebugTokenResultPageTypeExtra {
70 #[serde(deserialize_with = "deserialize_number_from_string")]
71 pub app_id: u64,
72 pub application: String,
73 #[serde(deserialize_with = "deserialize_number_from_string")]
75 pub user_id: u64,
76 #[serde(default, with = "ts_seconds_option")]
77 pub issued_at: Option<DateTime<Utc>>,
78 #[serde(default, with = "ts_seconds")]
79 pub expires_at: DateTime<Utc>,
80 #[serde(default, with = "ts_seconds")]
81 pub data_access_expires_at: DateTime<Utc>,
82 pub metadata: Option<Value>,
84 pub granular_scopes: Option<Vec<DebugTokenResultUserTypeExtraGranularScope>>,
85 #[serde(deserialize_with = "deserialize_number_from_string")]
87 pub profile_id: u64,
88}
89
90impl DebugTokenResultPageTypeExtra {
91 pub fn expires(&self) -> DebugTokenResultExpires {
92 if self.expires_at.timestamp() == 0 {
93 DebugTokenResultExpires::Never
94 } else {
95 DebugTokenResultExpires::Date(self.expires_at)
96 }
97 }
98}
99
100#[derive(Deserialize, Serialize, Debug, Clone)]
102pub struct DebugTokenResultUserTypeExtraGranularScope {
103 pub scope: FacebookPermission,
104 #[serde(default, deserialize_with = "deserialize_target_ids")]
105 pub target_ids: Option<Vec<i64>>,
106}
107
108fn deserialize_target_ids<'de, D>(deserializer: D) -> Result<Option<Vec<i64>>, D::Error>
109where
110 D: Deserializer<'de>,
111{
112 #[derive(Deserialize)]
113 #[serde(untagged)]
114 enum VecOrNull {
115 Vec(Vec<String>),
116 Null,
117 }
118
119 match VecOrNull::deserialize(deserializer)? {
120 VecOrNull::Vec(v) => v
121 .into_iter()
122 .map(|s| s.parse::<i64>())
123 .collect::<Result<Vec<_>, _>>()
124 .map(Some)
125 .map_err(serde::de::Error::custom),
126 VecOrNull::Null => Ok(None),
127 }
128}
129
130#[derive(Debug, Clone)]
132pub enum DebugTokenResultExpires {
133 Never,
134 Date(DateTime<Utc>),
135}