httpd: Add missing COB actions

Handles missing issue and patch actions. Adds embeds to patch comments.

Signed-off-by: Sebastian Martinez <me@sebastinez.dev>

radicle-cli/src/commands/patch/comment.rs

@@ -27,7 +27,7 @@ pub fn run(
         .ok_or_else(|| anyhow!("Patch revision `{revision_id}` not found"))?;
     let mut patch = patch::PatchMut::new(patch_id, patch, &mut patches);
     let (body, reply_to) = prompt(message, reply_to, &revision, repo)?;
-    let comment_id = patch.comment(revision_id, body, reply_to, &signer)?;
+    let comment_id = patch.comment(revision_id, body, reply_to, None, vec![], &signer)?;
     let comment = patch
         .revision(&revision_id)
         .ok_or(anyhow!("error retrieving revision `{revision_id}`"))?

radicle-httpd/src/api/json.rs

@@ -247,6 +247,7 @@ struct Comment<'a> {
     #[serde(with = "radicle::serde_ext::localtime::time")]
     timestamp: Timestamp,
     reply_to: Option<CommentId>,
+    resolved: bool,
 }
 
 impl<'a> Comment<'a> {
@@ -260,6 +261,7 @@ impl<'a> Comment<'a> {
             reactions: comment.reactions().collect::<Vec<_>>(),
             timestamp: comment.timestamp(),
             reply_to: comment.reply_to(),
+            resolved: comment.resolved(),
         }
     }
 }

radicle-httpd/src/api/v1/projects.rs

@@ -732,11 +732,21 @@ async fn issue_update_handler(
         } => {
             issue.react(id, reaction, active, &signer)?;
         }
