1use std::ops::Deref;
2use std::sync::{Arc, Mutex, PoisonError};
3
4use chrono::{DateTime, TimeZone, Utc};
5use serde::Serialize;
6use serde_json::{Value, json};
7
8use crate::authentification::{Credentials, CredentialsOrApiKey};
9use crate::error::{Error, Result};
10use crate::http::{client, encode, ok};
11use crate::parrot::chat::LastMessage;
12use crate::parrot::room::{ChatRoom, RoomHooks, connect_room};
13use crate::parrot::share::ChatTarget;
14use crate::shared::server::{Authorization, Hooks, Presence, Room, connect as connect_server};
15
16pub fn ticket_chat_auto_enabled<'a>(
17 emails: impl IntoIterator<Item = &'a str>,
18 reporter: &str,
19) -> bool {
20 let reporter_email = reporter.trim().to_lowercase();
21 if reporter_email.is_empty() {
22 return false;
23 }
24 let mut reporter_present = false;
25 let mut other_present = false;
26 for raw in emails {
27 let email = raw.trim().to_lowercase();
28 if email.is_empty() {
29 continue;
30 }
31 if email == reporter_email {
32 reporter_present = true;
33 } else {
34 other_present = true;
35 }
36 }
37 reporter_present && !other_present
38}
39
40pub type TicketLast = LastMessage;
41
42#[derive(Debug, Clone, Serialize)]
43#[serde(rename_all = "camelCase")]
44pub struct Ticket {
45 pub id: String,
46 pub title: String,
47 pub description: String,
48 #[serde(skip_serializing_if = "Option::is_none")]
49 pub source: Option<String>,
50 #[serde(skip_serializing_if = "Option::is_none")]
51 pub reporter: Option<String>,
52 #[serde(skip_serializing_if = "Option::is_none")]
53 pub room_reference: Option<String>,
54 pub created_at: DateTime<Utc>,
55 pub updated_at: DateTime<Utc>,
56 pub last: Option<TicketLast>,
57 pub unread: bool,
58}
59
60pub(crate) fn parse_date(value: &Value) -> Option<DateTime<Utc>> {
62 match value {
63 Value::String(value) => DateTime::parse_from_rfc3339(value)
64 .ok()
65 .map(|date| date.with_timezone(&Utc)),
66 Value::Number(value) => value
67 .as_f64()
68 .and_then(|millis| Utc.timestamp_millis_opt(millis as i64).single()),
69 _ => None,
70 }
71}
72
73pub(crate) fn optional(value: &Value) -> Option<String> {
75 value
76 .as_str()
77 .filter(|value| !value.is_empty())
78 .map(str::to_string)
79}
80
81impl Ticket {
82 pub fn from_json(json: &Value) -> Ticket {
83 let field = |camel: &str, snake: &str| {
84 if json[camel].is_null() {
85 json[snake].clone()
86 } else {
87 json[camel].clone()
88 }
89 };
90 Ticket {
91 id: match &json["id"] {
92 Value::String(id) => id.clone(),
93 id => id.to_string(),
94 },
95 title: json["title"].as_str().unwrap_or_default().to_string(),
96 description: json["description"].as_str().unwrap_or_default().to_string(),
97 source: optional(&json["source"]),
98 reporter: optional(&json["reporter"]),
99 room_reference: optional(&json["roomReference"])
100 .or_else(|| optional(&json["room_reference"])),
101 created_at: parse_date(&field("createdAt", "created_at")).unwrap_or_default(),
102 updated_at: parse_date(&field("updatedAt", "updated_at")).unwrap_or_default(),
103 last: LastMessage::from_json(&json["last"]),
104 unread: match &json["unread"] {
105 Value::Bool(unread) => *unread,
106 Value::Null => false,
107 Value::Number(unread) => unread.as_f64().is_some_and(|unread| unread != 0.0),
108 Value::String(unread) => !unread.is_empty(),
109 _ => true,
110 },
111 }
112 }
113}
114
115#[derive(Clone)]
116pub struct TicketRoom {
117 room: Room,
118 ticket: Arc<Mutex<Ticket>>,
119}
120
121impl Deref for TicketRoom {
122 type Target = Room;
123 fn deref(&self) -> &Room {
124 &self.room
125 }
126}
127
128struct TicketHooks {
129 ticket: Arc<Mutex<Ticket>>,
130 user: Arc<dyn Hooks>,
131}
132
133impl TicketHooks {
134 fn room(&self, room: &Room) -> TicketRoom {
135 TicketRoom {
136 room: room.clone(),
137 ticket: self.ticket.clone(),
138 }
139 }
140}
141
142impl Hooks for TicketHooks {
143 fn create_room(&self, room: &Room, state: &Value) {
144 self.user.create_room(room, state);
145 }
146
147 fn create_presence(&self, room: &Room, presence: &Presence) {
148 self.user.create_presence(room, presence);
149 }
150
151 fn remove_presence(&self, room: &Room, presence: &Presence) {
152 self.user.remove_presence(room, presence);
153 }
154
155 fn on_connection(&self, room: &Room, state: &Value) {
156 self.room(room).hydrate(state);
157 self.user.on_connection(room, state);
158 }
159
160 fn on_event(&self, room: &Room, packet: &Value) -> bool {
161 let handled = self.room(room).handle_event(packet);
162 self.user.on_event(room, packet) || handled
163 }
164
165 fn on_presence(&self, room: &Room) {
166 self.user.on_presence(room);
167 }
168
169 fn on_closed(&self, room: &Room, reason: Option<&str>) {
170 self.user.on_closed(room, reason);
171 }
172}
173
174impl TicketRoom {
175 pub fn ticket(&self) -> Ticket {
176 self.ticket
177 .lock()
178 .unwrap_or_else(PoisonError::into_inner)
179 .clone()
180 }
181
182 pub fn hydrate(&self, state: &Value) {
183 if state.is_object() && !state["id"].is_null() {
184 *self.ticket.lock().unwrap_or_else(PoisonError::into_inner) = Ticket::from_json(state);
185 }
186 }
187
188 pub fn handle_event(&self, packet: &Value) -> bool {
189 let event = packet["event"].as_str().unwrap_or_default();
190 if event == "update-ticket" || event == "ticket" {
191 let data = if !packet["ticket"].is_null() {
192 &packet["ticket"]
193 } else if !packet["data"]["ticket"].is_null() {
194 &packet["data"]["ticket"]
195 } else {
196 &packet["data"]
197 };
198 if !data["id"].is_null() {
199 *self.ticket.lock().unwrap_or_else(PoisonError::into_inner) =
200 Ticket::from_json(data);
201 }
202 return true;
203 }
204 false
205 }
206
207 pub async fn get_chat(
208 &self,
209 hooks: Option<Arc<dyn RoomHooks>>,
210 ) -> Result<(ChatRoom, Presence)> {
211 let authorization = self.get_authorization();
212 let token = match authorization {
213 CredentialsOrApiKey::Credentials(credentials) => credentials.token.as_str(),
214 CredentialsOrApiKey::ApiKey(_) => "",
215 };
216 if token.is_empty() {
217 return Err(Error::Message(
218 "Ticket chat requires user credentials.".to_string(),
219 ));
220 }
221 let response = client()
222 .post(format!(
223 "{}/tickets/{}/chat",
224 crate::get_url(),
225 encode(&self.ticket().id)
226 ))
227 .header("Authorization", format!("Token {token}"))
228 .json(&json!({}))
229 .send()
230 .await?;
231 let json: Value = ok(response).await?.json().await?;
232 let chat_id = json["chatId"].as_str().filter(|id| !id.is_empty());
233 let reference = json["reference"]
234 .as_str()
235 .filter(|reference| !reference.is_empty());
236 if chat_id.is_none() && reference.is_none() {
237 return Err(Error::Message("Invalid ensure response.".to_string()));
238 }
239 let reference = match reference {
240 Some(reference) => reference.to_string(),
241 None => format!("parrot:chat:{}", chat_id.unwrap_or_default()),
242 };
243 connect_room(authorization, &ChatTarget::Reference { reference }, hooks).await
244 }
245
246 pub async fn connect(
247 authorization: &Credentials,
248 target_id: &str,
249 hooks: Option<Arc<dyn Hooks>>,
250 ) -> Result<(TicketRoom, Presence)> {
251 let ticket = Arc::new(Mutex::new(Ticket {
252 id: target_id.to_string(),
253 title: String::new(),
254 description: String::new(),
255 source: None,
256 reporter: None,
257 room_reference: None,
258 created_at: DateTime::<Utc>::default(),
259 updated_at: DateTime::<Utc>::default(),
260 last: None,
261 unread: false,
262 }));
263 let me = connect_server(
264 Authorization::Server {
265 authorization: CredentialsOrApiKey::Credentials(authorization.clone()),
266 server: format!("fauna:ticket:{target_id}"),
267 group: None,
268 },
269 &format!("{}/tickets", crate::get_url()),
270 Arc::new(TicketHooks {
271 ticket: ticket.clone(),
272 user: hooks.unwrap_or_else(|| Arc::new(())),
273 }),
274 )
275 .await?;
276 let room = TicketRoom {
277 room: me.room().clone(),
278 ticket,
279 };
280 Ok((room, me))
281 }
282}
283
284pub async fn list(credentials: &Credentials) -> Result<Vec<Ticket>> {
285 let response = client()
286 .get(format!("{}/tickets", crate::get_url()))
287 .header("Authorization", format!("Token {}", credentials.token))
288 .send()
289 .await?;
290 let rows: Value = ok(response).await?.json().await?;
291 Ok(rows
292 .as_array()
293 .into_iter()
294 .flatten()
295 .map(Ticket::from_json)
296 .collect())
297}
298
299#[derive(Debug, Clone, Default, Serialize)]
301pub struct TicketDraft {
302 #[serde(skip_serializing_if = "Option::is_none")]
303 pub title: Option<String>,
304 #[serde(skip_serializing_if = "Option::is_none")]
305 pub source: Option<String>,
306 #[serde(skip_serializing_if = "Option::is_none")]
307 pub description: Option<String>,
308}
309
310pub async fn create(credentials: &Credentials, partial: &TicketDraft) -> Result<Ticket> {
311 let response = client()
312 .post(format!("{}/tickets", crate::get_url()))
313 .header("Authorization", format!("Token {}", credentials.token))
314 .json(&json!(partial))
315 .send()
316 .await?;
317 let ticket: Value = ok(response).await?.json().await?;
318 Ok(Ticket::from_json(&ticket))
319}