use std::convert::TryFrom; use anyhow::Result; use k2v_client::K2vClient; use rusoto_s3::S3Client; use crate::bayou::Bayou; use crate::cryptoblob::Key; use crate::login::Credentials; use crate::mail::mail_ident::*; use crate::mail::uidindex::*; use crate::mail::IMF; pub struct Summary<'a> { pub validity: ImapUidvalidity, pub next: ImapUid, pub exists: u32, pub recent: u32, pub flags: FlagIter<'a>, pub unseen: Option<&'a ImapUid>, } impl std::fmt::Display for Summary<'_> { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { write!( f, "uidvalidity: {}, uidnext: {}, exists: {}", self.validity, self.next, self.exists ) } } // Non standard but common flags: // https://www.iana.org/assignments/imap-jmap-keywords/imap-jmap-keywords.xhtml pub struct Mailbox { bucket: String, pub name: String, key: Key, k2v: K2vClient, s3: S3Client, uid_index: Bayou, mail_path: String, } impl Mailbox { pub(super) fn new(creds: &Credentials, name: &str) -> Result { let index_path = format!("index/{}", name); let mail_path = format!("mail/{}", name); let uid_index = Bayou::::new(creds, index_path)?; Ok(Self { bucket: creds.bucket().to_string(), name: name.to_string(), // TODO: don't use name field if possible, use mail_path instead key: creds.keys.master.clone(), k2v: creds.k2v_client()?, s3: creds.s3_client()?, uid_index, mail_path, }) } /// Get a summary of the mailbox, useful for the SELECT command for example pub async fn summary(&mut self) -> Result { self.uid_index.sync().await?; let state = self.uid_index.state(); let unseen = state .idx_by_flag .get(&"$unseen".to_string()) .and_then(|os| os.get_min()); let recent = state .idx_by_flag .get(&"\\Recent".to_string()) .map(|os| os.len()) .unwrap_or(0); return Ok(Summary { validity: state.uidvalidity, next: state.uidnext, exists: u32::try_from(state.idx_by_uid.len())?, recent: u32::try_from(recent)?, flags: state.idx_by_flag.flags(), unseen, }); } /// Insert an email in the mailbox pub async fn append(&mut self, _msg: IMF) -> Result<()> { unimplemented!() } /// Copy an email from an other Mailbox to this mailbox /// (use this when possible, as it allows for a certain number of storage optimizations) pub async fn copy(&mut self, _from: &Mailbox, _uid: ImapUid) -> Result<()> { unimplemented!() } /// Delete all emails with the \Delete flag in the mailbox /// Can be called by CLOSE and EXPUNGE /// @FIXME do we want to implement this feature or a simpler "delete" command /// The controller could then "fetch \Delete" and call delete on each email? pub async fn expunge(&mut self) -> Result<()> { unimplemented!() } /// Update flags of a range of emails pub async fn store(&mut self) -> Result<()> { unimplemented!() } pub async fn fetch(&mut self) -> Result<()> { unimplemented!() } // ---- pub async fn test(&mut self) -> Result<()> { self.uid_index.sync().await?; dump(&self.uid_index); let add_mail_op = self .uid_index .state() .op_mail_add(gen_ident(), vec!["\\Unseen".into()]); self.uid_index.push(add_mail_op).await?; dump(&self.uid_index); if self.uid_index.state().idx_by_uid.len() > 6 { for i in 0..2 { let (_, ident) = self .uid_index .state() .idx_by_uid .iter() .skip(3 + i) .next() .unwrap(); let del_mail_op = self.uid_index.state().op_mail_del(*ident); self.uid_index.push(del_mail_op).await?; dump(&self.uid_index); } } Ok(()) } } fn dump(uid_index: &Bayou) { let s = uid_index.state(); println!("---- MAILBOX STATE ----"); println!("UIDVALIDITY {}", s.uidvalidity); println!("UIDNEXT {}", s.uidnext); println!("INTERNALSEQ {}", s.internalseq); for (uid, ident) in s.idx_by_uid.iter() { println!( "{} {} {}", uid, hex::encode(ident.0), s.table.get(ident).cloned().unwrap().1.join(", ") ); } println!(""); }