Musselman/kitchen-freezer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Better distinction ID/UID

Browse source
This commit is contained in:
daladim 2021-11-15 23:52:26 +01:00
parent 56b86adf02
commit 2f7c14d0aa
13 changed files with 165 additions and 221 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/cache.rs
View file

@ -86,7 +86,7 @@ impl Cache {
continue;
},
Ok(cal) =>
data.calendars.insert(cal.id().clone(), Arc::new(Mutex::new(cal))),
data.calendars.insert(cal.url().clone(), Arc::new(Mutex::new(cal))),
};
}
},
@ -259,13 +259,13 @@ mod tests {
{
let mut bucket_list = bucket_list.lock().unwrap();
let cal_id = bucket_list.id().clone();
let cal_url = bucket_list.url().clone();
bucket_list.add_item(Item::Task(Task::new(
String::from("Attend a concert of JS Bach"), false, &cal_id
String::from("Attend a concert of JS Bach"), false, &cal_url
))).await.unwrap();
bucket_list.add_item(Item::Task(Task::new(
String::from("Climb the Lighthouse of Alexandria"), true, &cal_id
String::from("Climb the Lighthouse of Alexandria"), true, &cal_url
))).await.unwrap();
}

62
src/calendar/cached_calendar.rs
View file

@ -4,12 +4,12 @@ use std::error::Error;
use serde::{Deserialize, Serialize};
use async_trait::async_trait;
use csscolorparser::Color;
use url::Url;
use crate::item::SyncStatus;
use crate::traits::{BaseCalendar, CompleteCalendar};
use crate::calendar::{CalendarId, SupportedComponents};
use crate::Item;
use crate::item::ItemId;
#[cfg(feature = "local_calendar_mocks_remote_calendars")]
use std::sync::{Arc, Mutex};
@ -23,14 +23,14 @@ use crate::mock_behaviour::MockBehaviour;
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct CachedCalendar {
name: String,
id: CalendarId,
url: Url,
supported_components: SupportedComponents,
color: Option<Color>,
#[cfg(feature = "local_calendar_mocks_remote_calendars")]
#[serde(skip)]
mock_behaviour: Option<Arc<Mutex<MockBehaviour>>>,
items: HashMap<ItemId, Item>,
items: HashMap<Url, Item>,
}
impl CachedCalendar {
@ -65,7 +65,7 @@ impl CachedCalendar {
fn regular_add_or_update_item(&mut self, item: Item) -> Result<SyncStatus, Box<dyn Error>> {
let ss_clone = item.sync_status().clone();
log::debug!("Adding or updating an item with {:?}", ss_clone);
self.items.insert(item.id().clone(), item);
self.items.insert(item.url().clone(), item);
Ok(ss_clone)
}
@ -78,7 +78,7 @@ impl CachedCalendar {
_ => item.set_sync_status(SyncStatus::random_synced()),
};
let ss_clone = item.sync_status().clone();
self.items.insert(item.id().clone(), item);
self.items.insert(item.url().clone(), item);
Ok(ss_clone)
}
@ -86,7 +86,7 @@ impl CachedCalendar {
#[cfg(any(test, feature = "integration_tests"))]
pub async fn has_same_observable_content_as(&self, other: &CachedCalendar) -> Result<bool, Box<dyn Error>> {
if self.name != other.name
|| self.id != other.id
|| self.url != other.url
|| self.supported_components != other.supported_components
|| self.color != other.color
{
@ -119,35 +119,35 @@ impl CachedCalendar {
}
/// The non-async version of [`Self::get_item_ids`]
pub fn get_item_ids_sync(&self) -> Result<HashSet<ItemId>, Box<dyn Error>> {
pub fn get_item_ids_sync(&self) -> Result<HashSet<Url>, Box<dyn Error>> {
Ok(self.items.iter()
.map(|(id, _)| id.clone())
.map(|(url, _)| url.clone())
.collect()
)
}
/// The non-async version of [`Self::get_items`]
pub fn get_items_sync(&self) -> Result<HashMap<ItemId, &Item>, Box<dyn Error>> {
pub fn get_items_sync(&self) -> Result<HashMap<Url, &Item>, Box<dyn Error>> {
Ok(self.items.iter()
.map(|(id, item)| (id.clone(), item))
.map(|(url, item)| (url.clone(), item))
.collect()
)
}
/// The non-async version of [`Self::get_item_by_id`]
pub fn get_item_by_id_sync<'a>(&'a self, id: &ItemId) -> Option<&'a Item> {
pub fn get_item_by_id_sync<'a>(&'a self, id: &Url) -> Option<&'a Item> {
self.items.get(id)
}
/// The non-async version of [`Self::get_item_by_id_mut`]
pub fn get_item_by_id_mut_sync<'a>(&'a mut self, id: &ItemId) -> Option<&'a mut Item> {
pub fn get_item_by_id_mut_sync<'a>(&'a mut self, id: &Url) -> Option<&'a mut Item> {
self.items.get_mut(id)
}
/// The non-async version of [`Self::add_item`]
pub fn add_item_sync(&mut self, item: Item) -> Result<SyncStatus, Box<dyn Error>> {
if self.items.contains_key(item.id()) {
return Err(format!("Item {:?} cannot be added, it exists already", item.id()).into());
if self.items.contains_key(item.url()) {
return Err(format!("Item {:?} cannot be added, it exists already", item.url()).into());
}
#[cfg(not(feature = "local_calendar_mocks_remote_calendars"))]
return self.regular_add_or_update_item(item);
@ -158,8 +158,8 @@ impl CachedCalendar {
/// The non-async version of [`Self::update_item`]
pub fn update_item_sync(&mut self, item: Item) -> Result<SyncStatus, Box<dyn Error>> {
if self.items.contains_key(item.id()) == false {
return Err(format!("Item {:?} cannot be updated, it does not already exist", item.id()).into());
if self.items.contains_key(item.url()) == false {
return Err(format!("Item {:?} cannot be updated, it does not already exist", item.url()).into());
}
#[cfg(not(feature = "local_calendar_mocks_remote_calendars"))]
return self.regular_add_or_update_item(item);
@ -169,7 +169,7 @@ impl CachedCalendar {
}
/// The non-async version of [`Self::mark_for_deletion`]
pub fn mark_for_deletion_sync(&mut self, item_id: &ItemId) -> Result<(), Box<dyn Error>> {
pub fn mark_for_deletion_sync(&mut self, item_id: &Url) -> Result<(), Box<dyn Error>> {
match self.items.get_mut(item_id) {
None => Err("no item for this key".into()),
Some(item) => {
@ -197,7 +197,7 @@ impl CachedCalendar {
}
/// The non-async version of [`Self::immediately_delete_item`]
pub fn immediately_delete_item_sync(&mut self, item_id: &ItemId) -> Result<(), Box<dyn Error>> {
pub fn immediately_delete_item_sync(&mut self, item_id: &Url) -> Result<(), Box<dyn Error>> {
match self.items.remove(item_id) {
None => Err(format!("Item {} is absent from this calendar", item_id).into()),
Some(_) => Ok(())
@ -213,8 +213,8 @@ impl BaseCalendar for CachedCalendar {
&self.name
}
fn id(&self) -> &CalendarId {
&self.id
fn url(&self) -> &Url {
&self.url
}
fn supported_components(&self) -> SupportedComponents {
@ -236,36 +236,36 @@ impl BaseCalendar for CachedCalendar {
#[async_trait]
impl CompleteCalendar for CachedCalendar {
fn new(name: String, id: CalendarId, supported_components: SupportedComponents, color: Option<Color>) -> Self {
fn new(name: String, url: CalendarId, supported_components: SupportedComponents, color: Option<Color>) -> Self {
Self {
name, id, supported_components, color,
name, url, supported_components, color,
#[cfg(feature = "local_calendar_mocks_remote_calendars")]
mock_behaviour: None,
items: HashMap::new(),
}
}
async fn get_item_ids(&self) -> Result<HashSet<ItemId>, Box<dyn Error>> {
async fn get_item_ids(&self) -> Result<HashSet<Url>, Box<dyn Error>> {
self.get_item_ids_sync()
}
async fn get_items(&self) -> Result<HashMap<ItemId, &Item>, Box<dyn Error>> {
async fn get_items(&self) -> Result<HashMap<Url, &Item>, Box<dyn Error>> {
self.get_items_sync()
}
async fn get_item_by_id<'a>(&'a self, id: &ItemId) -> Option<&'a Item> {
async fn get_item_by_id<'a>(&'a self, id: &Url) -> Option<&'a Item> {
self.get_item_by_id_sync(id)
}
async fn get_item_by_id_mut<'a>(&'a mut self, id: &ItemId) -> Option<&'a mut Item> {
async fn get_item_by_id_mut<'a>(&'a mut self, id: &Url) -> Option<&'a mut Item> {
self.get_item_by_id_mut_sync(id)
}
async fn mark_for_deletion(&mut self, item_id: &ItemId) -> Result<(), Box<dyn Error>> {
async fn mark_for_deletion(&mut self, item_id: &Url) -> Result<(), Box<dyn Error>> {
self.mark_for_deletion_sync(item_id)
}
async fn immediately_delete_item(&mut self, item_id: &ItemId) -> Result<(), Box<dyn Error>> {
async fn immediately_delete_item(&mut self, item_id: &Url) -> Result<(), Box<dyn Error>> {
self.immediately_delete_item_sync(item_id)
}
}
@ -286,7 +286,7 @@ impl DavCalendar for CachedCalendar {
crate::traits::CompleteCalendar::new(name, resource.url().clone(), supported_components, color)
}
async fn get_item_version_tags(&self) -> Result<HashMap<ItemId, VersionTag>, Box<dyn Error>> {
async fn get_item_version_tags(&self) -> Result<HashMap<Url, VersionTag>, Box<dyn Error>> {
#[cfg(feature = "local_calendar_mocks_remote_calendars")]
self.mock_behaviour.as_ref().map_or(Ok(()), |b| b.lock().unwrap().can_get_item_version_tags())?;
@ -307,14 +307,14 @@ impl DavCalendar for CachedCalendar {
Ok(result)
}
async fn get_item_by_id(&self, id: &ItemId) -> Result<Option<Item>, Box<dyn Error>> {
async fn get_item_by_id(&self, id: &Url) -> Result<Option<Item>, Box<dyn Error>> {
#[cfg(feature = "local_calendar_mocks_remote_calendars")]
self.mock_behaviour.as_ref().map_or(Ok(()), |b| b.lock().unwrap().can_get_item_by_id())?;
Ok(self.items.get(id).cloned())
}
async fn delete_item(&mut self, item_id: &ItemId) -> Result<(), Box<dyn Error>> {
async fn delete_item(&mut self, item_id: &Url) -> Result<(), Box<dyn Error>> {
#[cfg(feature = "local_calendar_mocks_remote_calendars")]
self.mock_behaviour.as_ref().map_or(Ok(()), |b| b.lock().unwrap().can_delete_item())?;

29
src/calendar/remote_calendar.rs
View file

@ -5,13 +5,12 @@ use std::sync::Mutex;
use async_trait::async_trait;
use reqwest::{header::CONTENT_TYPE, header::CONTENT_LENGTH};
use csscolorparser::Color;
use url::Url;
use crate::traits::BaseCalendar;
use crate::traits::DavCalendar;
use crate::calendar::SupportedComponents;
use crate::calendar::CalendarId;
use crate::item::Item;
use crate::item::ItemId;
use crate::item::VersionTag;
use crate::item::SyncStatus;
use crate::resource::Resource;
@ -40,13 +39,13 @@ pub struct RemoteCalendar {
supported_components: SupportedComponents,
color: Option<Color>,
cached_version_tags: Mutex<Option<HashMap<ItemId, VersionTag>>>,
cached_version_tags: Mutex<Option<HashMap<Url, VersionTag>>>,
}
#[async_trait]
impl BaseCalendar for RemoteCalendar {
fn name(&self) -> &str { &self.name }
fn id(&self) -> &CalendarId { &self.resource.url() }
fn url(&self) -> &Url { &self.resource.url() }
fn supported_components(&self) -> crate::calendar::SupportedComponents {
self.supported_components
}
@ -58,7 +57,7 @@ impl BaseCalendar for RemoteCalendar {
let ical_text = crate::ical::build_from(&item)?;
let response = reqwest::Client::new()
.put(item.id().as_url().clone())
.put(item.url().clone())
.header("If-None-Match", "*")
.header(CONTENT_TYPE, "text/calendar")
.header(CONTENT_LENGTH, ical_text.len())
@ -73,7 +72,7 @@ impl BaseCalendar for RemoteCalendar {
let reply_hdrs = response.headers();
match reply_hdrs.get("ETag") {
None => Err(format!("No ETag in these response headers: {:?} (request was {:?})", reply_hdrs, item.id()).into()),
None => Err(format!("No ETag in these response headers: {:?} (request was {:?})", reply_hdrs, item.url()).into()),
Some(etag) => {
let vtag_str = etag.to_str()?;
let vtag = VersionTag::from(String::from(vtag_str));
@ -92,7 +91,7 @@ impl BaseCalendar for RemoteCalendar {
let ical_text = crate::ical::build_from(&item)?;
let request = reqwest::Client::new()
.put(item.id().as_url().clone())
.put(item.url().clone())
.header("If-Match", old_etag.as_str())
.header(CONTENT_TYPE, "text/calendar")
.header(CONTENT_LENGTH, ical_text.len())
@ -107,7 +106,7 @@ impl BaseCalendar for RemoteCalendar {
let reply_hdrs = request.headers();
match reply_hdrs.get("ETag") {
None => Err(format!("No ETag in these response headers: {:?} (request was {:?})", reply_hdrs, item.id()).into()),
None => Err(format!("No ETag in these response headers: {:?} (request was {:?})", reply_hdrs, item.url()).into()),
Some(etag) => {
let vtag_str = etag.to_str()?;
let vtag = VersionTag::from(String::from(vtag_str));
@ -127,7 +126,7 @@ impl DavCalendar for RemoteCalendar {
}
async fn get_item_version_tags(&self) -> Result<HashMap<ItemId, VersionTag>, Box<dyn Error>> {
async fn get_item_version_tags(&self) -> Result<HashMap<Url, VersionTag>, Box<dyn Error>> {
if let Some(map) = &*self.cached_version_tags.lock().unwrap() {
log::debug!("Version tags are already cached.");
return Ok(map.clone());
@ -145,7 +144,7 @@ impl DavCalendar for RemoteCalendar {
continue;
},
Some(resource) => {
ItemId::from(&resource)
resource.url().clone()
},
};
@ -159,7 +158,7 @@ impl DavCalendar for RemoteCalendar {
}
};
items.insert(item_id, version_tag);
items.insert(item_id.clone(), version_tag);
}
// Note: the mutex cannot be locked during this whole async function, but it can safely be re-entrant (this will just waste an unnecessary request)
@ -167,9 +166,9 @@ impl DavCalendar for RemoteCalendar {
Ok(items)
}
async fn get_item_by_id(&self, id: &ItemId) -> Result<Option<Item>, Box<dyn Error>> {
async fn get_item_by_id(&self, id: &Url) -> Result<Option<Item>, Box<dyn Error>> {
let res = reqwest::Client::new()
.get(id.as_url().clone())
.get(id.clone())
.header(CONTENT_TYPE, "text/calendar")
.basic_auth(self.resource.username(), Some(self.resource.password()))
.send()
@ -192,9 +191,9 @@ impl DavCalendar for RemoteCalendar {
Ok(Some(item))
}
async fn delete_item(&mut self, item_id: &ItemId) -> Result<(), Box<dyn Error>> {
async fn delete_item(&mut self, item_id: &Url) -> Result<(), Box<dyn Error>> {
let del_response = reqwest::Client::new()
.delete(item_id.as_url().clone())
.delete(item_id.clone())
.basic_auth(self.resource.username(), Some(self.resource.password()))
.send()
.await?;

2
src/client.rs
View file

@ -216,7 +216,7 @@ impl Client {
let this_calendar = RemoteCalendar::new(display_name, this_calendar_url, supported_components, this_calendar_color);
log::info!("Found calendar {}", this_calendar.name());
calendars.insert(this_calendar.id().clone(), Arc::new(Mutex::new(this_calendar)));
calendars.insert(this_calendar.url().clone(), Arc::new(Mutex::new(this_calendar)));
}
let mut replies = self.cached_replies.lock().unwrap();

10
src/event.rs
View file

@ -2,15 +2,15 @@
use serde::{Deserialize, Serialize};
use chrono::{DateTime, Utc};
use url::Url;
use crate::item::ItemId;
use crate::item::SyncStatus;
/// TODO: implement `Event` one day.
/// This crate currently only supports tasks, not calendar events.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Event {
id: ItemId,
uid: String,
name: String,
sync_status: SyncStatus,
}
@ -20,12 +20,12 @@ impl Event {
unimplemented!();
}
pub fn id(&self) -> &ItemId {
&self.id
pub fn url(&self) -> &Url {
unimplemented!();
}
pub fn uid(&self) -> &str {
unimplemented!()
&self.uid
}
pub fn name(&self) -> &str {

34
src/ical/parser.rs
View file

@ -4,22 +4,22 @@ use std::error::Error;
use ical::parser::ical::component::{IcalCalendar, IcalEvent, IcalTodo};
use chrono::{DateTime, TimeZone, Utc};
use url::Url;
use crate::Item;
use crate::item::SyncStatus;
use crate::item::ItemId;
use crate::Task;
use crate::task::CompletionStatus;
use crate::Event;
/// Parse an iCal file into the internal representation [`crate::Item`]
pub fn parse(content: &str, item_id: ItemId, sync_status: SyncStatus) -> Result<Item, Box<dyn Error>> {
pub fn parse(content: &str, item_url: Url, sync_status: SyncStatus) -> Result<Item, Box<dyn Error>> {
let mut reader = ical::IcalParser::new(content.as_bytes());
let parsed_item = match reader.next() {
None => return Err(format!("Invalid iCal data to parse for item {}", item_id).into()),
None => return Err(format!("Invalid iCal data to parse for item {}", item_url).into()),
Some(item) => match item {
Err(err) => return Err(format!("Unable to parse iCal data for item {}: {}", item_id, err).into()),
Err(err) => return Err(format!("Unable to parse iCal data for item {}: {}", item_url, err).into()),
Ok(item) => item,
}
};
@ -80,15 +80,15 @@ pub fn parse(content: &str, item_id: ItemId, sync_status: SyncStatus) -> Result<
}
let name = match name {
Some(name) => name,
None => return Err(format!("Missing name for item {}", item_id).into()),
None => return Err(format!("Missing name for item {}", item_url).into()),
};
let uid = match uid {
Some(uid) => uid,
None => return Err(format!("Missing UID for item {}", item_id).into()),
None => return Err(format!("Missing UID for item {}", item_url).into()),
};
let last_modified = match last_modified {
Some(dt) => dt,
None => return Err(format!("Missing DTSTAMP for item {}, but this is required by RFC5545", item_id).into()),
None => return Err(format!("Missing DTSTAMP for item {}, but this is required by RFC5545", item_url).into()),
};
let completion_status = match completed {
false => {
@ -100,7 +100,7 @@ pub fn parse(content: &str, item_id: ItemId, sync_status: SyncStatus) -> Result<
true => CompletionStatus::Completed(completion_date),
};
Item::Task(Task::new_with_parameters(name, uid, item_id, completion_status, sync_status, creation_date, last_modified, ical_prod_id, extra_parameters))
Item::Task(Task::new_with_parameters(name, uid, item_url, completion_status, sync_status, creation_date, last_modified, ical_prod_id, extra_parameters))
},
};
@ -244,13 +244,13 @@ END:VCALENDAR
fn test_ical_parsing() {
let version_tag = VersionTag::from(String::from("test-tag"));
let sync_status = SyncStatus::Synced(version_tag);
let item_id: ItemId = "http://some.id/for/testing".parse().unwrap();
let item_url: Url = "http://some.id/for/testing".parse().unwrap();
let item = parse(EXAMPLE_ICAL, item_id.clone(), sync_status.clone()).unwrap();
let item = parse(EXAMPLE_ICAL, item_url.clone(), sync_status.clone()).unwrap();
let task = item.unwrap_task();
assert_eq!(task.name(), "Do not forget to do this");
assert_eq!(task.id(), &item_id);
assert_eq!(task.url(), &item_url);
assert_eq!(task.uid(), "0633de27-8c32-42be-bcb8-63bc879c6185@some-domain.com");
assert_eq!(task.completed(), false);
assert_eq!(task.completion_status(), &CompletionStatus::Uncompleted);
@ -262,9 +262,9 @@ END:VCALENDAR
fn test_completed_ical_parsing() {
let version_tag = VersionTag::from(String::from("test-tag"));
let sync_status = SyncStatus::Synced(version_tag);
let item_id: ItemId = "http://some.id/for/testing".parse().unwrap();
let item_url: Url = "http://some.id/for/testing".parse().unwrap();
let item = parse(EXAMPLE_ICAL_COMPLETED, item_id.clone(), sync_status.clone()).unwrap();
let item = parse(EXAMPLE_ICAL_COMPLETED, item_url.clone(), sync_status.clone()).unwrap();
let task = item.unwrap_task();
assert_eq!(task.completed(), true);
@ -275,9 +275,9 @@ END:VCALENDAR
fn test_completed_without_date_ical_parsing() {
let version_tag = VersionTag::from(String::from("test-tag"));
let sync_status = SyncStatus::Synced(version_tag);
let item_id: ItemId = "http://some.id/for/testing".parse().unwrap();
let item_url: Url = "http://some.id/for/testing".parse().unwrap();
let item = parse(EXAMPLE_ICAL_COMPLETED_WITHOUT_A_COMPLETION_DATE, item_id.clone(), sync_status.clone()).unwrap();
let item = parse(EXAMPLE_ICAL_COMPLETED_WITHOUT_A_COMPLETION_DATE, item_url.clone(), sync_status.clone()).unwrap();
let task = item.unwrap_task();
assert_eq!(task.completed(), true);
@ -288,9 +288,9 @@ END:VCALENDAR
fn test_multiple_items_in_ical() {
let version_tag = VersionTag::from(String::from("test-tag"));
let sync_status = SyncStatus::Synced(version_tag);
let item_id: ItemId = "http://some.id/for/testing".parse().unwrap();
let item_url: Url = "http://some.id/for/testing".parse().unwrap();
let item = parse(EXAMPLE_MULTIPLE_ICAL, item_id.clone(), sync_status.clone());
let item = parse(EXAMPLE_MULTIPLE_ICAL, item_url.clone(), sync_status.clone());
assert!(item.is_err());
}
}

72
src/item.rs
View file

@ -1,17 +1,10 @@
//! CalDAV items (todo, events, journals...)
// TODO: move Event and Task to nest them in crate::items::calendar::Calendar?
use std::fmt::{Display, Formatter};
use std::str::FromStr;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::{Deserialize, Serialize};
use url::Url;
use chrono::{DateTime, Utc};
use crate::resource::Resource;
use crate::calendar::CalendarId;
#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum Item {
@ -32,7 +25,7 @@ macro_rules! synthetise_common_getter {
}
impl Item {
synthetise_common_getter!(id, &ItemId);
synthetise_common_getter!(url, &Url);
synthetise_common_getter!(uid, &str);
synthetise_common_getter!(name, &str);
synthetise_common_getter!(creation_date, Option<&DateTime<Utc>>);
@ -94,67 +87,6 @@ impl Item {
}
#[derive(Clone, Debug, PartialEq, Hash)]
pub struct ItemId {
content: Url,
}
impl ItemId{
/// Generate a random ItemId.
pub fn random(parent_calendar: &CalendarId) -> Self {
let random = uuid::Uuid::new_v4().to_hyphenated().to_string();
let u = parent_calendar.join(&random).unwrap(/* this cannot panic since we've just created a string that is a valid URL */);
Self { content:u }
}
pub fn as_url(&self) -> &Url {
&self.content
}
}
impl From<Url> for ItemId {
fn from(url: Url) -> Self {
Self { content: url }
}
}
impl From<&Resource> for ItemId {
fn from(resource: &Resource) -> Self {
Self { content: resource.url().clone() }
}
}
impl FromStr for ItemId {
type Err = url::ParseError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let u: Url = s.parse()?;
Ok(Self::from(u))
}
}
impl Eq for ItemId {}
impl Display for ItemId {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
write!(f, "{}", self.content)
}
}
/// Used to support serde
impl Serialize for ItemId {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(self.content.as_str())
}
}
/// Used to support serde
impl<'de> Deserialize<'de> for ItemId {
fn deserialize<D>(deserializer: D) -> Result<ItemId, D::Error>
where
D: Deserializer<'de>,
{
let u = Url::deserialize(deserializer)?;
Ok(ItemId{ content: u })
}
}
/// A VersionTag is basically a CalDAV `ctag` or `etag`. Whenever it changes, this means the data has changed.

5
src/provider/mod.rs
View file

@ -6,10 +6,11 @@ use std::error::Error;
use std::collections::HashSet;
use std::marker::PhantomData;
use std::sync::{Arc, Mutex};
use url::Url;
use crate::traits::{BaseCalendar, CalDavSource, DavCalendar};
use crate::traits::CompleteCalendar;
use crate::item::{ItemId, SyncStatus};
use crate::item::SyncStatus;
use crate::calendar::CalendarId;
pub mod sync_progress;
@ -400,7 +401,7 @@ where
}
async fn item_name(cal: &T, id: &ItemId) -> String {
async fn item_name(cal: &T, id: &Url) -> String {
cal.get_item_by_id(id).await.map(|item| item.name()).unwrap_or_default().to_string()
}

23
src/task.rs
View file

@ -4,10 +4,11 @@ use serde::{Deserialize, Serialize};
use uuid::Uuid;
use chrono::{DateTime, Utc};
use ical::property::Property;
use url::Url;
use crate::item::ItemId;
use crate::item::SyncStatus;
use crate::calendar::CalendarId;
use crate::utils::random_url;
/// RFC5545 defines the completion as several optional fields, yet some combinations make no sense.
/// This enum provides an API that forbids such impossible combinations.
@ -33,10 +34,11 @@ impl CompletionStatus {
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Task {
/// The task URL
id: ItemId,
url: Url,
/// Persistent, globally unique identifier for the calendar component
/// The [RFC](https://tools.ietf.org/html/rfc5545#page-117) recommends concatenating a timestamp with the server's domain name, but UUID are even better
/// The [RFC](https://tools.ietf.org/html/rfc5545#page-117) recommends concatenating a timestamp with the server's domain name.
/// UUID are even better so we'll generate them, but we have to support tasks from the server, that may have any arbitrary strings here.
uid: String,
/// The sync status of this item
@ -65,8 +67,8 @@ pub struct Task {
impl Task {
/// Create a brand new Task that is not on a server yet.
/// This will pick a new (random) task ID.
pub fn new(name: String, completed: bool, parent_calendar_id: &CalendarId) -> Self {
let new_item_id = ItemId::random(parent_calendar_id);
pub fn new(name: String, completed: bool, parent_calendar_url: &CalendarId) -> Self {
let new_url = random_url(parent_calendar_url);
let new_sync_status = SyncStatus::NotSynced;
let new_uid = Uuid::new_v4().to_hyphenated().to_string();
let new_creation_date = Some(Utc::now());
@ -76,18 +78,18 @@ impl Task {
} else { CompletionStatus::Uncompleted };
let ical_prod_id = crate::ical::default_prod_id();
let extra_parameters = Vec::new();
Self::new_with_parameters(name, new_uid, new_item_id, new_completion_status, new_sync_status, new_creation_date, new_last_modified, ical_prod_id, extra_parameters)
Self::new_with_parameters(name, new_uid, new_url, new_completion_status, new_sync_status, new_creation_date, new_last_modified, ical_prod_id, extra_parameters)
}
/// Create a new Task instance, that may be synced on the server already
pub fn new_with_parameters(name: String, uid: String, id: ItemId,
pub fn new_with_parameters(name: String, uid: String, new_url: Url,
completion_status: CompletionStatus,
sync_status: SyncStatus, creation_date: Option<DateTime<Utc>>, last_modified: DateTime<Utc>,
ical_prod_id: String, extra_parameters: Vec<Property>,
) -> Self
{
Self {
id,
url: new_url,
uid,
name,
completion_status,
@ -99,7 +101,7 @@ impl Task {
}
}
pub fn id(&self) -> &ItemId { &self.id }
pub fn url(&self) -> &Url { &self.url }
pub fn uid(&self) -> &str { &self.uid }
pub fn name(&self) -> &str { &self.name }
pub fn completed(&self) -> bool { self.completion_status.is_completed() }
@ -112,7 +114,8 @@ impl Task {
#[cfg(any(test, feature = "integration_tests"))]
pub fn has_same_observable_content_as(&self, other: &Task) -> bool {
self.id == other.id
self.url == other.url
&& self.uid == other.uid
&& self.name == other.name
// sync status must be the same variant, but we ignore its embedded version tag
&& std::mem::discriminant(&self.sync_status) == std::mem::discriminant(&other.sync_status)

26
src/traits.rs
View file

@ -6,10 +6,10 @@ use std::sync::{Arc, Mutex};
use async_trait::async_trait;
use csscolorparser::Color;
use url::Url;
use crate::item::SyncStatus;
use crate::item::Item;
use crate::item::ItemId;
use crate::item::VersionTag;
use crate::calendar::CalendarId;
use crate::calendar::SupportedComponents;
@ -40,8 +40,8 @@ pub trait BaseCalendar {
/// Returns the calendar name
fn name(&self) -> &str;
/// Returns the calendar unique ID
fn id(&self) -> &CalendarId;
/// Returns the calendar URL
fn url(&self) -> &Url;
/// Returns the supported kinds of components for this calendar
fn supported_components(&self) -> crate::calendar::SupportedComponents;
@ -79,16 +79,16 @@ pub trait DavCalendar : BaseCalendar {
fn new(name: String, resource: Resource, supported_components: SupportedComponents, color: Option<Color>) -> Self;
/// Get the IDs and the version tags of every item in this calendar
async fn get_item_version_tags(&self) -> Result<HashMap<ItemId, VersionTag>, Box<dyn Error>>;
async fn get_item_version_tags(&self) -> Result<HashMap<Url, VersionTag>, Box<dyn Error>>;
/// Returns a particular item
async fn get_item_by_id(&self, id: &ItemId) -> Result<Option<Item>, Box<dyn Error>>;
async fn get_item_by_id(&self, id: &Url) -> Result<Option<Item>, Box<dyn Error>>;
/// Delete an item
async fn delete_item(&mut self, item_id: &ItemId) -> Result<(), Box<dyn Error>>;
async fn delete_item(&mut self, item_id: &Url) -> Result<(), Box<dyn Error>>;
/// Get the IDs of all current items in this calendar
async fn get_item_ids(&self) -> Result<HashSet<ItemId>, Box<dyn Error>> {
async fn get_item_ids(&self) -> Result<HashSet<Url>, Box<dyn Error>> {
let items = self.get_item_version_tags().await?;
Ok(items.iter()
.map(|(id, _tag)| id.clone())
@ -111,22 +111,22 @@ pub trait CompleteCalendar : BaseCalendar {
fn new(name: String, id: CalendarId, supported_components: SupportedComponents, color: Option<Color>) -> Self;
/// Get the IDs of all current items in this calendar
async fn get_item_ids(&self) -> Result<HashSet<ItemId>, Box<dyn Error>>;
async fn get_item_ids(&self) -> Result<HashSet<Url>, Box<dyn Error>>;
/// Returns all items that this calendar contains
async fn get_items(&self) -> Result<HashMap<ItemId, &Item>, Box<dyn Error>>;
async fn get_items(&self) -> Result<HashMap<Url, &Item>, Box<dyn Error>>;
/// Returns a particular item
async fn get_item_by_id<'a>(&'a self, id: &ItemId) -> Option<&'a Item>;
async fn get_item_by_id<'a>(&'a self, id: &Url) -> Option<&'a Item>;
/// Returns a particular item
async fn get_item_by_id_mut<'a>(&'a mut self, id: &ItemId) -> Option<&'a mut Item>;
async fn get_item_by_id_mut<'a>(&'a mut self, id: &Url) -> Option<&'a mut Item>;
/// Mark an item for deletion.
/// This is required so that the upcoming sync will know it should also also delete this task from the server
/// (and then call [`CompleteCalendar::immediately_delete_item`] once it has been successfully deleted on the server)
async fn mark_for_deletion(&mut self, item_id: &ItemId) -> Result<(), Box<dyn Error>>;
async fn mark_for_deletion(&mut self, item_id: &Url) -> Result<(), Box<dyn Error>>;
/// Immediately remove an item. See [`CompleteCalendar::mark_for_deletion`]
async fn immediately_delete_item(&mut self, item_id: &ItemId) -> Result<(), Box<dyn Error>>;
async fn immediately_delete_item(&mut self, item_id: &Url) -> Result<(), Box<dyn Error>>;
}

10
src/utils/mod.rs
View file

@ -6,6 +6,7 @@ use std::hash::Hash;
use std::io::{stdin, stdout, Read, Write};
use minidom::Element;
use url::Url;
use crate::traits::CompleteCalendar;
use crate::traits::DavCalendar;
@ -107,7 +108,7 @@ pub fn print_task(item: &Item) {
SyncStatus::LocallyModified(_) => "~",
SyncStatus::LocallyDeleted(_) => "x",
};
println!(" {}{} {}\t{}", completion, sync, task.name(), task.id());
println!(" {}{} {}\t{}", completion, sync, task.name(), task.url());
},
_ => return,
}
@ -148,3 +149,10 @@ pub fn pause() {
stdout.flush().unwrap();
stdin().read_exact(&mut [0]).unwrap();
}
/// Generate a random URL with a given prefix
pub fn random_url(parent_calendar: &Url) -> Url {
let random = uuid::Uuid::new_v4().to_hyphenated().to_string();
parent_calendar.join(&random).unwrap(/* this cannot panic since we've just created a string that is a valid URL */)
}