1 files changed, 75 insertions, 4 deletions

diff --git a/aero-collections/src/calendar/mod.rs b/aero-collections/src/calendar/mod.rs
index 6537a4e..936f8c3 100644
--- a/aero-collections/src/calendar/mod.rs
+++ b/aero-collections/src/calendar/mod.rs
@@ -9,7 +9,7 @@ use aero_user::cryptoblob::{self, gen_key, open_deserialize, seal_serialize, Key
 use aero_user::storage::{self, BlobRef, BlobVal, RowRef, RowVal, Selector, Store};
 
 use crate::unique_ident::*;
-use crate::davdag::DavDag;
+use crate::davdag::{DavDag, IndexEntry, Token, BlobId, SyncChange};
 
 pub struct Calendar {
     pub(super) id: UniqueIdent,
@@ -20,8 +20,49 @@ impl Calendar {
     pub(crate) async fn open(
         creds: &Credentials,
         id: UniqueIdent,
-    ) -> Result<Self> {
-        todo!();
+        ) -> Result<Self> {
+        let bayou_path = format!("calendar/dag/{}", id);
+        let cal_path = format!("calendar/events/{}", id);
+
+        let mut davdag = Bayou::<DavDag>::new(creds, bayou_path).await?;
+        davdag.sync().await?;
+
+        let internal = RwLock::new(CalendarInternal {
+            id,
+            encryption_key: creds.keys.master.clone(),
+            storage: creds.storage.build().await?,
+            davdag,
+            cal_path,
+        });
+
+        Ok(Self { id, internal })
+    }
+
+    /// Sync data with backing store
+    pub async fn force_sync(&self) -> Result<()> {
+        self.internal.write().await.force_sync().await
+    }
+
+    /// Sync data with backing store only if changes are detected
+    /// or last sync is too old
+    pub async fn opportunistic_sync(&self) -> Result<()> {
+        self.internal.write().await.opportunistic_sync().await
+    }
+
+    pub async fn get(&self, blob_id: UniqueIdent, message_key: &Key) -> Result<Vec<u8>> {
+        self.internal.read().await.get(blob_id, message_key).await
+    }
+
+    pub async fn diff(&self, sync_token: Token) -> Result<(Token, Vec<SyncChange>)> {
+        self.internal.read().await.diff(sync_token).await
+    }
+
+    pub async fn put<'a>(&self, entry: IndexEntry, evt: &'a [u8]) -> Result<Token> {
+        self.internal.write().await.put(entry, evt).await
+    }
+
+    pub async fn delete(&self, blob_id: UniqueIdent) -> Result<Token> {
+        self.internal.write().await.delete(blob_id).await
     }
 }
 
@@ -30,5 +71,35 @@ struct CalendarInternal {
     cal_path: String,
     encryption_key: Key,
     storage: Store,
-    uid_index: Bayou<DavDag>,
+    davdag: Bayou<DavDag>,
+}
+
+impl CalendarInternal {
+    async fn force_sync(&mut self) -> Result<()> {
+        self.davdag.sync().await?;
+        Ok(())
+    }
+
+    async fn opportunistic_sync(&mut self) -> Result<()> {
+        self.davdag.opportunistic_sync().await?;
+        Ok(())
+    }
+
+    async fn get(&self, blob_id: BlobId, message_key: &Key) -> Result<Vec<u8>> {
+        todo!()
+    }
+
+    async fn put<'a>(&mut self, entry: IndexEntry, evt: &'a [u8]) -> Result<Token> {
+        //@TODO write event to S3
+        //@TODO add entry into Bayou
+        todo!();
+    }
+
+    async fn delete(&mut self, blob_id: BlobId) -> Result<Token> {
+        todo!();
+    }
+
+    async fn diff(&self, sync_token: Token) -> Result<(Token, Vec<SyncChange>)> {
+        todo!();
+    }
 }