fauna-api 1.0.793

The Fauna SDK for Rust: accounts, Drive, groups, calendar, chats, payments, Parrot and live rooms.
Documentation
use std::ops::Deref;

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};

use crate::authentification::Credentials;
use crate::error::Result;
use crate::http::{client, encode, ok};
use crate::tickets::{Ticket as PublicTicket, optional, parse_date};

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Comment {
    pub content: String,
    pub user: String,
    pub created_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum TicketStatus {
    Open,
    Progress,
    Resolved,
    Closed,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum TicketPriority {
    Low,
    Medium,
    High,
}

/// The public ticket plus the board fields only admins see.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Ticket {
    #[serde(flatten)]
    pub ticket: PublicTicket,
    pub status: TicketStatus,
    pub priority: TicketPriority,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub assignee: Option<String>,
    pub comments: Vec<Comment>,
}

impl Deref for Ticket {
    type Target = PublicTicket;
    fn deref(&self) -> &PublicTicket {
        &self.ticket
    }
}

/// `Partial<Ticket>` in the TypeScript SDK.
#[derive(Debug, Clone, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PartialTicket {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<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>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unread: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<TicketStatus>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub priority: Option<TicketPriority>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub assignee: Option<String>,
}

impl Ticket {
    pub fn from_json(json: &Value) -> Ticket {
        Ticket {
            ticket: PublicTicket::from_json(json),
            status: serde_json::from_value(json["status"].clone()).unwrap_or(TicketStatus::Open),
            priority: serde_json::from_value(json["priority"].clone())
                .unwrap_or(TicketPriority::Medium),
            assignee: optional(&json["assignee"]),
            comments: json["comments"]
                .as_array()
                .into_iter()
                .flatten()
                .map(|comment| Comment {
                    content: comment["content"].as_str().unwrap_or_default().to_string(),
                    user: comment["user"].as_str().unwrap_or_default().to_string(),
                    created_at: parse_date(&comment["createdAt"]).unwrap_or_default(),
                })
                .collect(),
        }
    }
}

pub async fn get(credentials: &Credentials, id: &str) -> Result<Ticket> {
    let response = client()
        .get(format!("{}/tickets/{}", crate::get_url(), encode(id)))
        .header("Authorization", format!("Token {}", credentials.token))
        .header("Board", "1")
        .send()
        .await?;
    let ticket: Value = ok(response).await?.json().await?;
    Ok(Ticket::from_json(&ticket))
}

pub async fn update(
    credentials: &Credentials,
    id: &str,
    partial: &PartialTicket,
) -> Result<Ticket> {
    let response = client()
        .patch(format!("{}/tickets/{}", crate::get_url(), encode(id)))
        .header("Authorization", format!("Token {}", credentials.token))
        .json(partial)
        .send()
        .await?;
    let ticket: Value = ok(response).await?.json().await?;
    Ok(Ticket::from_json(&ticket))
}

pub async fn remove(credentials: &Credentials, id: &str) -> Result<bool> {
    let response = client()
        .delete(format!("{}/tickets/{}", crate::get_url(), encode(id)))
        .header("Authorization", format!("Token {}", credentials.token))
        .send()
        .await?;
    ok(response).await?;
    Ok(true)
}

pub async fn comment(credentials: &Credentials, id: &str, content: &str) -> Result<Ticket> {
    let response = client()
        .post(format!(
            "{}/tickets/{}/comment",
            crate::get_url(),
            encode(id)
        ))
        .header("Authorization", format!("Token {}", credentials.token))
        .json(&json!({ "content": content }))
        .send()
        .await?;
    let ticket: Value = ok(response).await?.json().await?;
    Ok(Ticket::from_json(&ticket))
}