-        issue::Action::CommentEdit { .. } => {
+        issue::Action::CommentEdit { id, body, embeds } => {
-            todo!();
+            let embeds: Vec<Embed> = embeds
+                .into_iter()
+                .filter_map(|embed| {
+                    let content = TryInto::<DataUri>::try_into(&embed.content).ok()?;
+                    Some(Embed {
+                        name: embed.name,
+                        content: content.into(),
+                    })
+                })
+                .collect();
+            issue.edit_comment(id, body, embeds, &signer)?;
         }
-        issue::Action::CommentRedact { .. } => {
+        issue::Action::CommentRedact { id } => {
-            todo!();
+            issue.redact_comment(id, &signer)?;
         }
     };
 
@@ -824,11 +834,26 @@ async fn patch_update_handler(
         patch::Action::Edit { title, target } => {
             patch.edit(title, target, &signer)?;
         }
-        patch::Action::RevisionEdit {
+        patch::Action::Label { labels } => {
+            patch.label(labels, &signer)?;
+        }
+        patch::Action::Lifecycle { state } => {
+            patch.lifecycle(state, &signer)?;
+        }
+        patch::Action::Assign { assignees } => {
+            patch.assign(assignees, &signer)?;
+        }
+        patch::Action::Merge { revision, commit } => {
+            // TODO: We should cleanup the stored copy at least.
+            let _ = patch.merge(revision, commit, &signer)?;
+        }
+        patch::Action::Review {
             revision,
-            description,
+            summary,
+            verdict,
+            labels,
         } => {
-            patch.edit_revision(revision, description, &signer)?;
+            patch.review(revision, verdict, summary, labels, &signer)?;
         }
         patch::Action::ReviewEdit {
             review,
@@ -837,20 +862,45 @@ async fn patch_update_handler(
         } => {
             patch.edit_review(review, summary, verdict, &signer)?;
         }
+        patch::Action::ReviewRedact { review } => {
+            patch.redact_review(review, &signer)?;
+        }
         patch::Action::ReviewComment {
             review,
             body,
             reply_to,
-            ..
+            location,
+            embeds,
         } => {
-            patch.review_comment(review, body, None, reply_to, &signer)?;
+            let embeds: Vec<Embed> = embeds
+                .into_iter()
+                .filter_map(|embed| {
+                    let content = TryInto::<DataUri>::try_into(&embed.content).ok()?;
+                    Some(Embed {
+                        name: embed.name,
+                        content: content.into(),
+                    })
+                })
+                .collect();
+            patch.review_comment(review, body, location, reply_to, embeds, &signer)?;
         }
         patch::Action::ReviewCommentEdit {
             review,
             comment,
             body,
+            embeds,
         } => {
-            patch.edit_review_comment(review, comment, body, &signer)?;
+            let embeds: Vec<Embed> = embeds
+                .into_iter()
+                .filter_map(|embed| {
+                    let content = TryInto::<DataUri>::try_into(&embed.content).ok()?;
+                    Some(Embed {
+                        name: embed.name,
+                        content: content.into(),
+                    })
+                })
+                .collect();
+            patch.edit_review_comment(review, comment, body, embeds, &signer)?;
         }
         patch::Action::ReviewCommentReact {
             review,
@@ -863,8 +913,11 @@ async fn patch_update_handler(
         patch::Action::ReviewCommentRedact { review, comment } => {
             patch.redact_review_comment(review, comment, &signer)?;
         }
-        patch::Action::Label { labels } => {
+        patch::Action::ReviewCommentResolve { review, comment } => {
-            patch.label(labels, &signer)?;
+            patch.resolve_review_comment(review, comment, &signer)?;
+        }
+        patch::Action::ReviewCommentUnresolve { review, comment } => {
+            patch.unresolve_review_comment(review, comment, &signer)?;
         }
         patch::Action::Revision {
             description,
@@ -874,35 +927,51 @@ async fn patch_update_handler(
         } => {
             patch.update(description, base, oid, &signer)?;
         }
-        patch::Action::Lifecycle { state } => {
+        patch::Action::RevisionEdit {
-            patch.lifecycle(state, &signer)?;
-        }
-        patch::Action::Review {
             revision,
-            summary,
+            description,
-            verdict,
-            labels,
         } => {
-            patch.review(revision, verdict, summary, labels, &signer)?;
+            patch.edit_revision(revision, description, &signer)?;
         }
-        patch::Action::Merge { revision, commit } => {
+        patch::Action::RevisionRedact { revision } => {
-            // TODO: We should cleanup the stored copy at least.
+            patch.redact(revision, &signer)?;
-            let _ = patch.merge(revision, commit, &signer)?;
         }
         patch::Action::RevisionComment {
             revision,
             body,
             reply_to,
-            ..
+            location,
+            embeds,
         } => {
-            patch.comment(revision, body, reply_to, &signer)?;
+            let embeds: Vec<Embed> = embeds
+                .into_iter()
+                .filter_map(|embed| {
+                    let content = TryInto::<DataUri>::try_into(&embed.content).ok()?;
+                    Some(Embed {
+                        name: embed.name,
+                        content: content.into(),
+                    })
+                })
+                .collect();
+            patch.comment(revision, body, reply_to, location, embeds, &signer)?;
         }
         patch::Action::RevisionCommentEdit {
             revision,
             comment,
             body,
+            embeds,
         } => {
-            patch.comment_edit(revision, comment, body, &signer)?;
+            let embeds: Vec<Embed> = embeds
+                .into_iter()
+                .filter_map(|embed| {
+                    let content = TryInto::<DataUri>::try_into(&embed.content).ok()?;
+                    Some(Embed {
+                        name: embed.name,
+                        content: content.into(),
+                    })
+                })
+                .collect();
+            patch.comment_edit(revision, comment, body, embeds, &signer)?;
         }
         patch::Action::RevisionCommentReact {
             revision,
@@ -1937,7 +2006,8 @@ mod routes {
                     "embeds": [],
                     "reactions": [],
                     "timestamp": TIMESTAMP,
-                    "replyTo": null
+                    "replyTo": null,
+                    "resolved": false,
                   }
                 ],
                 "labels": []
@@ -2017,6 +2087,7 @@ mod routes {
                 "reactions": [],
                 "timestamp": TIMESTAMP,
                 "replyTo": null,
+                "resolved": false,
               }],
               "labels": [
                   "bug",
@@ -2059,7 +2130,7 @@ mod routes {
 
         let body = serde_json::to_vec(&json!({
           "type": "comment.react",
-          "id": "6fe9fdec2ec9f6436f2875dbcbedb95dd215b863",
+          "id": ISSUE_DISCUSSION_ID,
           "reaction": "🚀",
           "active": true,
         }))
@@ -2072,6 +2143,40 @@ mod routes {
         )
         .await;
 
+        let body = serde_json::to_vec(&json!({
+          "type": "comment.edit",
+          "id": ISSUE_DISCUSSION_ID,
+          "body": "EDIT: Change 'hello world' to 'hello anyone'",
+          "embeds": []
+        }))
+        .unwrap();
+
+        let response = patch(
+            &app,
+            format!("/projects/{CONTRIBUTOR_RID}/issues/{CONTRIBUTOR_ISSUE_ID}"),
+            Some(Body::from(body)),
+            Some(SESSION_ID.to_string()),
+        )
+        .await;
+
+        assert_eq!(response.json().await, json!({ "success": true }));
+
+        let body = serde_json::to_vec(&json!({
+          "type": "comment.redact",
+          "id": "6fe9fdec2ec9f6436f2875dbcbedb95dd215b863",
+        }))
+        .unwrap();
+
+        let response = patch(
+            &app,
+            format!("/projects/{CONTRIBUTOR_RID}/issues/{CONTRIBUTOR_ISSUE_ID}"),
+            Some(Body::from(body)),
+            Some(SESSION_ID.to_string()),
+        )
+        .await;
+
+        assert_eq!(response.json().await, json!({ "success": true }));
+
         let response = get(
             &app,
             format!("/projects/{CONTRIBUTOR_RID}/issues/{CONTRIBUTOR_ISSUE_ID}"),
@@ -2096,24 +2201,8 @@ mod routes {
                   "author": {
                     "id": CONTRIBUTOR_DID,
                   },
-                  "body": "Change 'hello world' to 'hello everyone'",
+                  "body": "EDIT: Change 'hello world' to 'hello anyone'",
                   "embeds": [],
-                  "reactions": [],
-                  "timestamp": TIMESTAMP,
-                  "replyTo": null,
-                },
-                {
-                  "id": "6fe9fdec2ec9f6436f2875dbcbedb95dd215b863",
-                  "author": {
-                    "id": CONTRIBUTOR_DID,
-                  },
-                  "body": "This is first-level comment",
-                  "embeds": [
-                    {
-                      "name": "image.jpg",
-                      "content": "git:94381b429d7f7fe87e1bade52d893ab348ae29cc",
-                    },
-                  ],
                   "reactions": [
                     [
                     "z6Mkk7oqY4pPxhMmGEotDYsFo97vhCj85BLY1H256HrJmjN8",
@@ -2121,7 +2210,8 @@ mod routes {
                     ],
                   ],
                   "timestamp": TIMESTAMP,
-                  "replyTo": CONTRIBUTOR_ISSUE_ID,
+                  "replyTo": null,
+                  "resolved": false,
                 },
               ],
               "labels": [],
@@ -2185,6 +2275,7 @@ mod routes {
                   "reactions": [],
                   "timestamp": TIMESTAMP,
                   "replyTo": null,
+                  "resolved": false,
                 },
                 {
                   "id": ISSUE_COMMENT_ID,
@@ -2196,6 +2287,7 @@ mod routes {
                   "reactions": [],
                   "timestamp": TIMESTAMP,
                   "replyTo": ISSUE_DISCUSSION_ID,
+                  "resolved": false,
                 },
               ],
               "labels": [],
@@ -2371,7 +2463,68 @@ mod routes {
     }
 
     #[tokio::test]
-    async fn test_projects_patches_tag() {
+    async fn test_projects_patches_assign() {
+        let tmp = tempfile::tempdir().unwrap();
+        let ctx = contributor(tmp.path());
+        let app = super::router(ctx.to_owned());
+        create_session(ctx).await;
+        let body = serde_json::to_vec(&json!({
+          "type": "assign",
+          "assignees": [CONTRIBUTOR_DID]
+        }))
+        .unwrap();
+        let response = patch(
+            &app,
+            format!("/projects/{CONTRIBUTOR_RID}/patches/{CONTRIBUTOR_PATCH_ID}"),
+            Some(Body::from(body)),
+            Some(SESSION_ID.to_string()),
+        )
+        .await;
+
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let response = get(
+            &app,
+            format!("/projects/{CONTRIBUTOR_RID}/patches/{CONTRIBUTOR_PATCH_ID}"),
+        )
+        .await;
+
+        assert_eq!(
+            response.json().await,
+            json!({
+              "id": CONTRIBUTOR_PATCH_ID,
+              "author": {
+                "id": CONTRIBUTOR_DID,
+              },
+              "title": "A new `hello world`",
+              "state": { "status": "open" },
+              "target": "delegates",
+              "labels": [],
+              "merges": [],
+              "assignees": [CONTRIBUTOR_DID],
+              "revisions": [
+                {
+                  "id": CONTRIBUTOR_PATCH_ID,
+                  "author": {
+                    "id": CONTRIBUTOR_DID,
+                  },
+                  "description": "change `hello world` in README to something else",
+                  "base": PARENT,
+                  "oid": HEAD,
+                  "refs": [
+                    "refs/heads/master",
+                  ],
+                  "discussions": [],
+                  "timestamp": TIMESTAMP,
+                  "reviews": [],
+                },
+              ],
+            })
+        );
+    }
+
+    #[tokio::test]
+    async fn test_projects_patches_label() {
         let tmp = tempfile::tempdir().unwrap();
         let ctx = contributor(tmp.path());
         let app = super::router(ctx.to_owned());
@@ -2575,6 +2728,68 @@ mod routes {
         );
     }
 
+    #[tokio::test]
+    async fn test_projects_patches_revisions_edit() {
+        let tmp = tempfile::tempdir().unwrap();
+        let ctx = contributor(tmp.path());
+        let app = super::router(ctx.to_owned());
+        create_session(ctx).await;
+        let body = serde_json::to_vec(&json!({
+          "type": "revision.edit",
+          "revision": CONTRIBUTOR_PATCH_ID,
+          "description": "Let's change the description a bit",
+        }))
+        .unwrap();
+        let response = patch(
+            &app,
+            format!("/projects/{CONTRIBUTOR_RID}/patches/{CONTRIBUTOR_PATCH_ID}"),
+            Some(Body::from(body)),
+            Some(SESSION_ID.to_string()),
+        )
+        .await;
+
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let response = get(
+            &app,
+            format!("/projects/{CONTRIBUTOR_RID}/patches/{CONTRIBUTOR_PATCH_ID}"),
+        )
+        .await;
+
+        assert_eq!(
+            response.json().await,
+            json!({
+              "id": CONTRIBUTOR_PATCH_ID,
+              "author": {
+                "id": CONTRIBUTOR_DID,
+              },
+              "title": "A new `hello world`",
+              "state": { "status": "open" },
+              "target": "delegates",
+              "labels": [],
+              "merges": [],
+              "assignees": [],
+              "revisions": [
+                {
+                  "id": CONTRIBUTOR_PATCH_ID,
+                  "author": {
+                    "id": CONTRIBUTOR_DID,
+                  },
+                  "description": "Let's change the description a bit",
+                  "base": PARENT,
+                  "oid": HEAD,
+                  "refs": [
+                    "refs/heads/master",
+                  ],
+                  "discussions": [],
+                  "timestamp": TIMESTAMP,
+                  "reviews": [],
+                },
+              ],
+            })
+        );
+    }
+
     #[tokio::test]
     async fn test_projects_patches_discussions() {
         let tmp = tempfile::tempdir().unwrap();
@@ -2584,7 +2799,13 @@ mod routes {
         let thread_body = serde_json::to_vec(&json!({
           "type": "revision.comment",
           "revision": CONTRIBUTOR_PATCH_ID,
-          "body": "This is a root level comment"
+          "body": "This is a root level comment",
+          "embeds": [
+            {
+              "name": "image.jpg",
+              "content": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4//8/AAX+Av4N70a4AAAAAElFTkSuQmCC"
+            }
+          ],
         }))
         .unwrap();
         let response = patch(
@@ -2616,7 +2837,13 @@ mod routes {
           "type": "revision.comment.edit",
           "revision": CONTRIBUTOR_PATCH_ID,
           "comment": CONTRIBUTOR_COMMENT_1,
-          "body": "EDIT: This is a root level comment"
+          "body": "EDIT: This is a root level comment",
+          "embeds": [
+            {
+              "name": "image.jpg",
+              "content": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4//8/AAX+Av4N70a4AAAAAElFTkSuQmCC"
+            }
+          ],
         }))
         .unwrap();
         let response = patch(
@@ -2633,6 +2860,7 @@ mod routes {
           "revision": CONTRIBUTOR_PATCH_ID,
           "body": "This is a root level comment",
           "replyTo": CONTRIBUTOR_COMMENT_1,
+          "embeds": [],
         }))
         .unwrap();
         let response = patch(
@@ -2683,10 +2911,16 @@ mod routes {
                         "id": CONTRIBUTOR_DID,
                       },
                       "body": "EDIT: This is a root level comment",
-                      "embeds": [],
+                      "embeds": [
+                        {
+                          "name": "image.jpg",
+                          "content": "git:94381b429d7f7fe87e1bade52d893ab348ae29cc",
+                        }
+                      ],
                       "reactions": [["z6Mkk7oqY4pPxhMmGEotDYsFo97vhCj85BLY1H256HrJmjN8","🚀"]],
                       "timestamp": TIMESTAMP,
                       "replyTo": null,
+                      "resolved": false,
                     },
                     {
                       "id": CONTRIBUTOR_COMMENT_2,
@@ -2698,6 +2932,7 @@ mod routes {
                       "reactions": [],
                       "timestamp": TIMESTAMP,
                       "replyTo": CONTRIBUTOR_COMMENT_1,
+                      "resolved": false,
                     },
                   ],
                   "timestamp": TIMESTAMP,
@@ -2734,7 +2969,18 @@ mod routes {
         let review_comment_body = serde_json::to_vec(&json!({
           "type": "review.comment",
           "review": CONTRIBUTOR_PATCH_REVIEW,
-          "body": "This is a comment on a review"
+          "body": "This is a comment on a review",
+          "embeds": [],
+          "location": {
+            "path": "README.md",
+            "new": {
+              "type": "lines",
+              "range": {
+                "start": 2,
+                "end": 4
+              }
+            }
+          }
         }))
         .unwrap();
         patch(
@@ -2749,7 +2995,8 @@ mod routes {
           "type": "review.comment.edit",
           "review": CONTRIBUTOR_PATCH_REVIEW,
           "comment": CONTRIBUTOR_COMMENT_3,
-          "body": "EDIT: This is a comment on a review"
+          "embeds": [],
+          "body": "EDIT: This is a comment on a review",
         }))
         .unwrap();
         patch(
@@ -2776,6 +3023,20 @@ mod routes {
         )
         .await;
 
+        let review_resolve_body = serde_json::to_vec(&json!({
+          "type": "review.comment.resolve",
+          "review": CONTRIBUTOR_PATCH_REVIEW,
+          "comment": CONTRIBUTOR_COMMENT_3,
+        }))
+        .unwrap();
+        patch(
+            &app,
+            format!("/projects/{CONTRIBUTOR_RID}/patches/{CONTRIBUTOR_PATCH_ID}"),
+            Some(Body::from(review_resolve_body)),
+            Some(SESSION_ID.to_string()),
+        )
+        .await;
+
         let response = get(
             &app,
             format!("/projects/{CONTRIBUTOR_RID}/patches/{CONTRIBUTOR_PATCH_ID}"),
@@ -2817,15 +3078,27 @@ mod routes {
                       "verdict": "accept",
                       "summary": "A small review",
                       "comments": [[
-                        "dd9743bb964ba22399548c86a3c1765020d58f48",
+                        CONTRIBUTOR_COMMENT_3,
                         {
-                          "author": "z6Mkk7oqY4pPxhMmGEotDYsFo97vhCj85BLY1H256HrJmjN8",
+                          "author": CONTRIBUTOR_NID,
+                          "location": {
+                            "path": "README.md",
+                            "old": null,
+                            "new": {
+                              "type": "lines",
+                              "range": {
+                                "start": 2,
+                                "end": 4,
+                              }
+                            }
+                          },
                           "reactions": [
                             [
                               "z6Mkk7oqY4pPxhMmGEotDYsFo97vhCj85BLY1H256HrJmjN8",
                               "🚀",
                             ],
                           ],
+                          "resolved": true,
                           "body": "EDIT: This is a comment on a review",
                         },
                       ]],

radicle-httpd/src/lib.rs

@@ -1,5 +1,6 @@
 #![allow(clippy::type_complexity)]
 #![allow(clippy::too_many_arguments)]
+#![recursion_limit = "256"]
 pub mod error;
 
 use std::collections::HashMap;

radicle-httpd/src/test.rs

@@ -45,9 +45,9 @@ pub const CONTRIBUTOR_NID: &str = "z6Mkk7oqY4pPxhMmGEotDYsFo97vhCj85BLY1H256HrJm
 pub const CONTRIBUTOR_ISSUE_ID: &str = "7466975f0bef37b459887824a9655f3e78262522";
 pub const CONTRIBUTOR_PATCH_ID: &str = "e651ae5869a2c1ac8ad4f6deae4cc835656ffa25";
 pub const CONTRIBUTOR_PATCH_REVIEW: &str = "ee3eeba95f4ec418b3d0714e18e0d1ff605dc0e6";
-pub const CONTRIBUTOR_COMMENT_1: &str = "d0bb75b2c72ab8b5486d39f6cf5f41f104b63cb1";
+pub const CONTRIBUTOR_COMMENT_1: &str = "d8ff07edbc8d2229e54e70f2f5bc31614287f0dc";
-pub const CONTRIBUTOR_COMMENT_2: &str = "227947fa41420e363752357b2edd54d3ccadf7b3";
+pub const CONTRIBUTOR_COMMENT_2: &str = "f3fca0add53f85bc51a85198efed3273fe13b88e";
-pub const CONTRIBUTOR_COMMENT_3: &str = "dd9743bb964ba22399548c86a3c1765020d58f48";
+pub const CONTRIBUTOR_COMMENT_3: &str = "06990ff59faa12463f693dae7a98eb33d75afd2e";
 
 /// Create a new profile.
 pub fn profile(home: &Path, seed: [u8; 32]) -> radicle::Profile {

radicle/src/cob/issue.rs

@@ -563,6 +563,19 @@ where
         })
     }
 
+    /// Edit a comment.
+    pub fn edit_comment<G: Signer, S: ToString>(
+        &mut self,
+        id: CommentId,
+        body: S,
+        embeds: impl IntoIterator<Item = Embed>,
+        signer: &G,
+    ) -> Result<EntryId, Error> {
+        self.transaction("Edit comment", signer, |tx| {
+            tx.edit_comment(id, body, embeds.into_iter().collect())
+        })
+    }
+
     /// Redact a comment.
     pub fn redact_comment<G: Signer>(
         &mut self,

radicle/src/cob/patch.rs

@@ -19,7 +19,7 @@ use crate::cob::store::{Cob, CobAction};
 use crate::cob::thread;
 use crate::cob::thread::Thread;
 use crate::cob::thread::{Comment, CommentId, Reactions};
-use crate::cob::{op, store, ActorId, EntryId, ObjectId, TypeName};
+use crate::cob::{op, store, ActorId, Embed, EntryId, ObjectId, TypeName, Uri};
 use crate::crypto::{PublicKey, Signer};
 use crate::git;
 use crate::identity;
@@ -176,12 +176,16 @@ pub enum Action {
         /// Should be [`Some`] otherwise.
         #[serde(default, skip_serializing_if = "Option::is_none")]
         reply_to: Option<CommentId>,
+        /// Embeded content.
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        embeds: Vec<Embed<Uri>>,
     },
     #[serde(rename = "review.comment.edit")]
     ReviewCommentEdit {
         review: ReviewId,
         comment: EntryId,
         body: String,
+        embeds: Vec<Embed<Uri>>,
     },
     #[serde(rename = "review.comment.redact")]
     ReviewCommentRedact { review: ReviewId, comment: EntryId },
@@ -240,6 +244,9 @@ pub enum Action {
         /// Should be the root [`CommentId`] if it's a top-level comment.
         #[serde(default, skip_serializing_if = "Option::is_none")]
         reply_to: Option<CommentId>,
+        /// Embeded content.
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        embeds: Vec<Embed<Uri>>,
     },
     /// Edit a revision comment.
     #[serde(rename = "revision.comment.edit")]
@@ -247,6 +254,7 @@ pub enum Action {
         revision: RevisionId,
         comment: CommentId,
         body: String,
+        embeds: Vec<Embed<Uri>>,
     },
     /// Redact a revision comment.
     #[serde(rename = "revision.comment.redact")]
@@ -856,6 +864,7 @@ impl Patch {
                 review,
                 comment,
                 body,
+                embeds,
             } => {
                 if let Some(review) = lookup::review_mut(self, &review)? {
                     thread::edit(
@@ -864,7 +873,7 @@ impl Patch {
                         comment,
                         timestamp,
                         body,
-                        vec![],
+                        embeds,
                     )?;
                 }
             }
@@ -883,6 +892,7 @@ impl Patch {
                 body,
                 location,
                 reply_to,
+                embeds,
             } => {
                 if let Some(review) = lookup::review_mut(self, &review)? {
                     thread::comment(
@@ -893,7 +903,7 @@ impl Patch {
                         body,
                         reply_to,
                         location,
-                        vec![],
+                        embeds,
                     )?;
                 }
             }
@@ -1008,6 +1018,7 @@ impl Patch {
                 revision,
                 comment,
                 body,
+                embeds,
             } => {
                 if let Some(revision) = lookup::revision_mut(self, &revision)? {
                     thread::edit(
@@ -1016,7 +1027,7 @@ impl Patch {
                         comment,
                         timestamp,
                         body,
-                        vec![],
+                        embeds,
                     )?;
                 }
             }
@@ -1554,6 +1565,7 @@ impl<R: ReadRepository> store::Transaction<Patch, R> {
             body: body.to_string(),
             reply_to: None,
             location: None,
+            embeds: vec![],
         })
     }
 
@@ -1563,12 +1575,18 @@ impl<R: ReadRepository> store::Transaction<Patch, R> {
         revision: RevisionId,
         body: S,
         reply_to: Option<CommentId>,
+        location: Option<CodeLocation>,
+        embeds: Vec<Embed>,
     ) -> Result<(), store::Error> {
+        let hashed = embeds.iter().map(|e| e.hashed()).collect();
+
+        self.embed(embeds)?;
         self.push(Action::RevisionComment {
             revision,
             body: body.to_string(),
             reply_to,
-            location: None,
+            location,
+            embeds: hashed,
         })
     }
 
@@ -1578,11 +1596,16 @@ impl<R: ReadRepository> store::Transaction<Patch, R> {
         revision: RevisionId,
         comment: CommentId,
         body: S,
+        embeds: Vec<Embed>,
     ) -> Result<(), store::Error> {
+        let hashed = embeds.iter().map(|e| e.hashed()).collect();
+
+        self.embed(embeds)?;
         self.push(Action::RevisionCommentEdit {
             revision,
             comment,
             body: body.to_string(),
+            embeds: hashed,
         })
     }
 
@@ -1618,26 +1641,54 @@ impl<R: ReadRepository> store::Transaction<Patch, R> {
         body: S,
         location: Option<CodeLocation>,
         reply_to: Option<CommentId>,
+        embeds: Vec<Embed>,
     ) -> Result<(), store::Error> {
+        let hashed = embeds.iter().map(|e| e.hashed()).collect();
+        self.embed(embeds)?;
+
         self.push(Action::ReviewComment {
             review,
             body: body.to_string(),
             location,
             reply_to,
+            embeds: hashed,
         })
     }
 
+    /// Resolve a review comment.
+    pub fn review_comment_resolve(
+        &mut self,
+        review: ReviewId,
+        comment: CommentId,
+    ) -> Result<(), store::Error> {
+        self.push(Action::ReviewCommentResolve { review, comment })
+    }
+
+    /// Unresolve a review comment.
+    pub fn review_comment_unresolve(
+        &mut self,
+        review: ReviewId,
+        comment: CommentId,
+    ) -> Result<(), store::Error> {
+        self.push(Action::ReviewCommentUnresolve { review, comment })
+    }
+
     /// Edit review comment.
     pub fn edit_review_comment<S: ToString>(
         &mut self,
         review: ReviewId,
         comment: EntryId,
         body: S,
+        embeds: Vec<Embed>,
     ) -> Result<(), store::Error> {
+        let hashed = embeds.iter().map(|e| e.hashed()).collect();
+
+        self.embed(embeds)?;
         self.push(Action::ReviewCommentEdit {
             review,
             comment,
             body: body.to_string(),
+            embeds: hashed,
         })
     }
 
@@ -1712,6 +1763,11 @@ impl<R: ReadRepository> store::Transaction<Patch, R> {
         self.push(Action::Lifecycle { state })
     }
 
+    /// Assign a patch.
+    pub fn assign(&mut self, assignees: BTreeSet<Did>) -> Result<(), store::Error> {
+        self.push(Action::Assign { assignees })
+    }
+
     /// Label a patch.
     pub fn label(&mut self, labels: impl IntoIterator<Item = Label>) -> Result<(), store::Error> {
         self.push(Action::Label {
@@ -1828,9 +1884,19 @@ where
         revision: RevisionId,
         body: S,
         reply_to: Option<CommentId>,
+        location: Option<CodeLocation>,
+        embeds: impl IntoIterator<Item = Embed>,
         signer: &G,
     ) -> Result<EntryId, Error> {
-        self.transaction("Comment", signer, |tx| tx.comment(revision, body, reply_to))
+        self.transaction("Comment", signer, |tx| {
+            tx.comment(
+                revision,
+                body,
+                reply_to,
+                location,
+                embeds.into_iter().collect(),
+            )
+        })
     }
 
     /// Edit a comment on a patch revision.
@@ -1839,10 +1905,11 @@ where
         revision: RevisionId,
         comment: CommentId,
         body: S,
+        embeds: impl IntoIterator<Item = Embed>,
         signer: &G,
     ) -> Result<EntryId, Error> {
         self.transaction("Edit comment", signer, |tx| {
-            tx.comment_edit(revision, comment, body)
+            tx.comment_edit(revision, comment, body, embeds.into_iter().collect())
         })
     }
 
@@ -1879,10 +1946,17 @@ where
         body: S,
         location: Option<CodeLocation>,
         reply_to: Option<CommentId>,
+        embeds: impl IntoIterator<Item = Embed>,
         signer: &G,
     ) -> Result<EntryId, Error> {
         self.transaction("Review comment", signer, |tx| {
-            tx.review_comment(review, body, location, reply_to)
+            tx.review_comment(
+                review,
+                body,
+                location,
+                reply_to,
+                embeds.into_iter().collect(),
+            )
         })
     }
 
@@ -1892,10 +1966,11 @@ where
         review: ReviewId,
         comment: EntryId,
         body: S,
+        embeds: impl IntoIterator<Item = Embed>,
         signer: &G,
     ) -> Result<EntryId, Error> {
         self.transaction("Edit review comment", signer, |tx| {
-            tx.edit_review_comment(review, comment, body)
+            tx.edit_review_comment(review, comment, body, embeds.into_iter().collect())
         })
     }
 
@@ -1949,6 +2024,30 @@ where
         self.transaction("Redact review", signer, |tx| tx.redact_review(review))
     }
 
+    /// Resolve a patch review comment.
+    pub fn resolve_review_comment<G: Signer>(
+        &mut self,
+        review: ReviewId,
+        comment: CommentId,
+        signer: &G,
+    ) -> Result<EntryId, Error> {
+        self.transaction("Resolve review comment", signer, |tx| {
+            tx.review_comment_resolve(review, comment)
+        })
+    }
+
+    /// Unresolve a patch review comment.
+    pub fn unresolve_review_comment<G: Signer>(
+        &mut self,
+        review: ReviewId,
+        comment: CommentId,
+        signer: &G,
+    ) -> Result<EntryId, Error> {
+        self.transaction("Unresolve review comment", signer, |tx| {
+            tx.review_comment_unresolve(review, comment)
+        })
+    }
+
     /// Merge a patch revision.
     pub fn merge<G: Signer>(
         &mut self,
@@ -1985,6 +2084,15 @@ where
         self.transaction("Lifecycle", signer, |tx| tx.lifecycle(state))
     }
 
+    /// Assign a patch.
+    pub fn assign<G: Signer>(
+        &mut self,
+        assignees: BTreeSet<Did>,
+        signer: &G,
+    ) -> Result<EntryId, Error> {
+        self.transaction("Assign", signer, |tx| tx.assign(assignees))
+    }
+
     /// Archive a patch.
     pub fn archive<G: Signer>(&mut self, signer: &G) -> Result<EntryId, Error> {
         self.lifecycle(Lifecycle::Archived, signer)
@@ -2223,6 +2331,7 @@ where
 #[allow(clippy::unwrap_used)]
 mod test {
     use std::str::FromStr;
+    use std::vec;
 
     use pretty_assertions::assert_eq;
 
@@ -2310,7 +2419,7 @@ mod test {
         let (revision_id, _) = patch.revisions().last().unwrap();
         assert!(
             patch
-                .comment(revision_id, "patch comment", None, &alice.signer)
+                .comment(revision_id, "patch comment", None, None, [], &alice.signer)
                 .is_ok(),
             "can comment on patch"
         );
@@ -2666,6 +2775,7 @@ mod test {
                 "I like these lines of code",
                 Some(location.clone()),
                 None,
+                [],
                 &alice.signer,
             )
             .unwrap();

radicle/src/cob/thread.rs

@@ -83,7 +83,7 @@ impl<T: Serialize> Serialize for Comment<T> {
     where
         S: serde::ser::Serializer,
     {
-        let mut state = serializer.serialize_struct("Comment", 6)?;
+        let mut state = serializer.serialize_struct("Comment", 8)?;
         state.serialize_field("author", &self.author())?;
         if let Some(loc) = &self.location {
             state.serialize_field("location", loc)?;
@@ -92,7 +92,11 @@ impl<T: Serialize> Serialize for Comment<T> {
             state.serialize_field("replyTo", &to)?;
         }
         state.serialize_field("reactions", &self.reactions)?;
+        state.serialize_field("resolved", &self.resolved)?;
         state.serialize_field("body", self.body())?;
+        if let Some(location) = self.location() {
+            state.serialize_field("location", &location)?;
+        }
 
         let embeds = self.embeds();
         if !embeds.is_empty() {
@@ -179,6 +183,11 @@ impl<L> Comment<L> {
         self.location.as_ref()
     }
 
+    /// Get comment resolution status.
+    pub fn resolved(&self) -> bool {
+        self.resolved
+    }
+
     /// Return the embedded media.
     pub fn embeds(&self) -> &[Embed<Uri>] {
         // SAFETY: There is always at least one edit. This is guaranteed by the [`Comment`]