AccountManagementView

View used to add and remove accounts from the app

Signed-off-by: kernelkind <[email protected]>
Signed-off-by: William Casarin <[email protected]>

Author: kernelkind

src/account_manager.rs

@@ -0,0 +1,107 @@
+use nostr_sdk::Keys;
+use nostrdb::{Ndb, Transaction};
+
+pub use crate::user_account::UserAccount;
+use crate::{
+    imgcache::ImageCache, key_storage::KeyStorage, relay_generation::RelayGenerator,
+    ui::profile::preview::SimpleProfilePreview,
+};
+
+pub struct SimpleProfilePreviewController<'a> {
+    ndb: &'a Ndb,
+    img_cache: &'a mut ImageCache,
+}
+
+impl<'a> SimpleProfilePreviewController<'a> {
+    pub fn new(ndb: &'a Ndb, img_cache: &'a mut ImageCache) -> Self {
+        SimpleProfilePreviewController { ndb, img_cache }
+    }
+
+    pub fn set_profile_previews(
+        &mut self,
+        account_manager: &AccountManager<'a>,
+        ui: &mut egui::Ui,
+        edit_mode: bool,
+        add_preview_ui: fn(
+            ui: &mut egui::Ui,
+            preview: SimpleProfilePreview,
+            edit_mode: bool,
+        ) -> bool,
+    ) -> Option<Vec<usize>> {
+        let mut to_remove: Option<Vec<usize>> = None;
+
+        for i in 0..account_manager.num_accounts() {
+            if let Some(account) = account_manager.get_account(i) {
+                if let Ok(txn) = Transaction::new(self.ndb) {
+                    let profile = self
+                        .ndb
+                        .get_profile_by_pubkey(&txn, &account.key.public_key().to_bytes());
+
+                    if let Ok(profile) = profile {
+                        let preview = SimpleProfilePreview::new(&profile, self.img_cache);
+
+                        if add_preview_ui(ui, preview, edit_mode) {
+                            if to_remove.is_none() {
+                                to_remove = Some(Vec::new());
+                            }
+                            to_remove.as_mut().unwrap().push(i);
+                        }
+                    };
+                }
+            }
+        }
+
+        to_remove
+    }
+}
+
+/// The interface for managing the user's accounts.
+/// Represents all user-facing operations related to account management.
+pub struct AccountManager<'a> {
+    accounts: &'a mut Vec<UserAccount>,
+    key_store: KeyStorage,
+    relay_generator: RelayGenerator,
+}
+
+impl<'a> AccountManager<'a> {
+    pub fn new(
+        accounts: &'a mut Vec<UserAccount>,
+        key_store: KeyStorage,
+        relay_generator: RelayGenerator,
+    ) -> Self {
+        AccountManager {
+            accounts,
+            key_store,
+            relay_generator,
+        }
+    }
+
+    pub fn get_accounts(&'a self) -> &'a Vec<UserAccount> {
+        self.accounts
+    }
+
+    pub fn get_account(&'a self, index: usize) -> Option<&'a UserAccount> {
+        self.accounts.get(index)
+    }
+
+    pub fn remove_account(&mut self, index: usize) {
+        if let Some(account) = self.accounts.get(index) {
+            self.key_store.remove_key(&account.key);
+        }
+        if index < self.accounts.len() {
+            self.accounts.remove(index);
+        }
+    }
+
+    pub fn add_account(&'a mut self, key: Keys, ctx: &egui::Context) {
+        self.key_store.add_key(&key);
+        let relays = self.relay_generator.generate_relays_for(&key, ctx);
+        let account = UserAccount { key, relays };
+
+        self.accounts.push(account)
+    }
+
+    pub fn num_accounts(&self) -> usize {
+        self.accounts.len()
+    }
+}

src/key_storage.rs

@@ -0,0 +1,48 @@
+use nostr_sdk::Keys;
+
+pub enum KeyStorage {
+    None,
+    // TODO:
+    // Linux,
+    // Windows,
+    // Android,
+}
+
+impl KeyStorage {
+    pub fn get_keys(&self) -> Result<Vec<Keys>, KeyStorageError> {
+        match self {
+            Self::None => Ok(Vec::new()),
+        }
+    }
+
+    pub fn add_key(&self, key: &Keys) -> Result<(), KeyStorageError> {
+        match self {
+            Self::None => Ok(()),
+        }
+    }
+
+    pub fn remove_key(&self, key: &Keys) -> Result<(), KeyStorageError> {
+        match self {
+            Self::None => Ok(()),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum KeyStorageError<'a> {
+    Retrieval,
+    Addition(&'a Keys),
+    Removal(&'a Keys),
+}
+
+impl std::fmt::Display for KeyStorageError<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::Retrieval => write!(f, "Failed to retrieve keys."),
+            Self::Addition(key) => write!(f, "Failed to add key: {:?}", key.public_key()),
+            Self::Removal(key) => write!(f, "Failed to remove key: {:?}", key.public_key()),
+        }
+    }
+}
+
+impl std::error::Error for KeyStorageError<'_> {}

src/lib.rs

@@ -4,6 +4,7 @@ mod error;
 //mod note;
 //mod block;
 mod abbrev;
+pub mod account_manager;
 pub mod app_creation;
 mod app_style;
 mod colors;
@@ -13,16 +14,19 @@ mod frame_history;
 mod images;
 mod imgcache;
 mod key_parsing;
+mod key_storage;
 pub mod login_manager;
 mod notecache;
 mod profile;
+mod relay_generation;
 pub mod relay_pool_manager;
 mod result;
 mod test_data;
 mod time;
 mod timecache;
 mod timeline;
 pub mod ui;
+mod user_account;
 
 #[cfg(test)]
 #[macro_use]

src/relay_generation.rs

@@ -0,0 +1,54 @@
+use crate::relay_pool_manager::create_wakeup;
+use enostr::RelayPool;
+use nostr_sdk::Keys;
+use tracing::error;
+
+pub enum RelayGenerator {
+    GossipModel,
+    Nip65,
+    Constant,
+}
+
+impl RelayGenerator {
+    pub fn generate_relays_for(&self, key: &Keys, ctx: &egui::Context) -> RelayPool {
+        match self {
+            Self::GossipModel => generate_relays_gossip(key, ctx),
+            Self::Nip65 => generate_relays_nip65(key, ctx),
+            Self::Constant => generate_constant_relays(ctx),
+        }
+    }
+}
+
+fn generate_relays_gossip(key: &Keys, ctx: &egui::Context) -> RelayPool {
+    todo!()
+}
+
+fn generate_relays_nip65(key: &Keys, ctx: &egui::Context) -> RelayPool {
+    todo!()
+}
+
+fn generate_constant_relays(ctx: &egui::Context) -> RelayPool {
+    let mut pool = RelayPool::new();
+    let wakeup = create_wakeup(ctx);
+
+    if let Err(e) = pool.add_url("ws://localhost:8080".to_string(), wakeup.clone()) {
+        error!("{:?}", e)
+    }
+    if let Err(e) = pool.add_url("wss://relay.damus.io".to_string(), wakeup.clone()) {
+        error!("{:?}", e)
+    }
+    if let Err(e) = pool.add_url("wss://pyramid.fiatjaf.com".to_string(), wakeup.clone()) {
+        error!("{:?}", e)
+    }
+    if let Err(e) = pool.add_url("wss://nos.lol".to_string(), wakeup.clone()) {
+        error!("{:?}", e)
+    }
+    if let Err(e) = pool.add_url("wss://nostr.wine".to_string(), wakeup.clone()) {
+        error!("{:?}", e)
+    }
+    if let Err(e) = pool.add_url("wss://purplepag.es".to_string(), wakeup) {
+        error!("{:?}", e)
+    }
+
+    pool
+}

src/relay_pool_manager.rs

@@ -46,7 +46,7 @@ impl<'a> RelayPoolManager<'a> {
     }
 }
 
-fn create_wakeup(ctx: &egui::Context) -> impl Fn() + Send + Sync + Clone + 'static {
+pub fn create_wakeup(ctx: &egui::Context) -> impl Fn() + Send + Sync + Clone + 'static {
     let ctx = ctx.clone();
     move || {
         ctx.request_repaint();