use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value, json};
use crate::authentification::{Credentials, CredentialsOrApiKey};
use crate::error::Result;
use crate::groups::Group;
use crate::http::{client, encode, ok};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Answer {
Invited,
Yes,
No,
Maybe,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Attendee {
pub email: String,
pub response: Answer,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum CalendarKind {
Person,
Group,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Calendar {
pub kind: CalendarKind,
pub id: String,
pub name: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Source {
Google,
Microsoft,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Event {
pub id: String,
pub calendar: Calendar,
pub title: String,
#[serde(default)]
pub notes: String,
#[serde(default)]
pub place: String,
#[serde(with = "chrono::serde::ts_milliseconds")]
pub start: DateTime<Utc>,
#[serde(with = "chrono::serde::ts_milliseconds")]
pub end: DateTime<Utc>,
#[serde(default)]
pub all_day: bool,
#[serde(default)]
pub time_zone: String,
#[serde(default)]
pub recurrence: String,
#[serde(default)]
pub reminder: u32,
#[serde(default)]
pub attendees: Vec<Attendee>,
#[serde(default)]
pub source: Option<Source>,
#[serde(default)]
pub editable: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub response: Option<Answer>,
#[serde(with = "chrono::serde::ts_milliseconds")]
pub created: DateTime<Utc>,
#[serde(with = "chrono::serde::ts_milliseconds")]
pub updated: DateTime<Utc>,
}
#[derive(Debug, Clone)]
pub struct Draft {
pub title: String,
pub start: DateTime<Utc>,
pub end: DateTime<Utc>,
pub all_day: Option<bool>,
pub time_zone: Option<String>,
pub place: Option<String>,
pub notes: Option<String>,
pub recurrence: Option<String>,
pub reminder: Option<u32>,
pub attendees: Option<Vec<String>>,
}
#[derive(Debug, Clone, Default)]
pub struct PartialDraft {
pub title: Option<String>,
pub start: Option<DateTime<Utc>>,
pub end: Option<DateTime<Utc>>,
pub all_day: Option<bool>,
pub time_zone: Option<String>,
pub place: Option<String>,
pub notes: Option<String>,
pub recurrence: Option<String>,
pub reminder: Option<u32>,
pub attendees: Option<Vec<String>>,
}
fn draft_json(draft: PartialDraft) -> Value {
let mut body = Map::new();
let mut set = |key: &str, value: Option<Value>| {
if let Some(value) = value {
body.insert(key.to_string(), value);
}
};
set("title", draft.title.map(Value::from));
set("start", draft.start.map(|at| json!(at.timestamp_millis())));
set("end", draft.end.map(|at| json!(at.timestamp_millis())));
set("allDay", draft.all_day.map(Value::from));
set("timeZone", draft.time_zone.map(Value::from));
set("place", draft.place.map(Value::from));
set("notes", draft.notes.map(Value::from));
set("recurrence", draft.recurrence.map(Value::from));
set("reminder", draft.reminder.map(Value::from));
set("attendees", draft.attendees.map(|emails| json!(emails)));
Value::Object(body)
}
pub async fn list(
authorization: &CredentialsOrApiKey,
from: DateTime<Utc>,
to: DateTime<Utc>,
group: Option<&Group>,
) -> Result<Vec<Event>> {
let mut request = client()
.get(format!(
"{}/calendar/events?from={}&to={}",
crate::get_url(),
from.timestamp_millis(),
to.timestamp_millis()
))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request.send().await?;
Ok(ok(response).await?.json().await?)
}
pub async fn get(authorization: &CredentialsOrApiKey, id: &str) -> Result<Event> {
let response = client()
.get(format!(
"{}/calendar/events/{}",
crate::get_url(),
encode(id)
))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn create(
authorization: &CredentialsOrApiKey,
draft: Draft,
group: Option<&Group>,
) -> Result<Event> {
let mut request = client()
.post(format!("{}/calendar/events", crate::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let body = draft_json(PartialDraft {
title: Some(draft.title),
start: Some(draft.start),
end: Some(draft.end),
all_day: draft.all_day,
time_zone: draft.time_zone,
place: draft.place,
notes: draft.notes,
recurrence: draft.recurrence,
reminder: draft.reminder,
attendees: draft.attendees,
});
let response = request.json(&body).send().await?;
Ok(ok(response).await?.json().await?)
}
pub async fn update(
authorization: &CredentialsOrApiKey,
id: &str,
update: PartialDraft,
) -> Result<Event> {
let response = client()
.patch(format!(
"{}/calendar/events/{}",
crate::get_url(),
encode(id)
))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.json(&draft_json(update))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn remove(authorization: &CredentialsOrApiKey, id: &str) -> Result<()> {
let response = client()
.delete(format!(
"{}/calendar/events/{}",
crate::get_url(),
encode(id)
))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.send()
.await?;
ok(response).await?;
Ok(())
}
pub async fn respond(
authorization: &CredentialsOrApiKey,
id: &str,
answer: Answer,
) -> Result<Event> {
let response = client()
.post(format!(
"{}/calendar/events/{}/respond",
crate::get_url(),
encode(id)
))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.json(&json!({ "response": answer }))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
#[derive(Deserialize)]
struct FeedUrl {
url: String,
}
pub async fn feed(authorization: &CredentialsOrApiKey, group: Option<&Group>) -> Result<String> {
let mut request = client()
.get(format!("{}/calendar/feed", crate::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request.send().await?;
let feed: FeedUrl = ok(response).await?.json().await?;
Ok(feed.url)
}
pub async fn reset_feed(credentials: &Credentials, group: Option<&Group>) -> Result<String> {
let mut request = client()
.post(format!("{}/calendar/feed/reset", crate::get_url()))
.header("Authorization", format!("Token {}", credentials.token));
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request.send().await?;
let feed: FeedUrl = ok(response).await?.json().await?;
Ok(feed.url)
}