facebook_access_token_api/objects/
debug_token.rs

1use 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//
12#[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    //
45    #[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    //
54    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    //
74    #[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    //
83    pub metadata: Option<Value>,
84    pub granular_scopes: Option<Vec<DebugTokenResultUserTypeExtraGranularScope>>,
85    //
86    #[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//
101#[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//
131#[derive(Debug, Clone)]
132pub enum DebugTokenResultExpires {
133    Never,
134    Date(DateTime<Utc>),
135}