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>

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()),
+  }
+}