1 files changed, 72 insertions, 70 deletions

diff --git a/src/imap/command/examined.rs b/src/imap/command/examined.rs
index 1740b39..7de94f4 100644
--- a/src/imap/command/examined.rs
+++ b/src/imap/command/examined.rs
@@ -1,56 +1,60 @@
 use std::sync::Arc;
 
 use anyhow::Result;
-use boitalettres::proto::Request;
-use boitalettres::proto::Response;
-use imap_codec::types::command::{CommandBody, SearchKey};
-use imap_codec::types::core::{Charset, NonZeroBytes};
-use imap_codec::types::datetime::MyDateTime;
-use imap_codec::types::fetch_attributes::MacroOrFetchAttributes;
-use imap_codec::types::flag::Flag;
-use imap_codec::types::mailbox::Mailbox as MailboxCodec;
-use imap_codec::types::response::Code;
-use imap_codec::types::sequence::SequenceSet;
+use imap_codec::imap_types::command::{Command, CommandBody};
+use imap_codec::imap_types::core::Charset;
+use imap_codec::imap_types::fetch::MacroOrMessageDataItemNames;
+use imap_codec::imap_types::search::SearchKey;
+use imap_codec::imap_types::sequence::SequenceSet;
 
-use crate::imap::command::authenticated;
+use crate::imap::command::{anystate, authenticated};
 use crate::imap::flow;
 use crate::imap::mailbox_view::MailboxView;
+use crate::imap::response::Response;
 use crate::mail::user::User;
 
 pub struct ExaminedContext<'a> {
-    pub req: &'a Request,
+    pub req: &'a Command<'static>,
     pub user: &'a Arc<User>,
     pub mailbox: &'a mut MailboxView,
 }
 
