fauna-api 1.0.807

The Fauna SDK for Rust: accounts, Drive, groups, calendar, chats, payments, Parrot and live rooms.
Documentation
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,
}

/// `new Date(value)` for the ISO strings and epoch milliseconds the server sends.
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,
    }
}

/// A string field the TypeScript SDK reads with `value || undefined`.
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())
}

/// `{ title?, source?, description? }` in the TypeScript SDK.
#[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))
}