pub mod model;
pub use model::*;
use serde::Serialize;
use crate::error::HostError;
use crate::host::core_call;
const TICKETS: &str = "tickets";
const TICKET_TYPES: &str = "ticket_types";
const TICKET_STATUSES: &str = "ticket_statuses";
const TICKET_PRIORITIES: &str = "ticket_priorities";
const TAGS: &str = "tags";
const USERS: &str = "users";
const ORGANIZATIONS: &str = "organizations";
const TEAMS: &str = "teams";
const SLA_POLICIES: &str = "sla_policies";
const CUSTOM_FIELDS: &str = "custom_fields";
const BUSINESS_HOURS: &str = "business_hours";
const MEETINGS: &str = "meetings";
#[derive(Debug, Clone, Copy, Default, Serialize)]
pub struct Paging {
#[serde(skip_serializing_if = "is_zero")]
pub limit: i32,
#[serde(skip_serializing_if = "is_zero")]
pub offset: i32,
}
impl Paging {
pub fn new(limit: i32, offset: i32) -> Self {
Self { limit, offset }
}
pub fn page(limit: i32, page: i32) -> Self {
Self { limit, offset: limit.saturating_mul(page) }
}
}
fn is_zero(v: &i32) -> bool {
*v == 0
}
fn none() -> Option<()> {
None
}
fn opt<T>(res: Result<T, HostError>) -> Result<Option<T>, HostError> {
match res {
Ok(v) => Ok(Some(v)),
Err(e) if e.is_not_found() => Ok(None),
Err(e) => Err(e),
}
}
pub fn ticket_types() -> Result<Page<TicketType>, HostError> {
core_call(TICKET_TYPES, "list", none())
}
pub fn ticket_statuses() -> Result<Page<TicketStatus>, HostError> {
core_call(TICKET_STATUSES, "list", none())
}
pub fn ticket_priorities() -> Result<Page<TicketPriority>, HostError> {
core_call(TICKET_PRIORITIES, "list", none())
}
pub fn sla_policies() -> Result<Page<SlaPolicy>, HostError> {
core_call(SLA_POLICIES, "list", none())
}
#[derive(Serialize)]
struct PriorityParams<'a> {
priority_id: &'a str,
}
pub fn sla_policy_for_priority(priority_id: &str) -> Result<Option<SlaPolicy>, HostError> {
opt(core_call(SLA_POLICIES, "for_priority", Some(PriorityParams { priority_id })))
}
#[derive(Default, Serialize)]
struct CustomFieldParams<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
entity: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
active_only: Option<bool>,
}
pub fn custom_fields(entity: Option<&str>, active_only: Option<bool>) -> Result<Page<CustomField>, HostError> {
core_call(CUSTOM_FIELDS, "list", Some(CustomFieldParams { entity, active_only }))
}
pub fn business_hours() -> Result<BusinessHours, HostError> {
core_call(BUSINESS_HOURS, "get", none())
}
pub fn tags() -> Result<Page<Tag>, HostError> {
core_call(TAGS, "list", none())
}
#[derive(Serialize)]
struct TicketParams<'a> {
ticket_id: &'a str,
}
pub fn ticket_tags(ticket_id: &str) -> Result<Page<Tag>, HostError> {
core_call(TAGS, "for_ticket", Some(TicketParams { ticket_id }))
}
#[derive(Serialize)]
struct TicketTagsParams<'a> {
ticket_id: &'a str,
names: &'a [&'a str],
}
pub fn add_ticket_tags(ticket_id: &str, names: &[&str]) -> Result<Page<Tag>, HostError> {
core_call(TAGS, "add_to_ticket", Some(TicketTagsParams { ticket_id, names }))
}
pub fn remove_ticket_tags(ticket_id: &str, names: &[&str]) -> Result<Page<Tag>, HostError> {
core_call(TAGS, "remove_from_ticket", Some(TicketTagsParams { ticket_id, names }))
}
#[derive(Serialize)]
struct ListUsersParams<'a> {
#[serde(flatten)]
paging: Paging,
#[serde(skip_serializing_if = "Option::is_none")]
role: Option<&'a str>,
}
pub fn users(paging: Paging, role: Option<&str>) -> Result<Page<User>, HostError> {
core_call(USERS, "list", Some(ListUsersParams { paging, role }))
}
#[derive(Serialize)]
struct UserIdParams<'a> {
user_id: &'a str,
}
pub fn user(user_id: &str) -> Result<Option<User>, HostError> {
opt(core_call(USERS, "get", Some(UserIdParams { user_id })))
}
#[derive(Serialize)]
struct EmailParams<'a> {
email: &'a str,
}
pub fn user_by_email(email: &str) -> Result<Option<User>, HostError> {
opt(core_call(USERS, "by_email", Some(EmailParams { email })))
}
#[derive(Serialize)]
struct OrganizationIdParams<'a> {
organization_id: &'a str,
#[serde(flatten)]
paging: Paging,
}
pub fn organizations(paging: Paging) -> Result<Page<Organization>, HostError> {
core_call(ORGANIZATIONS, "list", Some(paging))
}
pub fn organization(organization_id: &str) -> Result<Option<Organization>, HostError> {
opt(core_call(
ORGANIZATIONS,
"get",
Some(OrganizationIdParams { organization_id, paging: Paging::default() }),
))
}
pub fn organization_by_domain(domain: &str) -> Result<Option<Organization>, HostError> {
#[derive(Serialize)]
struct DomainParams<'a> {
domain: &'a str,
}
opt(core_call(ORGANIZATIONS, "by_domain", Some(DomainParams { domain })))
}
pub fn organization_members(organization_id: &str, paging: Paging) -> Result<Page<User>, HostError> {
core_call(ORGANIZATIONS, "members", Some(OrganizationIdParams { organization_id, paging }))
}
pub fn teams(paging: Paging) -> Result<Page<Team>, HostError> {
core_call(TEAMS, "list", Some(paging))
}
pub fn team_members(team_id: &str) -> Result<Page<User>, HostError> {
#[derive(Serialize)]
struct TeamIdParams<'a> {
team_id: &'a str,
}
core_call(TEAMS, "members", Some(TeamIdParams { team_id }))
}
pub fn ticket(ticket_id: &str) -> Result<Option<Ticket>, HostError> {
opt(core_call(TICKETS, "get", Some(TicketParams { ticket_id })))
}
#[derive(Serialize)]
struct RequesterParams<'a> {
requester_id: &'a str,
#[serde(flatten)]
paging: Paging,
}
pub fn tickets_by_requester(requester_id: &str, paging: Paging) -> Result<Page<Ticket>, HostError> {
core_call(TICKETS, "list_by_requester", Some(RequesterParams { requester_id, paging }))
}
pub fn tickets_by_organization(organization_id: &str, paging: Paging) -> Result<Page<Ticket>, HostError> {
core_call(
TICKETS,
"list_by_organization",
Some(OrganizationIdParams { organization_id, paging }),
)
}
#[derive(Serialize)]
struct MessagesParams<'a> {
ticket_id: &'a str,
#[serde(skip_serializing_if = "is_false")]
include_private: bool,
}
fn is_false(v: &bool) -> bool {
!*v
}
pub fn ticket_messages(ticket_id: &str, include_private: bool) -> Result<Page<TicketMessage>, HostError> {
core_call(TICKETS, "messages", Some(MessagesParams { ticket_id, include_private }))
}
#[derive(Serialize)]
struct AddNoteParams<'a> {
ticket_id: &'a str,
author_id: &'a str,
body: &'a str,
}
#[derive(serde::Deserialize)]
struct AddNoteResult {
message_id: String,
}
pub fn add_ticket_note(ticket_id: &str, author_id: &str, body: &str) -> Result<String, HostError> {
let res: AddNoteResult = core_call(TICKETS, "add_note", Some(AddNoteParams { ticket_id, author_id, body }))?;
Ok(res.message_id)
}
#[derive(Serialize)]
struct UpdateTicketParams<'a> {
ticket_id: &'a str,
#[serde(skip_serializing_if = "Option::is_none")]
status_id: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
priority_id: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
assigned_agent_id: Option<&'a str>,
}
#[derive(Debug, Clone, Default)]
pub struct TicketUpdate<'a> {
pub status_id: Option<&'a str>,
pub priority_id: Option<&'a str>,
pub assigned_agent_id: Option<&'a str>,
}
impl<'a> TicketUpdate<'a> {
pub fn new() -> Self {
Self::default()
}
pub fn status(mut self, id: &'a str) -> Self {
self.status_id = Some(id);
self
}
pub fn priority(mut self, id: &'a str) -> Self {
self.priority_id = Some(id);
self
}
pub fn assign(mut self, agent_id: &'a str) -> Self {
self.assigned_agent_id = Some(agent_id);
self
}
}
pub fn update_ticket(ticket_id: &str, update: TicketUpdate<'_>) -> Result<(), HostError> {
let _: serde_json::Value = core_call(
TICKETS,
"update",
Some(UpdateTicketParams {
ticket_id,
status_id: update.status_id,
priority_id: update.priority_id,
assigned_agent_id: update.assigned_agent_id,
}),
)?;
Ok(())
}
#[derive(Serialize)]
struct CreateTicketParams<'a> {
requester_id: &'a str,
subject: &'a str,
#[serde(skip_serializing_if = "str::is_empty")]
body: &'a str,
#[serde(skip_serializing_if = "Option::is_none")]
ticket_type_id: Option<&'a str>,
}
#[derive(serde::Deserialize)]
struct CreateTicketResult {
ticket_id: String,
}
pub fn create_ticket(
requester_id: &str,
subject: &str,
body: &str,
ticket_type_id: Option<&str>,
) -> Result<String, HostError> {
let res: CreateTicketResult = core_call(
TICKETS,
"create",
Some(CreateTicketParams { requester_id, subject, body, ticket_type_id }),
)?;
Ok(res.ticket_id)
}
#[derive(Serialize)]
struct UpsertCustomerParams<'a> {
email: &'a str,
#[serde(skip_serializing_if = "Option::is_none")]
name: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
phone: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
organization_id: Option<&'a str>,
}
#[derive(serde::Deserialize)]
struct UpsertCustomerResult {
user_id: String,
}
pub fn upsert_customer(
email: &str,
name: Option<&str>,
phone: Option<&str>,
organization_id: Option<&str>,
) -> Result<String, HostError> {
let res: UpsertCustomerResult = core_call(
USERS,
"upsert",
Some(UpsertCustomerParams { email, name, phone, organization_id }),
)?;
Ok(res.user_id)
}
#[derive(Serialize)]
struct UpsertOrganizationParams<'a> {
name: &'a str,
#[serde(skip_serializing_if = "Option::is_none")]
domain: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
website: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
phone: Option<&'a str>,
}
#[derive(serde::Deserialize)]
struct UpsertOrganizationResult {
organization_id: String,
}
pub fn upsert_organization(
name: &str,
domain: Option<&str>,
website: Option<&str>,
phone: Option<&str>,
) -> Result<String, HostError> {
let res: UpsertOrganizationResult = core_call(
ORGANIZATIONS,
"upsert",
Some(UpsertOrganizationParams { name, domain, website, phone }),
)?;
Ok(res.organization_id)
}
#[derive(Serialize)]
struct ApplyExternalCalendarUpdateParams<'a> {
external_event_id: &'a str,
cancelled: bool,
#[serde(skip_serializing_if = "Option::is_none")]
new_start: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
new_end: Option<&'a str>,
}
pub fn apply_external_calendar_update(
external_event_id: &str,
cancelled: bool,
new_start: Option<&str>,
new_end: Option<&str>,
) -> Result<(), HostError> {
let _: serde_json::Value = core_call(
MEETINGS,
"apply_external_update",
Some(ApplyExternalCalendarUpdateParams { external_event_id, cancelled, new_start, new_end }),
)?;
Ok(())
}