Notification Panel (#200)

* feat: add tauri nspanel * feat: add notification panel * feat: move notification service to backend * feat: add sync notification job * feat: enable panel to join all spaces including fullscreen (#203) * feat: fetch notification * feat: listen for new notification * feat: finish panel --------- Co-authored-by: Victor Aremu <me@victorare.mu>
2024-06-06 14:32:30 +07:00
parent 4e7da4108b
commit 799835a629
25 changed files with 1006 additions and 977 deletions
--- a/src-tauri/src/nostr/event.rs
+++ b/src-tauri/src/nostr/event.rs
@@ -122,11 +122,11 @@ pub async fn get_local_events(
  let filter = Filter::new()
    .kinds(vec![Kind::TextNote, Kind::Repost])
    .limit(20)
-    .authors(authors)
-    .until(as_of);
+    .until(as_of)
+    .authors(authors);

  match client
-    .get_events_of(vec![filter], Some(Duration::from_secs(8)))
+    .get_events_of(vec![filter], Some(Duration::from_secs(10)))
    .await
  {
    Ok(events) => Ok(events.into_iter().map(|ev| ev.as_json()).collect()),
--- a/src-tauri/src/nostr/keys.rs
+++ b/src-tauri/src/nostr/keys.rs
@@ -6,7 +6,8 @@ use serde::Serialize;
 use specta::Type;
 use std::str::FromStr;
 use std::time::Duration;
-use tauri::{Manager, State};
+use tauri::{EventTarget, Manager, State};
+use tauri_plugin_notification::NotificationExt;

 #[derive(Serialize, Type)]
 pub struct Account {
@@ -106,6 +107,7 @@ pub async fn load_account(
  state: State<'_, Nostr>,
  app: tauri::AppHandle,
 ) -> Result<bool, String> {
+  let handle = app.clone();
  let client = &state.client;
  let keyring = Entry::new(npub, "nostr_secret").unwrap();

@@ -167,7 +169,7 @@ pub async fn load_account(

          // Add relay to relay pool
          let _ = client
-            .add_relay_with_opts(relay_url.clone(), opts)
+            .add_relay_with_opts(&relay_url, opts)
            .await
            .unwrap_or_default();

@@ -177,20 +179,51 @@ pub async fn load_account(
      }
    };

+    // Run sync service
+    tauri::async_runtime::spawn(async move {
+      let window = handle.get_window("main").unwrap();
+      let state = window.state::<Nostr>();
+      let client = &state.client;
+
+      let filter = Filter::new()
+        .pubkey(public_key)
+        .kinds(vec![
+          Kind::TextNote,
+          Kind::Repost,
+          Kind::Reaction,
+          Kind::ZapReceipt,
+        ])
+        .limit(500);
+
+      match client.reconcile(filter, NegentropyOptions::default()).await {
+        Ok(_) => println!("Sync notification done."),
+        Err(_) => println!("Sync notification failed."),
+      }
+    });
+
    // Run notification service
    tauri::async_runtime::spawn(async move {
+      println!("Starting notification service...");
+
      let window = app.get_window("main").unwrap();
      let state = window.state::<Nostr>();
      let client = &state.client;
-      let subscription = Filter::new()
-        .pubkey(public_key)
-        .kinds(vec![Kind::TextNote, Kind::Repost, Kind::ZapReceipt])
-        .since(Timestamp::now());
-      let activity_id = SubscriptionId::new("activity");

-      // Create a subscription for activity
+      // Create a subscription for notification
+      let notification_id = SubscriptionId::new("notification");
+      let filter = Filter::new()
+        .pubkey(public_key)
+        .kinds(vec![
+          Kind::TextNote,
+          Kind::Repost,
+          Kind::Reaction,
+          Kind::ZapReceipt,
+        ])
+        .since(Timestamp::now());
+
+      // Subscribe
      client
-        .subscribe_with_id(activity_id.clone(), vec![subscription], None)
+        .subscribe_with_id(notification_id.clone(), vec![filter], None)
        .await;

      // Handle notifications
@@ -202,8 +235,68 @@ pub async fn load_account(
            ..
          } = notification
          {
-            if subscription_id == activity_id {
-              let _ = app.emit("activity", event.as_json());
+            if subscription_id == notification_id {
+              println!("new notification: {}", event.as_json());
+
+              if let Err(_) = app.emit_to(
+                EventTarget::window("panel"),
+                "notification",
+                event.as_json(),
+              ) {
+                println!("Emit new notification failed.")
+              }
+
+              let handle = app.app_handle();
+              let author = client.metadata(event.pubkey).await.unwrap();
+
+              match event.kind() {
+                Kind::TextNote => {
+                  if let Err(e) = handle
+                    .notification()
+                    .builder()
+                    .body("Mentioned you in a thread.")
+                    .title(author.display_name.unwrap_or_else(|| "Lume".to_string()))
+                    .show()
+                  {
+                    println!("Failed to show notification: {:?}", e);
+                  }
+                }
+                Kind::Repost => {
+                  if let Err(e) = handle
+                    .notification()
+                    .builder()
+                    .body("Reposted your note.")
+                    .title(author.display_name.unwrap_or_else(|| "Lume".to_string()))
+                    .show()
+                  {
+                    println!("Failed to show notification: {:?}", e);
+                  }
+                }
+                Kind::Reaction => {
+                  let content = event.content();
+                  if let Err(e) = handle
+                    .notification()
+                    .builder()
+                    .body(content)
+                    .title(author.display_name.unwrap_or_else(|| "Lume".to_string()))
+                    .show()
+                  {
+                    println!("Failed to show notification: {:?}", e);
+                  }
+                }
+                Kind::ZapReceipt => {
+                  if let Err(e) = handle
+                    .notification()
+                    .builder()
+                    .body("Zapped you.")
+                    .title(author.display_name.unwrap_or_else(|| "Lume".to_string()))
+                    .show()
+                  {
+                    println!("Failed to show notification: {:?}", e);
+                  }
+                }
+                _ => {}
+              }
            }
          }
          Ok(false)
--- a/src-tauri/src/nostr/metadata.rs
+++ b/src-tauri/src/nostr/metadata.rs
@@ -6,73 +6,6 @@ use std::{str::FromStr, time::Duration};
 use tauri::State;
 use url::Url;

-#[tauri::command]
-#[specta::specta]
-pub async fn get_activities(
-  account: &str,
-  kind: &str,
-  state: State<'_, Nostr>,
-) -> Result<Vec<String>, String> {
-  let client = &state.client;
-
-  if let Ok(pubkey) = PublicKey::from_str(account) {
-    if let Ok(kind) = Kind::from_str(kind) {
-      let filter = Filter::new()
-        .pubkey(pubkey)
-        .kind(kind)
-        .limit(100)
-        .until(Timestamp::now());
-
-      match client.get_events_of(vec![filter], None).await {
-        Ok(events) => Ok(events.into_iter().map(|ev| ev.as_json()).collect()),
-        Err(err) => Err(err.to_string()),
-      }
-    } else {
-      Err("Kind is not valid, please check again.".into())
-    }
-  } else {
-    Err("Public Key is not valid, please check again.".into())
-  }
-}
-
-#[tauri::command]
-#[specta::specta]
-pub async fn friend_to_friend(npub: &str, state: State<'_, Nostr>) -> Result<bool, String> {
-  let client = &state.client;
-
-  match PublicKey::from_bech32(npub) {
-    Ok(author) => {
-      let mut contact_list: Vec<Contact> = Vec::new();
-      let contact_list_filter = Filter::new()
-        .author(author)
-        .kind(Kind::ContactList)
-        .limit(1);
-
-      if let Ok(contact_list_events) = client.get_events_of(vec![contact_list_filter], None).await {
-        for event in contact_list_events.into_iter() {
-          for tag in event.into_iter_tags() {
-            if let Some(TagStandard::PublicKey {
-              public_key,
-              relay_url,
-              alias,
-              uppercase: false,
-            }) = tag.to_standardized()
-            {
-              contact_list.push(Contact::new(public_key, relay_url, alias))
-            }
-          }
-        }
-      }
-
-      match client.set_contact_list(contact_list).await {
-        Ok(_) => Ok(true),
-        Err(err) => Err(err.to_string()),
-      }
-    }
-    Err(err) => Err(err.to_string()),
-  }
-}
-
 #[tauri::command]
 #[specta::specta]
 pub async fn get_current_user_profile(state: State<'_, Nostr>) -> Result<String, String> {
@@ -468,6 +401,42 @@ pub async fn zap_event(

 #[tauri::command]
 #[specta::specta]
+pub async fn friend_to_friend(npub: &str, state: State<'_, Nostr>) -> Result<bool, String> {
+  let client = &state.client;
+
+  match PublicKey::from_bech32(npub) {
+    Ok(author) => {
+      let mut contact_list: Vec<Contact> = Vec::new();
+      let contact_list_filter = Filter::new()
+        .author(author)
+        .kind(Kind::ContactList)
+        .limit(1);
+
+      if let Ok(contact_list_events) = client.get_events_of(vec![contact_list_filter], None).await {
+        for event in contact_list_events.into_iter() {
+          for tag in event.into_iter_tags() {
+            if let Some(TagStandard::PublicKey {
+              public_key,
+              relay_url,
+              alias,
+              uppercase: false,
+            }) = tag.to_standardized()
+            {
+              contact_list.push(Contact::new(public_key, relay_url, alias))
+            }
+          }
+        }
+      }
+
+      match client.set_contact_list(contact_list).await {
+        Ok(_) => Ok(true),
+        Err(err) => Err(err.to_string()),
+      }
+    }
+    Err(err) => Err(err.to_string()),
+  }
+}
+
 pub async fn get_following(
  state: State<'_, Nostr>,
  public_key: &str,
@@ -500,8 +469,6 @@ pub async fn get_following(
  Ok(ret)
 }

-#[tauri::command]
-#[specta::specta]
 pub async fn get_followers(
  state: State<'_, Nostr>,
  public_key: &str,
@@ -529,3 +496,34 @@ pub async fn get_followers(
  Ok(ret)
  //todo: get more than 500 events
 }
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_notifications(state: State<'_, Nostr>) -> Result<Vec<String>, String> {
+  let client = &state.client;
+
+  match client.signer().await {
+    Ok(signer) => {
+      let public_key = signer.public_key().await.unwrap();
+      let filter = Filter::new()
+        .pubkey(public_key)
+        .kinds(vec![
+          Kind::TextNote,
+          Kind::Repost,
+          Kind::Reaction,
+          Kind::ZapReceipt,
+        ])
+        .limit(200);
+
+      match client
+        .database()
+        .query(vec![filter], Order::default())
+        .await
+      {
+        Ok(events) => Ok(events.into_iter().map(|ev| ev.as_json()).collect()),
+        Err(err) => Err(err.to_string()),
+      }
+    }
+    Err(err) => Err(err.to_string()),
+  }
+}