Skip to main content

fauna_api/
tickets.rs

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
60/// `new Date(value)` for the ISO strings and epoch milliseconds the server sends.
61pub(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
73/// A string field the TypeScript SDK reads with `value || undefined`.
74pub(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/// `{ title?, source?, description? }` in the TypeScript SDK.
300#[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}