From 52554af4f12d9cb8b46793dbccbcf2451a5995da Mon Sep 17 00:00:00 2001
From: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Wed, 24 Jul 2024 13:18:54 +0100
Subject: [PATCH] cli: add `rad unblock` command

Add the `rad unblock` command for reversing the effect of blocking an NID or RID.

In both cases, the entry is removed from the DB, if the policy was set to block
-- otherwise it is a no-op.
---
 radicle-cli/examples/rad-block.md   | 12 ++++
 radicle-cli/src/commands.rs         |  2 +
 radicle-cli/src/commands/help.rs    |  1 +
 radicle-cli/src/commands/unblock.rs | 98 +++++++++++++++++++++++++++++
 radicle-cli/src/main.rs             |  7 +++
 radicle/src/node/policy.rs          |  6 +-
 radicle/src/node/policy/store.rs    | 24 +++++++
 7 files changed, 149 insertions(+), 1 deletion(-)
 create mode 100644 radicle-cli/src/commands/unblock.rs

diff --git a/radicle-cli/examples/rad-block.md b/radicle-cli/examples/rad-block.md
index 267229c7..41335027 100644
--- a/radicle-cli/examples/rad-block.md
+++ b/radicle-cli/examples/rad-block.md
@@ -41,3 +41,15 @@ $ rad seed
 │ rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji          block    all   │
 ╰───────────────────────────────────────────────────────────╯
 ```
+
+If we want to reverse the blocking of the RID we can use `rad unblock`:
+
+```
+$ rad unblock rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji
+✓ The 'block' policy for rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji is removed
+```
+
+```
+$ rad seed
+No seeding policies to show.
+```
diff --git a/radicle-cli/src/commands.rs b/radicle-cli/src/commands.rs
index 6808f7ff..e4df12c1 100644
--- a/radicle-cli/src/commands.rs
+++ b/radicle-cli/src/commands.rs
@@ -52,6 +52,8 @@ pub mod rad_self;
 pub mod rad_stats;
 #[path = "commands/sync.rs"]
 pub mod rad_sync;
+#[path = "commands/unblock.rs"]
+pub mod rad_unblock;
 #[path = "commands/unfollow.rs"]
 pub mod rad_unfollow;
 #[path = "commands/unseed.rs"]
diff --git a/radicle-cli/src/commands/help.rs b/radicle-cli/src/commands/help.rs
index 6027dd85..79ba11bf 100644
--- a/radicle-cli/src/commands/help.rs
+++ b/radicle-cli/src/commands/help.rs
@@ -33,6 +33,7 @@ const COMMANDS: &[Help] = &[
     rad_self::HELP,
     rad_seed::HELP,
     rad_follow::HELP,
+    rad_unblock::HELP,
     rad_unfollow::HELP,
     rad_unseed::HELP,
     rad_remote::HELP,
diff --git a/radicle-cli/src/commands/unblock.rs b/radicle-cli/src/commands/unblock.rs
new file mode 100644
index 00000000..6a144c3f
--- /dev/null
+++ b/radicle-cli/src/commands/unblock.rs
@@ -0,0 +1,98 @@
+use std::ffi::OsString;
+
+use radicle::prelude::{NodeId, RepoId};
+
+use crate::terminal as term;
+use crate::terminal::args;
+use crate::terminal::args::{Args, Error, Help};
+
+pub const HELP: Help = Help {
+    name: "unblock",
+    description: "Unblock repositories or nodes to allow them to be seeded or followed",
+    version: env!("RADICLE_VERSION"),
+    usage: r#"
+Usage
+
+    rad unblock <rid> [<option>...]
+    rad unblock <nid> [<option>...]
+
+    Unblock a repository or remote to allow it to be seeded or followed.
+
+Options
+
+    --help          Print help
+"#,
+};
+
+enum Target {
+    Node(NodeId),
+    Repo(RepoId),
+}
+
+impl std::fmt::Display for Target {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Node(nid) => nid.fmt(f),
+            Self::Repo(rid) => rid.fmt(f),
+        }
+    }
+}
+
+pub struct Options {
+    target: Target,
+}
+
+impl Args for Options {
+    fn from_args(args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)> {
+        use lexopt::prelude::*;
+
+        let mut parser = lexopt::Parser::from_args(args);
+        let mut target = None;
+
+        while let Some(arg) = parser.next()? {
+            match arg {
+                Long("help") | Short('h') => {
+                    return Err(Error::Help.into());
+                }
+                Value(val) if target.is_none() => {
+                    if let Ok(rid) = args::rid(&val) {
+                        target = Some(Target::Repo(rid));
+                    } else if let Ok(nid) = args::nid(&val) {
+                        target = Some(Target::Node(nid));
+                    } else {
+                        return Err(anyhow::anyhow!(
+                            "invalid repository or remote specified, see `rad unblock --help`"
+                        ));
+                    }
+                }
+                _ => return Err(anyhow::anyhow!(arg.unexpected())),
+            }
+        }
+
+        Ok((
+            Options {
+                target: target.ok_or(anyhow::anyhow!(
+                    "a repository or remote to unblock must be specified, see `rad unblock --help`"
+                ))?,
+            },
+            vec![],
+        ))
+    }
+}
+
+pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {
+    let profile = ctx.profile()?;
+    let mut policies = profile.policies_mut()?;
+
+    let updated = match options.target {
+        Target::Node(nid) => policies.unblock_nid(&nid)?,
+        Target::Repo(rid) => policies.unblock_rid(&rid)?,
+    };
+
+    if updated {
+        term::success!("The 'block' policy for {} is removed", options.target);
+    } else {
+        term::info!("No 'block' policy exists for {}", options.target)
+    }
+    Ok(())
+}
diff --git a/radicle-cli/src/main.rs b/radicle-cli/src/main.rs
index 1a143863..3b397227 100644
--- a/radicle-cli/src/main.rs
+++ b/radicle-cli/src/main.rs
@@ -291,6 +291,13 @@ fn run_other(exe: &str, args: &[OsString]) -> Result<(), Option<anyhow::Error>>
                 args.to_vec(),
             );
         }
+        "unblock" => {
+            term::run_command_args::<rad_unblock::Options, _>(
+                rad_unblock::HELP,
+                rad_unblock::run,
+                args.to_vec(),
+            );
+        }
         "unfollow" => {
             term::run_command_args::<rad_unfollow::Options, _>(
                 rad_unfollow::HELP,
diff --git a/radicle/src/node/policy.rs b/radicle/src/node/policy.rs
index cd97ce05..8a128816 100644
--- a/radicle/src/node/policy.rs
+++ b/radicle/src/node/policy.rs
@@ -139,11 +139,15 @@ impl TryFrom<&sqlite::Value> for Policy {
     type Error = sqlite::Error;
 
     fn try_from(value: &sqlite::Value) -> Result<Self, Self::Error> {
-        let message = Some("sql: invalid policy".to_owned());
+        let message = Some("sql: invalid policy value".to_owned());
 
         match value {
             sqlite::Value::String(s) if s == "allow" => Ok(Policy::Allow),
             sqlite::Value::String(s) if s == "block" => Ok(Policy::Block),
+            sqlite::Value::String(s) => Err(sqlite::Error {
+                code: None,
+                message: Some(format!("sql: invalid policy '{s}'")),
+            }),
             _ => Err(sqlite::Error {
                 code: None,
                 message,
diff --git a/radicle/src/node/policy/store.rs b/radicle/src/node/policy/store.rs
index 76352d3a..4ef9f78e 100644
--- a/radicle/src/node/policy/store.rs
+++ b/radicle/src/node/policy/store.rs
@@ -198,6 +198,30 @@ impl Store<Write> {
 
         Ok(self.db.change_count() > 0)
     }
+
+    /// Unblock a repository.
+    pub fn unblock_rid(&mut self, id: &RepoId) -> Result<bool, Error> {
+        let mut stmt = self
+            .db
+            .prepare("DELETE FROM `seeding` WHERE id = ? AND policy = 'block'")?;
+
+        stmt.bind((1, id))?;
+        stmt.next()?;
+
+        Ok(self.db.change_count() > 0)
+    }
+
+    /// Unblock a remote.
+    pub fn unblock_nid(&mut self, id: &NodeId) -> Result<bool, Error> {
+        let mut stmt = self
+            .db
+            .prepare("DELETE FROM `following` WHERE id = ? AND policy = 'block'")?;
+
+        stmt.bind((1, id))?;
+        stmt.next()?;
+
+        Ok(self.db.change_count() > 0)
+    }
 }
 
 /// `Read` methods for `Config`. This implies that a