1use chrono::{DateTime, Utc};
2use hmac::{Hmac, Mac};
3use serde::{Deserialize, Serialize};
4use serde_json::json;
5use sha2::Sha256;
6
7use crate::authentification::{CredentialsOrApiKey, Profile};
8use crate::error::Result;
9use crate::groups::GroupRef;
10use crate::http::{client, encode, ok};
11
12#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
16pub enum EventType {
17 #[serde(rename = "chat.message")]
18 ChatMessage,
19 #[serde(rename = "group.joined")]
20 GroupJoined,
21 #[serde(rename = "group.left")]
22 GroupLeft,
23 #[serde(rename = "payment.succeeded")]
24 PaymentSucceeded,
25 #[serde(rename = "payment.expired")]
26 PaymentExpired,
27 #[serde(rename = "payment.refunded")]
28 PaymentRefunded,
29 #[serde(rename = "payment.disputed")]
30 PaymentDisputed,
31 #[serde(rename = "calendar.event.started")]
32 CalendarEventStarted,
33}
34
35#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
37#[serde(rename_all = "camelCase")]
38pub enum WebhookOwner {
39 Group(String),
40 Chat(String),
41 Key,
42}
43
44#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(rename_all = "camelCase")]
47pub struct Webhook {
48 pub id: String,
49
50 pub url: String,
51 pub events: Vec<EventType>,
52
53 #[serde(default, skip_serializing_if = "Option::is_none")]
56 pub creator: Option<Profile>,
57 pub created: DateTime<Utc>,
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
62pub struct Registration {
63 pub webhook: Webhook,
64 pub secret: String,
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69pub struct Delivery {
70 pub id: String,
71 pub r#type: EventType,
72 pub created: i64,
74 pub data: serde_json::Value,
75}
76
77#[derive(Debug, Clone, Serialize, Deserialize)]
79pub struct Reaction {
80 pub emoji: String,
81 pub position: u32,
83 pub on: bool,
84}
85
86#[derive(Debug, Clone, Serialize, Deserialize)]
89#[serde(rename_all = "camelCase")]
90pub struct ChatMessage {
91 pub chat_id: String,
92 pub chat_name: String,
93 #[serde(default, skip_serializing_if = "Option::is_none")]
94 pub group: Option<String>,
95 pub position: u32,
96
97 pub author: Profile,
98 pub text: String,
99 #[serde(default)]
101 pub mentions: Vec<Profile>,
102 #[serde(default, skip_serializing_if = "Option::is_none")]
104 pub reaction: Option<Reaction>,
105
106 pub created: i64,
108}
109
110#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
113#[serde(untagged)]
114pub enum GroupChangeMember {
115 Person { email: String },
116 Group { group: GroupRef },
117}
118
119#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
122#[serde(rename_all = "lowercase")]
123pub enum GroupChangeReason {
124 Joined,
125 Left,
126 Removed,
127 Unnested,
128 Deleted,
129}
130
131#[derive(Debug, Clone, Serialize, Deserialize)]
135pub struct GroupChange {
136 pub group: GroupRef,
137 pub member: GroupChangeMember,
138 pub reason: GroupChangeReason,
139}
140
141pub async fn create(
145 authorization: &CredentialsOrApiKey,
146 owner: &WebhookOwner,
147 url: &str,
148 events: &[EventType],
149 secret: Option<&str>,
150) -> Result<Registration> {
151 let response = client()
152 .post(format!("{}/webhooks", crate::get_url()))
153 .header(
154 "Authorization",
155 match authorization {
156 CredentialsOrApiKey::Credentials(credentials) => {
157 format!("Token {}", credentials.token)
158 }
159 CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
160 },
161 )
162 .json(&json!({ "owner": owner, "url": url, "events": events, "secret": secret }))
163 .send()
164 .await?;
165 Ok(ok(response).await?.json().await?)
166}
167
168pub async fn list(
170 authorization: &CredentialsOrApiKey,
171 owner: &WebhookOwner,
172) -> Result<Vec<Webhook>> {
173 let response = client()
174 .post(format!("{}/webhooks/list", crate::get_url()))
175 .header(
176 "Authorization",
177 match authorization {
178 CredentialsOrApiKey::Credentials(credentials) => {
179 format!("Token {}", credentials.token)
180 }
181 CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
182 },
183 )
184 .json(&json!({ "owner": owner }))
185 .send()
186 .await?;
187 Ok(ok(response).await?.json().await?)
188}
189
190pub async fn remove(authorization: &CredentialsOrApiKey, id: &str) -> Result<()> {
191 let response = client()
192 .delete(format!("{}/webhooks/{}", crate::get_url(), encode(id)))
193 .header(
194 "Authorization",
195 match authorization {
196 CredentialsOrApiKey::Credentials(credentials) => {
197 format!("Token {}", credentials.token)
198 }
199 CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
200 },
201 )
202 .send()
203 .await?;
204 ok(response).await?;
205 Ok(())
206}
207
208pub async fn verify(
213 secret: &str,
214 body: &str,
215 signature: &str,
216 tolerance: Option<i64>,
217) -> Result<bool> {
218 let mut timestamp = None;
219 let mut expected = None;
220 for piece in signature.split(',') {
221 if let Some((key, value)) = piece.split_once('=') {
222 match key.trim() {
223 "t" => timestamp = value.trim().parse::<i64>().ok(),
224 "v1" => expected = hex(value.trim()),
225 _ => {}
226 }
227 }
228 }
229 let (Some(timestamp), Some(expected)) = (timestamp, expected) else {
230 return Ok(false);
231 };
232 if (Utc::now().timestamp() - timestamp).abs() > tolerance.unwrap_or(300) {
233 return Ok(false);
234 }
235 let Ok(mut mac) = Hmac::<Sha256>::new_from_slice(secret.as_bytes()) else {
236 return Ok(false);
237 };
238 mac.update(format!("{timestamp}.{body}").as_bytes());
239 Ok(mac.verify_slice(&expected).is_ok())
240}
241
242fn hex(text: &str) -> Option<Vec<u8>> {
243 if !text.len().is_multiple_of(2) {
244 return None;
245 }
246 (0..text.len())
247 .step_by(2)
248 .map(|at| u8::from_str_radix(text.get(at..at + 2)?, 16).ok())
249 .collect()
250}