-pub async fn dispatch(ctx: ExaminedContext<'_>) -> Result<(Response, flow::Transition)> {
-    match &ctx.req.command.body {
-        // CLOSE in examined state is not the same as in selected state
-        // (in selected state it also does an EXPUNGE, here it doesn't)
+pub async fn dispatch(ctx: ExaminedContext<'_>) -> Result<(Response<'static>, flow::Transition)> {
+    match &ctx.req.body {
+        // Any State
+        // noop is specific to this state
+        CommandBody::Capability => anystate::capability(ctx.req.tag.clone()),
+        CommandBody::Logout => anystate::logout(),
+
+        // Specific to the EXAMINE state (specialization of the SELECTED state)
+        // ~3 commands -> close, fetch, search + NOOP
         CommandBody::Close => ctx.close().await,
         CommandBody::Fetch {
             sequence_set,
-            attributes,
+            macro_or_item_names,
             uid,
-        } => ctx.fetch(sequence_set, attributes, uid).await,
+        } => ctx.fetch(sequence_set, macro_or_item_names, uid).await,
         CommandBody::Search {
             charset,
             criteria,
             uid,
         } => ctx.search(charset, criteria, uid).await,
-        CommandBody::Noop => ctx.noop().await,
-        CommandBody::Append {
-            mailbox,
-            flags,
-            date,
-            message,
-        } => ctx.append(mailbox, flags, date, message).await,
+        CommandBody::Noop | CommandBody::Check => ctx.noop().await,
+        CommandBody::Expunge { .. } | CommandBody::Store { .. } => Ok((
+            Response::build()
+                .to_req(ctx.req)
+                .message("Forbidden command: can't write in read-only mode (EXAMINE)")
+                .bad()?,
+            flow::Transition::None,
+        )),
+
+        // In examined mode, we fallback to authenticated when needed
         _ => {
-            let ctx = authenticated::AuthenticatedContext {
+            authenticated::dispatch(authenticated::AuthenticatedContext {
                 req: ctx.req,
                 user: ctx.user,
-            };
-            authenticated::dispatch(ctx).await
+            })
+            .await
         }
     }
 }
@@ -58,71 +62,69 @@ pub async fn dispatch(ctx: ExaminedContext<'_>) -> Result<(Response, flow::Trans
 // --- PRIVATE ---
 
 impl<'a> ExaminedContext<'a> {
-    async fn close(self) -> Result<(Response, flow::Transition)> {
-        Ok((Response::ok("CLOSE completed")?, flow::Transition::Unselect))
+    /// CLOSE in examined state is not the same as in selected state
+    /// (in selected state it also does an EXPUNGE, here it doesn't)
+    async fn close(self) -> Result<(Response<'static>, flow::Transition)> {
+        Ok((
+            Response::build()
+                .to_req(self.req)
+                .message("CLOSE completed")
+                .ok()?,
+            flow::Transition::Unselect,
+        ))
     }
 
     pub async fn fetch(
         self,
         sequence_set: &SequenceSet,
-        attributes: &MacroOrFetchAttributes,
+        attributes: &'a MacroOrMessageDataItemNames<'static>,
         uid: &bool,
-    ) -> Result<(Response, flow::Transition)> {
+    ) -> Result<(Response<'static>, flow::Transition)> {
         match self.mailbox.fetch(sequence_set, attributes, uid).await {
             Ok(resp) => Ok((
-                Response::ok("FETCH completed")?.with_body(resp),
+                Response::build()
+                    .to_req(self.req)
+                    .message("FETCH completed")
+                    .set_body(resp)
+                    .ok()?,
+                flow::Transition::None,
+            )),
+            Err(e) => Ok((
+                Response::build()
+                    .to_req(self.req)
+                    .message(e.to_string())
+                    .no()?,
                 flow::Transition::None,
             )),
-            Err(e) => Ok((Response::no(&e.to_string())?, flow::Transition::None)),
         }
     }
 
     pub async fn search(
         self,
-        _charset: &Option<Charset>,
-        _criteria: &SearchKey,
+        _charset: &Option<Charset<'a>>,
+        _criteria: &SearchKey<'a>,
         _uid: &bool,
-    ) -> Result<(Response, flow::Transition)> {
-        Ok((Response::bad("Not implemented")?, flow::Transition::None))
+    ) -> Result<(Response<'static>, flow::Transition)> {
+        Ok((
+            Response::build()
+                .to_req(self.req)
+                .message("Not implemented")
+                .bad()?,
+            flow::Transition::None,
+        ))
     }
 
-    pub async fn noop(self) -> Result<(Response, flow::Transition)> {
+    pub async fn noop(self) -> Result<(Response<'static>, flow::Transition)> {
         self.mailbox.mailbox.force_sync().await?;
 
         let updates = self.mailbox.update().await?;
         Ok((
-            Response::ok("NOOP completed.")?.with_body(updates),
+            Response::build()
+                .to_req(self.req)
+                .message("NOOP completed.")
+                .set_body(updates)
+                .ok()?,
             flow::Transition::None,
         ))
     }
-
-    async fn append(
-        self,
-        mailbox: &MailboxCodec,
-        flags: &[Flag],
-        date: &Option<MyDateTime>,
-        message: &NonZeroBytes,
-    ) -> Result<(Response, flow::Transition)> {
-        let ctx2 = authenticated::AuthenticatedContext {
-            req: self.req,
-            user: self.user,
-        };
-
-        match ctx2.append_internal(mailbox, flags, date, message).await {
-            Ok((mb, uidvalidity, uid)) => {
-                let resp = Response::ok("APPEND completed")?.with_extra_code(Code::Other(
-                    "APPENDUID".try_into().unwrap(),
-                    Some(format!("{} {}", uidvalidity, uid)),
-                ));
-
-                if Arc::ptr_eq(&mb, &self.mailbox.mailbox) {
-                    let data = self.mailbox.update().await?;
-                    Ok((resp.with_body(data), flow::Transition::None))
-                } else {
-                    Ok((resp, flow::Transition::None))
-                }
-            }
-            Err(e) => Ok((Response::no(&e.to_string())?, flow::Transition::None)),
-        }
-    }
 }