use std::ops::Deref;
use std::sync::{Arc, Mutex, PoisonError};
use chrono::{DateTime, TimeZone, Utc};
use serde::Serialize;
use serde_json::{Value, json};
use crate::authentification::{Credentials, CredentialsOrApiKey};
use crate::error::{Error, Result};
use crate::http::{client, encode, ok};
use crate::parrot::generative::Content;
use crate::parrot::room::{ChatRoom, RoomHooks, connect_room};
use crate::parrot::share::ChatTarget;
use crate::shared::server::{Authorization, Hooks, Presence, Room, connect as connect_server};
pub fn ticket_chat_auto_enabled<'a>(
emails: impl IntoIterator<Item = &'a str>,
reporter: &str,
) -> bool {
let reporter_email = reporter.trim().to_lowercase();
if reporter_email.is_empty() {
return false;
}
let mut reporter_present = false;
let mut other_present = false;
for raw in emails {
let email = raw.trim().to_lowercase();
if email.is_empty() {
continue;
}
if email == reporter_email {
reporter_present = true;
} else {
other_present = true;
}
}
reporter_present && !other_present
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Ticket {
pub id: String,
pub title: String,
pub description: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reporter: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub room_reference: Option<String>,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
#[serde(skip)]
pub last: Option<Content>,
pub unread: bool,
}
pub(crate) fn parse_date(value: &Value) -> Option<DateTime<Utc>> {
match value {
Value::String(value) => DateTime::parse_from_rfc3339(value)
.ok()
.map(|date| date.with_timezone(&Utc)),
Value::Number(value) => value
.as_f64()
.and_then(|millis| Utc.timestamp_millis_opt(millis as i64).single()),
_ => None,
}
}
pub(crate) fn optional(value: &Value) -> Option<String> {
value
.as_str()
.filter(|value| !value.is_empty())
.map(str::to_string)
}
impl Ticket {
pub fn from_json(json: &Value) -> Ticket {
let field = |camel: &str, snake: &str| {
if json[camel].is_null() {
json[snake].clone()
} else {
json[camel].clone()
}
};
Ticket {
id: match &json["id"] {
Value::String(id) => id.clone(),
id => id.to_string(),
},
title: json["title"].as_str().unwrap_or_default().to_string(),
description: json["description"].as_str().unwrap_or_default().to_string(),
source: optional(&json["source"]),
reporter: optional(&json["reporter"]),
room_reference: optional(&json["roomReference"])
.or_else(|| optional(&json["room_reference"])),
created_at: parse_date(&field("createdAt", "created_at")).unwrap_or_default(),
updated_at: parse_date(&field("updatedAt", "updated_at")).unwrap_or_default(),
last: json["last"]
.is_object()
.then(|| Content::from_json(&json["last"], None)),
unread: match &json["unread"] {
Value::Bool(unread) => *unread,
Value::Null => false,
Value::Number(unread) => unread.as_f64().is_some_and(|unread| unread != 0.0),
Value::String(unread) => !unread.is_empty(),
_ => true,
},
}
}
}
#[derive(Clone)]
pub struct TicketRoom {
room: Room,
ticket: Arc<Mutex<Ticket>>,
}
impl Deref for TicketRoom {
type Target = Room;
fn deref(&self) -> &Room {
&self.room
}
}
struct TicketHooks {
ticket: Arc<Mutex<Ticket>>,
user: Arc<dyn Hooks>,
}
impl TicketHooks {
fn room(&self, room: &Room) -> TicketRoom {
TicketRoom {
room: room.clone(),
ticket: self.ticket.clone(),
}
}
}
impl Hooks for TicketHooks {
fn create_room(&self, room: &Room, state: &Value) {
self.user.create_room(room, state);
}
fn create_presence(&self, room: &Room, presence: &Presence) {
self.user.create_presence(room, presence);
}
fn remove_presence(&self, room: &Room, presence: &Presence) {
self.user.remove_presence(room, presence);
}
fn on_connection(&self, room: &Room, state: &Value) {
self.room(room).hydrate(state);
self.user.on_connection(room, state);
}
fn on_event(&self, room: &Room, packet: &Value) -> bool {
let handled = self.room(room).handle_event(packet);
self.user.on_event(room, packet) || handled
}
fn on_presence(&self, room: &Room) {
self.user.on_presence(room);
}
fn on_closed(&self, room: &Room, reason: Option<&str>) {
self.user.on_closed(room, reason);
}
}
impl TicketRoom {
pub fn ticket(&self) -> Ticket {
self.ticket
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone()
}
pub fn hydrate(&self, state: &Value) {
if state.is_object() && !state["id"].is_null() {
*self.ticket.lock().unwrap_or_else(PoisonError::into_inner) = Ticket::from_json(state);
}
}
pub fn handle_event(&self, packet: &Value) -> bool {
let event = packet["event"].as_str().unwrap_or_default();
if event == "update-ticket" || event == "ticket" {
let data = if !packet["ticket"].is_null() {
&packet["ticket"]
} else if !packet["data"]["ticket"].is_null() {
&packet["data"]["ticket"]
} else {
&packet["data"]
};
if !data["id"].is_null() {
*self.ticket.lock().unwrap_or_else(PoisonError::into_inner) =
Ticket::from_json(data);
}
return true;
}
false
}
pub async fn get_chat(
&self,
hooks: Option<Arc<dyn RoomHooks>>,
) -> Result<(ChatRoom, Presence)> {
let authorization = self.get_authorization();
let token = match authorization {
CredentialsOrApiKey::Credentials(credentials) => credentials.token.as_str(),
CredentialsOrApiKey::ApiKey(_) => "",
};
if token.is_empty() {
return Err(Error::Message(
"Ticket chat requires user credentials.".to_string(),
));
}
let response = client()
.post(format!(
"{}/tickets/{}/chat",
crate::get_url(),
encode(&self.ticket().id)
))
.header("Authorization", format!("Token {token}"))
.json(&json!({}))
.send()
.await?;
let json: Value = ok(response).await?.json().await?;
let chat_id = json["chatId"].as_str().filter(|id| !id.is_empty());
let reference = json["reference"]
.as_str()
.filter(|reference| !reference.is_empty());
if chat_id.is_none() && reference.is_none() {
return Err(Error::Message("Invalid ensure response.".to_string()));
}
let reference = match reference {
Some(reference) => reference.to_string(),
None => format!("parrot:chat:{}", chat_id.unwrap_or_default()),
};
connect_room(authorization, &ChatTarget::Reference { reference }, hooks).await
}
pub async fn connect(
authorization: &Credentials,
target_id: &str,
hooks: Option<Arc<dyn Hooks>>,
) -> Result<(TicketRoom, Presence)> {
let ticket = Arc::new(Mutex::new(Ticket {
id: target_id.to_string(),
title: String::new(),
description: String::new(),
source: None,
reporter: None,
room_reference: None,
created_at: DateTime::<Utc>::default(),
updated_at: DateTime::<Utc>::default(),
last: None,
unread: false,
}));
let me = connect_server(
Authorization::Server {
authorization: CredentialsOrApiKey::Credentials(authorization.clone()),
server: format!("fauna:ticket:{target_id}"),
group: None,
},
&format!("{}/tickets", crate::get_url()),
Arc::new(TicketHooks {
ticket: ticket.clone(),
user: hooks.unwrap_or_else(|| Arc::new(())),
}),
)
.await?;
let room = TicketRoom {
room: me.room().clone(),
ticket,
};
Ok((room, me))
}
}
pub async fn list(credentials: &Credentials) -> Result<Vec<Ticket>> {
let response = client()
.get(format!("{}/tickets", crate::get_url()))
.header("Authorization", format!("Token {}", credentials.token))
.send()
.await?;
let rows: Value = ok(response).await?.json().await?;
Ok(rows
.as_array()
.into_iter()
.flatten()
.map(Ticket::from_json)
.collect())
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct TicketDraft {
#[serde(skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
pub async fn create(credentials: &Credentials, partial: &TicketDraft) -> Result<Ticket> {
let response = client()
.post(format!("{}/tickets", crate::get_url()))
.header("Authorization", format!("Token {}", credentials.token))
.json(&json!(partial))
.send()
.await?;
let ticket: Value = ok(response).await?.json().await?;
Ok(Ticket::from_json(&ticket))
}