server/src/bin/server.rs

@@ -91,24 +91,23 @@ impl<'r, 'o: 'r> Responder<'r, 'o> for InlineAttachmentResponder {
     }
 }
 
-struct DownloadAttachmentResponder(Attachment);
+struct DownloadPartResponder {
+    bytes: Vec<u8>,
+    filename: Option<String>,
+}
 
-impl<'r, 'o: 'r> Responder<'r, 'o> for DownloadAttachmentResponder {
+impl<'r, 'o: 'r> Responder<'r, 'o> for DownloadPartResponder {
     fn respond_to(self, _: &'r Request<'_>) -> rocket::response::Result<'o> {
         let mut resp = Response::build();
-        if let Some(filename) = self.0.filename {
+        if let Some(filename) = self.filename {
             info!("filename {:?}", filename);
             resp.header(Header::new(
                 "Content-Disposition",
                 format!(r#"attachment; filename="{}""#, filename),
-            ));
+            ))
+            .header(ContentType::Binary);
         }
-        if let Some(content_type) = self.0.content_type {
-            if let Some(ct) = ContentType::parse_flexible(&content_type) {
-                resp.header(ct);
-            }
-        }
-        resp.sized_body(self.0.bytes.len(), Cursor::new(self.0.bytes))
+        resp.sized_body(self.bytes.len(), Cursor::new(self.bytes))
             .ok()
     }
 }
@@ -130,6 +129,7 @@ async fn view_attachment(
         .map(|s| s.parse().expect("not a usize"))
         .collect();
     let attachment = attachment_bytes(nm, &mid, &idx)?;
+    // TODO: plumb Content-Type, or just create wrappers for serving the Attachment type
     Ok(InlineAttachmentResponder(attachment))
 }
 
@@ -138,7 +138,7 @@ async fn download_attachment(
     nm: &State<Notmuch>,
     id: &str,
     idx: &str,
-) -> Result<DownloadAttachmentResponder, Debug<ServerError>> {
+) -> Result<DownloadPartResponder, Debug<ServerError>> {
     let mid = if id.starts_with("id:") {
         id.to_string()
     } else {
@@ -150,7 +150,30 @@ async fn download_attachment(
         .map(|s| s.parse().expect("not a usize"))
         .collect();
     let attachment = attachment_bytes(nm, &mid, &idx)?;
-    Ok(DownloadAttachmentResponder(attachment))
+    // TODO(wathiede): use walk_attachments from graphql to fill this out
+    Ok(DownloadPartResponder {
+        bytes: attachment.bytes,
+        filename: attachment.filename,
+    })
+}
+
+#[get("/original/<id>/part/<part>")]
+async fn original_part(
+    nm: &State<Notmuch>,
+    id: &str,
+    part: usize,
+) -> Result<DownloadPartResponder, Debug<NotmuchError>> {
+    let mid = if id.starts_with("id:") {
+        id.to_string()
+    } else {
+        format!("id:{}", id)
+    };
+    let meta = nm.show_part(&mid, part)?;
+    let res = nm.show_original_part(&mid, part)?;
+    Ok(DownloadPartResponder {
+        bytes: res,
+        filename: meta.filename,
+    })
 }
 
 #[get("/original/<id>")]
@@ -217,6 +240,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         .mount(
             "/",
             routes![
+                original_part,
                 original,
                 refresh,
                 search_all,

server/src/graphql.rs

@@ -86,10 +86,8 @@ pub struct Message {
 // X-Attachment-Id: f_lponoluo1
 #[derive(Default, Debug, SimpleObject)]
 pub struct Attachment {
-    pub id: String,
-    pub idx: String,
     pub filename: Option<String>,
-    pub size: usize,
+    pub size: Option<usize>,
     pub content_type: Option<String>,
     pub content_id: Option<String>,
     pub disposition: DispositionType,
@@ -377,7 +375,7 @@ impl QueryRoot {
                 })
                 .collect();
             // TODO(wathiede): parse message and fill out attachments
-            let attachments = extract_attachments(&m, &id)?;
+            let attachments = extract_attachments(&m)?;
             messages.push(Message {
                 id,
                 from,
@@ -658,17 +656,17 @@ fn walk_attachments<T, F: Fn(&ParsedMail, &[usize]) -> Option<T>>(
 // TODO(wathiede): make this walk_attachments that takes a closure.
 // Then implement one closure for building `Attachment` and imlement another that can be used to
 // get the bytes for serving attachments of HTTP
-fn extract_attachments(m: &ParsedMail, id: &str) -> Result<Vec<Attachment>, Error> {
+fn extract_attachments(m: &ParsedMail) -> Result<Vec<Attachment>, Error> {
     let mut attachments = Vec::new();
-    for (idx, sp) in m.subparts.iter().enumerate() {
-        if let Some(attachment) = extract_attachment(sp, id, &[idx]) {
+    for sp in &m.subparts {
+        if let Some(attachment) = extract_attachment(sp) {
             attachments.push(attachment);
         }
     }
     Ok(attachments)
 }
 
-fn extract_attachment(m: &ParsedMail, id: &str, idx: &[usize]) -> Option<Attachment> {
+fn extract_attachment(m: &ParsedMail) -> Option<Attachment> {
     let pcd = m.get_content_disposition();
     // TODO: do we need to handle empty filename attachments, or should we change the definition of
     // Attachment::filename?
@@ -686,15 +684,12 @@ fn extract_attachment(m: &ParsedMail, id: &str, idx: &[usize]) -> Option<Attachm
         }
     };
     return Some(Attachment {
-        id: id.to_string(),
-        idx: idx
-            .iter()
-            .map(|i| i.to_string())
-            .collect::<Vec<_>>()
-            .join("."),
         disposition: pcd.disposition.into(),
         filename: Some(filename),
-        size: bytes.len(),
+        size: pcd
+            .params
+            .get("size")
+            .map(|s| s.parse().unwrap_or_default()),
         // TODO: what is the default for ctype?
         // TODO: do we want to use m.ctype.params for anything?
         content_type: Some(m.ctype.mimetype.clone()),
@@ -846,7 +841,7 @@ pub fn attachment_bytes(nm: &Notmuch, id: &str, idx: &[usize]) -> Result<Attachm
     if let Some(attachment) = walk_attachments(&m, |sp, cur_idx| {
         info!("checking {cur_idx:?}=={idx:?}");
         if cur_idx == idx {
-            let attachment = extract_attachment(&sp, id, idx).unwrap_or(Attachment {
+            let attachment = extract_attachment(&sp).unwrap_or(Attachment {
                 ..Attachment::default()
             });
             return Some(attachment);

server/src/lib.rs

@@ -83,9 +83,8 @@ pub fn sanitize_html(html: &str) -> Result<String, SanitizeError> {
         }
     };
     // Default's don't allow style, but we want to preserve that.
-    let attributes = hashset![
-        "align", "bgcolor", "class", "color", "height", "lang", "title", "width", "style",
-    ];
+    let attributes =
+        hashset!["align", "bgcolor", "color", "height", "lang", "title", "width", "style",];
 
     let tags = hashset![
         "a",