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,
}
#[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
}
}
#[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))
}