tyiu/notedeck
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge follow/unfollow from kernel

Browse Source 
Jakub Gladysz (1):
      ui: add follow button

kernelkind (14):
      bump nostrdb
      move polling responsibility to `AccountData`
      `AccountData`: decouple query from constructor
      add constructor for `AccountData`
      add `Contacts`
      use `Contacts` in `AccountData`
      expose `AccountSubs`
      Unify sub for contacts in accounts & timeline
      move `styled_button_toggleable` to notedeck_ui
      construct NoteBuilder from existing note
      send kind 3 event
      add actions for follow/unfollow
      add UI for (un)follow
      send contact list event on account creation
This commit is contained in:
William Casarin
2025-07-11 13:06:04 -07:00
parent 217c1e5223 dca9d3eeab
commit 96cb5e26ce
23 changed files with 684 additions and 252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.lock generated
View File

@@ -3267,8 +3267,8 @@ dependencies = [
[[package]]
name = "nostrdb"
version = "0.6.1"
source = "git+https://github.com/damus-io/nostrdb-rs?rev=3e87e504090b8cc153474e584a1ecd4618441099#3e87e504090b8cc153474e584a1ecd4618441099"
version = "0.7.0"
source = "git+https://github.com/damus-io/nostrdb-rs?rev=ee7287a897fc229fa2ef060e2358a7ba258a4a6d#ee7287a897fc229fa2ef060e2358a7ba258a4a6d"
dependencies = [
"bindgen",
"cc",

2
Cargo.toml
View File

@@ -37,7 +37,7 @@ log = "0.4.17"
nostr = { version = "0.37.0", default-features = false, features = ["std", "nip49"] }
nwc = "0.39.0"
mio = { version = "1.0.3", features = ["os-poll", "net"] }
nostrdb = { git = "https://github.com/damus-io/nostrdb-rs", rev = "3e87e504090b8cc153474e584a1ecd4618441099" }
nostrdb = { git = "https://github.com/damus-io/nostrdb-rs", rev = "ee7287a897fc229fa2ef060e2358a7ba258a4a6d" }
#nostrdb = "0.6.1"
notedeck = { path = "crates/notedeck" }
notedeck_chrome = { path = "crates/notedeck_chrome" }

176
crates/notedeck/src/account/accounts.rs
View File

@@ -1,7 +1,7 @@
use tracing::debug;
use uuid::Uuid;
use crate::account::cache::AccountCache;
use crate::account::contacts::Contacts;
use crate::account::mute::AccountMutedData;
use crate::account::relay::{
modify_advertised_relays, update_relay_configuration, AccountRelayData, RelayAction,
@@ -42,10 +42,7 @@ impl Accounts {
) -> Self {
let (mut cache, unknown_id) = AccountCache::new(UserAccount::new(
Keypair::only_pubkey(fallback),
AccountData {
relay: AccountRelayData::new(ndb, txn, fallback.bytes()),
muted: AccountMutedData::new(ndb, txn, fallback.bytes()),
},
AccountData::new(fallback.bytes()),
));
unknown_id.process_action(unknown_ids, ndb, txn);
@@ -56,7 +53,7 @@ impl Accounts {
match reader.get_accounts() {
Ok(accounts) => {
for account in accounts {
add_account_from_storage(&mut cache, ndb, txn, account).process_action(
add_account_from_storage(&mut cache, account).process_action(
unknown_ids,
ndb,
txn,
@@ -76,8 +73,10 @@ impl Accounts {
let relay_defaults = RelayDefaults::new(forced_relays);
let selected = cache.selected();
let selected_data = &selected.data;
let selected = cache.selected_mut();
let selected_data = &mut selected.data;
selected_data.query(ndb, txn);
let subs = {
AccountSubs::new(
@@ -117,12 +116,7 @@ impl Accounts {
}
#[must_use = "UnknownIdAction's must be handled. Use .process_unknown_id_action()"]
pub fn add_account(
&mut self,
ndb: &Ndb,
txn: &Transaction,
kp: Keypair,
) -> Option<AddAccountResponse> {
pub fn add_account(&mut self, kp: Keypair) -> Option<AddAccountResponse> {
let acc = if let Some(acc) = self.cache.get_mut(&kp.pubkey) {
if kp.secret_key.is_none() || acc.key.secret_key.is_some() {
tracing::info!("Already have account, not adding");
@@ -132,10 +126,7 @@ impl Accounts {
acc.key = kp.clone();
AccType::Acc(&*acc)
} else {
let new_account_data = AccountData {
relay: AccountRelayData::new(ndb, txn, kp.pubkey.bytes()),
muted: AccountMutedData::new(ndb, txn, kp.pubkey.bytes()),
};
let new_account_data = AccountData::new(kp.pubkey.bytes());
AccType::Entry(
self.cache
.add(UserAccount::new(kp.clone(), new_account_data)),
@@ -213,6 +204,7 @@ impl Accounts {
&mut self,
pk_to_select: &Pubkey,
ndb: &mut Ndb,
txn: &Transaction,
pool: &mut RelayPool,
ctx: &egui::Context,
) {
@@ -226,6 +218,7 @@ impl Accounts {
}
}
self.get_selected_account_mut().data.query(ndb, txn);
self.subs.swap_to(
ndb,
pool,
@@ -261,53 +254,40 @@ impl Accounts {
),
relay_url,
);
}
fn poll_for_updates(&mut self, ndb: &Ndb) -> bool {
let mut changed = false;
let relay_sub = self.subs.relay.local;
let mute_sub = self.subs.mute.local;
let acc = self.get_selected_account_mut();
let nks = ndb.poll_for_notes(relay_sub, 1);
if !nks.is_empty() {
let txn = Transaction::new(ndb).expect("txn");
let relays = AccountRelayData::harvest_nip65_relays(ndb, &txn, &nks);
debug!(
"pubkey {}: updated relays {:?}",
acc.key.pubkey.hex(),
relays
);
acc.data.relay.advertised = relays.into_iter().collect();
changed = true;
}
let nks = ndb.poll_for_notes(mute_sub, 1);
if !nks.is_empty() {
let txn = Transaction::new(ndb).expect("txn");
let muted = AccountMutedData::harvest_nip51_muted(ndb, &txn, &nks);
debug!("pubkey {}: updated muted {:?}", acc.key.pubkey.hex(), muted);
acc.data.muted.muted = Arc::new(muted);
changed = true;
}
changed
pool.send_to(
&ClientMessage::req(
self.subs.contacts.remote.clone(),
vec![data.contacts.filter.clone()],
),
relay_url,
);
}
pub fn update(&mut self, ndb: &mut Ndb, pool: &mut RelayPool, ctx: &egui::Context) {
// IMPORTANT - This function is called in the UI update loop,
// make sure it is fast when idle
// If needed, update the relay configuration
if self.poll_for_updates(ndb) {
let acc = self.cache.selected();
update_relay_configuration(
pool,
&self.relay_defaults,
&acc.key.pubkey,
&acc.data,
create_wakeup(ctx),
);
let Some(update) = self
.cache
.selected_mut()
.data
.poll_for_updates(ndb, &self.subs)
else {
return;
};
match update {
// If needed, update the relay configuration
AccountDataUpdate::Relay => {
let acc = self.cache.selected();
update_relay_configuration(
pool,
&self.relay_defaults,
&acc.key.pubkey,
&acc.data.relay,
create_wakeup(ctx),
);
}
}
}
@@ -328,10 +308,14 @@ impl Accounts {
pool,
&self.relay_defaults,
&acc.key.pubkey,
&acc.data,
&acc.data.relay,
create_wakeup(ctx),
);
}
pub fn get_subs(&self) -> &AccountSubs {
&self.subs
}
}
enum AccType<'a> {
@@ -357,11 +341,9 @@ fn create_wakeup(ctx: &egui::Context) -> impl Fn() + Send + Sync + Clone + 'stat
fn add_account_from_storage(
cache: &mut AccountCache,
ndb: &Ndb,
txn: &Transaction,
user_account_serializable: UserAccountSerializable,
) -> SingleUnkIdAction {
let Some(acc) = get_acc_from_storage(ndb, txn, user_account_serializable) else {
let Some(acc) = get_acc_from_storage(user_account_serializable) else {
return SingleUnkIdAction::NoAction;
};
@@ -371,16 +353,9 @@ fn add_account_from_storage(
SingleUnkIdAction::pubkey(pk)
}
fn get_acc_from_storage(
ndb: &Ndb,
txn: &Transaction,
user_account_serializable: UserAccountSerializable,
) -> Option<UserAccount> {
fn get_acc_from_storage(user_account_serializable: UserAccountSerializable) -> Option<UserAccount> {
let keypair = user_account_serializable.key;
let new_account_data = AccountData {
relay: AccountRelayData::new(ndb, txn, keypair.pubkey.bytes()),
muted: AccountMutedData::new(ndb, txn, keypair.pubkey.bytes()),
};
let new_account_data = AccountData::new(keypair.pubkey.bytes());
let mut wallet = None;
if let Some(wallet_s) = user_account_serializable.wallet {
@@ -403,6 +378,46 @@ fn get_acc_from_storage(
pub struct AccountData {
pub(crate) relay: AccountRelayData,
pub(crate) muted: AccountMutedData,
pub contacts: Contacts,
}
impl AccountData {
pub fn new(pubkey: &[u8; 32]) -> Self {
Self {
relay: AccountRelayData::new(pubkey),
muted: AccountMutedData::new(pubkey),
contacts: Contacts::new(pubkey),
}
}
pub(super) fn poll_for_updates(
&mut self,
ndb: &Ndb,
subs: &AccountSubs,
) -> Option<AccountDataUpdate> {
let txn = Transaction::new(ndb).expect("txn");
let mut resp = None;
if self.relay.poll_for_updates(ndb, &txn, subs.relay.local) {
resp = Some(AccountDataUpdate::Relay);
}
self.muted.poll_for_updates(ndb, &txn, subs.mute.local);
self.contacts
.poll_for_updates(ndb, &txn, subs.contacts.local);
resp
}
/// Note: query should be called as close to the subscription as possible
pub(super) fn query(&mut self, ndb: &Ndb, txn: &Transaction) {
self.relay.query(ndb, txn);
self.muted.query(ndb, txn);
self.contacts.query(ndb, txn);
}
}
pub(super) enum AccountDataUpdate {
Relay,
}
pub struct AddAccountResponse {
@@ -410,13 +425,14 @@ pub struct AddAccountResponse {
pub unk_id_action: SingleUnkIdAction,
}
struct AccountSubs {
pub struct AccountSubs {
relay: UnifiedSubscription,
mute: UnifiedSubscription,
pub contacts: UnifiedSubscription,
}
impl AccountSubs {
pub fn new(
pub(super) fn new(
ndb: &mut Ndb,
pool: &mut RelayPool,
relay_defaults: &RelayDefaults,
@@ -426,12 +442,17 @@ impl AccountSubs {
) -> Self {
let relay = subscribe(ndb, pool, &data.relay.filter);
let mute = subscribe(ndb, pool, &data.muted.filter);
update_relay_configuration(pool, relay_defaults, pk, data, wakeup);
let contacts = subscribe(ndb, pool, &data.contacts.filter);
update_relay_configuration(pool, relay_defaults, pk, &data.relay, wakeup);
Self { relay, mute }
Self {
relay,
mute,
contacts,
}
}
pub fn swap_to(
pub(super) fn swap_to(
&mut self,
ndb: &mut Ndb,
pool: &mut RelayPool,
@@ -442,6 +463,7 @@ impl AccountSubs {
) {
unsubscribe(ndb, pool, &self.relay);
unsubscribe(ndb, pool, &self.mute);
unsubscribe(ndb, pool, &self.contacts);
*self = AccountSubs::new(ndb, pool, relay_defaults, pk, new_selection_data, wakeup);
}

145
crates/notedeck/src/account/contacts.rs Normal file
View File

@@ -0,0 +1,145 @@
use std::collections::HashSet;
use enostr::Pubkey;
use nostrdb::{Filter, Ndb, Note, NoteKey, Subscription, Transaction};
pub struct Contacts {
pub filter: Filter,
pub(super) state: ContactState,
}
pub enum ContactState {
Unreceived,
Received {
contacts: HashSet<Pubkey>,
note_key: NoteKey,
},
}
#[derive(Eq, PartialEq, Debug, Clone, Copy)]
pub enum IsFollowing {
/// We don't have the contact list, so we don't know
Unknown,
/// We are follow
Yes,
No,
}
impl Contacts {
pub fn new(pubkey: &[u8; 32]) -> Self {
let filter = Filter::new().authors([pubkey]).kinds([3]).limit(1).build();
Self {
filter,
state: ContactState::Unreceived,
}
}
pub(super) fn query(&mut self, ndb: &Ndb, txn: &Transaction) {
let binding = ndb
.query(txn, &[self.filter.clone()], 1)
.expect("query user relays results");
let Some(res) = binding.first() else {
return;
};
update_state(&mut self.state, &res.note, res.note_key);
}
pub fn is_following(&self, other: &Pubkey) -> IsFollowing {
match &self.state {
ContactState::Unreceived => IsFollowing::Unknown,
ContactState::Received {
contacts,
note_key: _,
} => {
if contacts.contains(other) {
IsFollowing::Yes
} else {
IsFollowing::No
}
}
}
}
pub(super) fn poll_for_updates(&mut self, ndb: &Ndb, txn: &Transaction, sub: Subscription) {
let nks = ndb.poll_for_notes(sub, 1);
let Some(key) = nks.first() else {
return;
};
let note = match ndb.get_note_by_key(txn, *key) {
Ok(note) => note,
Err(e) => {
tracing::error!("Could not find note at key {:?}: {e}", key);
return;
}
};
update_state(&mut self.state, &note, *key);
}
pub fn get_state(&self) -> &ContactState {
&self.state
}
}
fn update_state(state: &mut ContactState, note: &Note, key: NoteKey) {
match state {
ContactState::Unreceived => {
*state = ContactState::Received {
contacts: get_contacts_owned(note),
note_key: key,
};
}
ContactState::Received { contacts, note_key } => {
update_contacts(contacts, note);
*note_key = key;
}
};
}
fn get_contacts<'a>(note: &Note<'a>) -> HashSet<&'a [u8; 32]> {
let mut contacts = HashSet::with_capacity(note.tags().count().into());
for tag in note.tags() {
if tag.count() < 2 {
continue;
}
let Some("p") = tag.get_str(0) else {
continue;
};
let Some(cur_id) = tag.get_id(1) else {
continue;
};
contacts.insert(cur_id);
}
contacts
}
fn get_contacts_owned(note: &Note<'_>) -> HashSet<Pubkey> {
get_contacts(note)
.iter()
.map(|p| Pubkey::new(**p))
.collect()
}
fn update_contacts(cur: &mut HashSet<Pubkey>, new: &Note<'_>) {
let new_contacts = get_contacts(new);
cur.retain(|pk| new_contacts.contains(pk.bytes()));
new_contacts.iter().for_each(|c| {
if !cur.contains(*c) {
cur.insert(Pubkey::new(**c));
}
});
}

1
crates/notedeck/src/account/mod.rs
View File

@@ -1,5 +1,6 @@
pub mod accounts;
pub mod cache;
pub mod contacts;
pub mod mute;
pub mod relay;

37
crates/notedeck/src/account/mute.rs
View File

@@ -1,6 +1,6 @@
use std::sync::Arc;
use nostrdb::{Filter, Ndb, NoteKey, Transaction};
use nostrdb::{Filter, Ndb, NoteKey, Subscription, Transaction};
use tracing::{debug, error};
use crate::Muted;
@@ -11,7 +11,7 @@ pub(crate) struct AccountMutedData {
}
impl AccountMutedData {
pub fn new(ndb: &Ndb, txn: &Transaction, pubkey: &[u8; 32]) -> Self {
pub fn new(pubkey: &[u8; 32]) -> Self {
// Construct a filter for the user's NIP-51 muted list
let filter = Filter::new()
.authors([pubkey])
@@ -19,21 +19,28 @@ impl AccountMutedData {
.limit(1)
.build();
AccountMutedData {
filter,
muted: Arc::new(Muted::default()),
}
}
pub(super) fn query(&mut self, ndb: &Ndb, txn: &Transaction) {
// Query the ndb immediately to see if the user's muted list is already there
let lim = filter.limit().unwrap_or(crate::filter::default_limit()) as i32;
let lim = self
.filter
.limit()
.unwrap_or(crate::filter::default_limit()) as i32;
let nks = ndb
.query(txn, &[filter.clone()], lim)
.query(txn, &[self.filter.clone()], lim)
.expect("query user muted results")
.iter()
.map(|qr| qr.note_key)
.collect::<Vec<NoteKey>>();
let muted = Self::harvest_nip51_muted(ndb, txn, &nks);
debug!("pubkey {}: initial muted {:?}", hex::encode(pubkey), muted);
debug!("initial muted {:?}", muted);
AccountMutedData {
filter,
muted: Arc::new(muted),
}
self.muted = Arc::new(muted);
}
pub(crate) fn harvest_nip51_muted(ndb: &Ndb, txn: &Transaction, nks: &[NoteKey]) -> Muted {
@@ -76,4 +83,16 @@ impl AccountMutedData {
}
muted
}
pub(super) fn poll_for_updates(&mut self, ndb: &Ndb, txn: &Transaction, sub: Subscription) {
let nks = ndb.poll_for_notes(sub, 1);
if nks.is_empty() {
return;
}
let muted = AccountMutedData::harvest_nip51_muted(ndb, txn, &nks);
debug!("updated muted {:?}", muted);
self.muted = Arc::new(muted);
}
}

51
crates/notedeck/src/account/relay.rs
View File

@@ -1,7 +1,7 @@
use std::collections::BTreeSet;
use enostr::{Keypair, Pubkey, RelayPool};
use nostrdb::{Filter, Ndb, NoteBuilder, NoteKey, Transaction};
use nostrdb::{Filter, Ndb, NoteBuilder, NoteKey, Subscription, Transaction};
use tracing::{debug, error, info};
use url::Url;
@@ -14,7 +14,7 @@ pub(crate) struct AccountRelayData {
}
impl AccountRelayData {
pub fn new(ndb: &Ndb, txn: &Transaction, pubkey: &[u8; 32]) -> Self {
pub fn new(pubkey: &[u8; 32]) -> Self {
// Construct a filter for the user's NIP-65 relay list
let filter = Filter::new()
.authors([pubkey])
@@ -22,26 +22,29 @@ impl AccountRelayData {
.limit(1)
.build();
AccountRelayData {
filter,
local: BTreeSet::new(),
advertised: BTreeSet::new(),
}
}
pub fn query(&mut self, ndb: &Ndb, txn: &Transaction) {
// Query the ndb immediately to see if the user list is already there
let lim = filter.limit().unwrap_or(crate::filter::default_limit()) as i32;
let lim = self
.filter
.limit()
.unwrap_or(crate::filter::default_limit()) as i32;
let nks = ndb
.query(txn, &[filter.clone()], lim)
.query(txn, &[self.filter.clone()], lim)
.expect("query user relays results")
.iter()
.map(|qr| qr.note_key)
.collect::<Vec<NoteKey>>();
let relays = Self::harvest_nip65_relays(ndb, txn, &nks);
debug!(
"pubkey {}: initial relays {:?}",
hex::encode(pubkey),
relays
);
debug!("initial relays {:?}", relays);
AccountRelayData {
filter,
local: BTreeSet::new(),
advertised: relays.into_iter().collect(),
}
self.advertised = relays.into_iter().collect()
}
// standardize the format (ie, trailing slashes) to avoid dups
@@ -106,6 +109,20 @@ impl AccountRelayData {
let note = builder.sign(seckey).build().expect("note build");
pool.send(&enostr::ClientMessage::event(&note).expect("note client message"));
}
pub fn poll_for_updates(&mut self, ndb: &Ndb, txn: &Transaction, sub: Subscription) -> bool {
let nks = ndb.poll_for_notes(sub, 1);
if nks.is_empty() {
return false;
}
let relays = AccountRelayData::harvest_nip65_relays(ndb, txn, &nks);
debug!("updated relays {:?}", relays);
self.advertised = relays.into_iter().collect();
true
}
}
pub(crate) struct RelayDefaults {
@@ -142,7 +159,7 @@ pub(super) fn update_relay_configuration(
pool: &mut RelayPool,
relay_defaults: &RelayDefaults,
pk: &Pubkey,
data: &AccountData,
data: &AccountRelayData,
wakeup: impl Fn() + Send + Sync + Clone + 'static,
) {
debug!(
@@ -155,8 +172,8 @@ pub(super) fn update_relay_configuration(
// Compose the desired relay lists from the selected account
if desired_relays.is_empty() {
desired_relays.extend(data.relay.local.iter().cloned());
desired_relays.extend(data.relay.advertised.iter().cloned());
desired_relays.extend(data.local.iter().cloned());
desired_relays.extend(data.advertised.iter().cloned());
}
// If no relays are specified at this point use the bootstrap list

4
crates/notedeck/src/app.rs
View File

@@ -203,7 +203,7 @@ impl Notedeck {
{
for key in &parsed_args.keys {
info!("adding account: {}", &key.pubkey);
if let Some(resp) = accounts.add_account(&ndb, &txn, key.clone()) {
if let Some(resp) = accounts.add_account(key.clone()) {
resp.unk_id_action
.process_action(&mut unknown_ids, &ndb, &txn);
}
@@ -211,7 +211,7 @@ impl Notedeck {
}
if let Some(first) = parsed_args.keys.first() {
accounts.select_account(&first.pubkey, &mut ndb, &mut pool, ctx);
accounts.select_account(&first.pubkey, &mut ndb, &txn, &mut pool, ctx);
}
let img_cache = Images::new(img_cache_dir);

3
crates/notedeck/src/lib.rs
View File

@@ -33,7 +33,8 @@ mod user_account;
mod wallet;
mod zaps;
pub use account::accounts::{AccountData, Accounts};
pub use account::accounts::{AccountData, AccountSubs, Accounts};
pub use account::contacts::{ContactState, IsFollowing};
pub use account::relay::RelayAction;
pub use account::FALLBACK_PUBKEY;
pub use app::{App, AppAction, Notedeck};

8
crates/notedeck/src/user_account.rs
View File

@@ -1,9 +1,9 @@
use enostr::{Keypair, KeypairUnowned};
use enostr::{Keypair, KeypairUnowned, Pubkey};
use tokenator::{ParseError, TokenParser, TokenSerializable};
use crate::{
wallet::{WalletSerializable, ZapWallet},
AccountData,
AccountData, IsFollowing,
};
pub struct UserAccount {
@@ -32,6 +32,10 @@ impl UserAccount {
self.wallet = Some(wallet);
self
}
pub fn is_following(&self, pk: &Pubkey) -> IsFollowing {
self.data.contacts.is_following(pk)
}
}
pub struct UserAccountSerializable {

13
crates/notedeck_columns/src/accounts/mod.rs
View File

@@ -5,6 +5,7 @@ use notedeck::{Accounts, AppContext, SingleUnkIdAction, UnknownIds};
use crate::app::get_active_columns_mut;
use crate::decks::DecksCache;
use crate::profile::send_new_contact_list;
use crate::{
login_manager::AcquireKeyState,
route::Route,
@@ -149,18 +150,14 @@ pub fn process_login_view_response(
) -> AddAccountAction {
let (r, pubkey) = match response {
AccountLoginResponse::CreateNew => {
let kp = FullKeypair::generate().to_keypair();
let kp = FullKeypair::generate();
let pubkey = kp.pubkey;
let txn = Transaction::new(app_ctx.ndb).expect("txn");
(app_ctx.accounts.add_account(app_ctx.ndb, &txn, kp), pubkey)
send_new_contact_list(kp.to_filled(), app_ctx.ndb, app_ctx.pool);
(app_ctx.accounts.add_account(kp.to_keypair()), pubkey)
}
AccountLoginResponse::LoginWith(keypair) => {
let pubkey = keypair.pubkey;
let txn = Transaction::new(app_ctx.ndb).expect("txn");
(
app_ctx.accounts.add_account(app_ctx.ndb, &txn, keypair),
pubkey,
)
(app_ctx.accounts.add_account(keypair), pubkey)
}
};

61
crates/notedeck_columns/src/app.rs
View File

@@ -8,14 +8,16 @@ use crate::{
storage,
subscriptions::{SubKind, Subscriptions},
support::Support,
timeline::{self, kind::ListKind, thread::Threads, TimelineCache, TimelineKind},
timeline::{
self, fetch_contact_list, kind::ListKind, thread::Threads, TimelineCache, TimelineKind,
},
ui::{self, DesktopSidePanel, SidePanelAction},
view_state::ViewState,
Result,
};
use notedeck::{
ui::is_narrow, Accounts, AppAction, AppContext, DataPath, DataPathType, FilterState, UnknownIds,
ui::is_narrow, Accounts, AppAction, AppContext, DataPath, DataPathType, UnknownIds,
};
use notedeck_ui::{jobs::JobsCache, NoteOptions};
@@ -116,13 +118,21 @@ fn try_process_event(
.accounts
.send_initial_filters(app_ctx.pool, &ev.relay);
let data = app_ctx.accounts.get_subs();
damus.subscriptions.subs.insert(
data.contacts.remote.clone(),
SubKind::FetchingContactList(TimelineKind::List(ListKind::Contact(
*app_ctx.accounts.selected_account_pubkey(),
))),
);
timeline::send_initial_timeline_filters(
app_ctx.ndb,
damus.since_optimize,
&mut damus.timeline_cache,
&mut damus.subscriptions,
app_ctx.pool,
&ev.relay,
app_ctx.accounts,
);
}
// TODO: handle reconnects
@@ -248,44 +258,11 @@ fn handle_eose(
}
SubKind::FetchingContactList(timeline_uid) => {
let timeline = if let Some(tl) = timeline_cache.timelines.get_mut(timeline_uid) {
tl
} else {
error!(
"timeline uid:{} not found for FetchingContactList",
timeline_uid
);
let Some(timeline) = timeline_cache.timelines.get_mut(timeline_uid) else {
return Ok(());
};
let filter_state = timeline.filter.get_mut(relay_url);
// If this request was fetching a contact list, our filter
// state should be "FetchingRemote". We look at the local
// subscription for that filter state and get the subscription id
let local_sub = if let FilterState::FetchingRemote(unisub) = filter_state {
unisub.local
} else {
// TODO: we could have multiple contact list results, we need
// to check to see if this one is newer and use that instead
warn!(
"Expected timeline to have FetchingRemote state but was {:?}",
timeline.filter
);
return Ok(());
};
info!(
"got contact list from {}, updating filter_state to got_remote",
relay_url
);
// We take the subscription id and pass it to the new state of
// "GotRemote". This will let future frames know that it can try
// to look for the contact list in nostrdb.
timeline
.filter
.set_relay_state(relay_url.to_string(), FilterState::got_remote(local_sub));
fetch_contact_list(relay_url, timeline, ctx.accounts);
}
}
@@ -747,7 +724,13 @@ fn timelines_view(
let mut save_cols = false;
if let Some(action) = side_panel_action {
save_cols = save_cols
|| action.process(&mut app.timeline_cache, &mut app.decks_cache, ctx, ui.ctx());
|| action.process(
&mut app.timeline_cache,
&mut app.decks_cache,
&mut app.subscriptions,
ctx,
ui.ctx(),
);
}
let mut app_action: Option<AppAction> = None;

19
crates/notedeck_columns/src/nav.rs
View File

@@ -7,9 +7,11 @@ use crate::{
profile::{ProfileAction, SaveProfileChanges},
profile_state::ProfileState,
route::{Route, Router, SingletonRouter},
subscriptions::{SubKind, Subscriptions},
timeline::{
kind::ListKind,
route::{render_thread_route, render_timeline_route},
TimelineCache,
TimelineCache, TimelineKind,
},
ui::{
self,
@@ -72,18 +74,31 @@ impl SwitchingAction {
&self,
timeline_cache: &mut TimelineCache,
decks_cache: &mut DecksCache,
subs: &mut Subscriptions,
ctx: &mut AppContext<'_>,
ui_ctx: &egui::Context,
) -> bool {
match &self {
SwitchingAction::Accounts(account_action) => match account_action {
AccountsAction::Switch(switch_action) => {
let txn = Transaction::new(ctx.ndb).expect("txn");
ctx.accounts.select_account(
&switch_action.switch_to,
ctx.ndb,
&txn,
ctx.pool,
ui_ctx,
);
let new_subs = ctx.accounts.get_subs();
subs.subs.insert(
new_subs.contacts.remote.clone(),
SubKind::FetchingContactList(TimelineKind::List(ListKind::Contact(
*ctx.accounts.selected_account_pubkey(),
))),
);
// pop nav after switch
get_active_columns_mut(ctx.accounts, decks_cache)
.column_mut(switch_action.source_column)
@@ -378,6 +393,7 @@ fn process_render_nav_action(
if switching_action.process(
&mut app.timeline_cache,
&mut app.decks_cache,
&mut app.subscriptions,
ctx,
ui.ctx(),
) {
@@ -390,6 +406,7 @@ fn process_render_nav_action(
&mut app.view_state.pubkey_to_profile_state,
ctx.ndb,
ctx.pool,
ctx.accounts,
),
RenderNavAction::WalletAction(wallet_action) => {
wallet_action.process(ctx.accounts, ctx.global_wallet)

159
crates/notedeck_columns/src/profile.rs
View File

@@ -1,8 +1,9 @@
use std::collections::HashMap;
use enostr::{FullKeypair, Pubkey, RelayPool};
use nostrdb::{Ndb, Note, NoteBuildOptions, NoteBuilder};
use enostr::{FilledKeypair, FullKeypair, Pubkey, RelayPool};
use nostrdb::{Ndb, Note, NoteBuildOptions, NoteBuilder, Transaction};
use notedeck::{Accounts, ContactState};
use tracing::info;
use crate::{nav::RouterAction, profile_state::ProfileState, route::Route};
@@ -37,6 +38,8 @@ fn add_client_tag(builder: NoteBuilder<'_>) -> NoteBuilder<'_> {
pub enum ProfileAction {
Edit(FullKeypair),
SaveChanges(SaveProfileChanges),
Follow(Pubkey),
Unfollow(Pubkey),
}
impl ProfileAction {
@@ -45,6 +48,7 @@ impl ProfileAction {
state_map: &mut HashMap<Pubkey, ProfileState>,
ndb: &Ndb,
pool: &mut RelayPool,
accounts: &Accounts,
) -> Option<RouterAction> {
match self {
ProfileAction::Edit(kp) => Some(RouterAction::route_to(Route::EditProfile(kp.pubkey))),
@@ -62,6 +66,157 @@ impl ProfileAction {
Some(RouterAction::GoBack)
}
ProfileAction::Follow(target_key) => {
Self::send_follow_user_event(ndb, pool, accounts, target_key);
None
}
ProfileAction::Unfollow(target_key) => {
Self::send_unfollow_user_event(ndb, pool, accounts, target_key);
None
}
}
}
fn send_follow_user_event(
ndb: &Ndb,
pool: &mut RelayPool,
accounts: &Accounts,
target_key: &Pubkey,
) {
send_kind_3_event(ndb, pool, accounts, FollowAction::Follow(target_key));
}
fn send_unfollow_user_event(
ndb: &Ndb,
pool: &mut RelayPool,
accounts: &Accounts,
target_key: &Pubkey,
) {
send_kind_3_event(ndb, pool, accounts, FollowAction::Unfollow(target_key));
}
}
pub fn builder_from_note<F>(note: Note<'_>, skip_tag: Option<F>) -> NoteBuilder<'_>
where
F: Fn(&nostrdb::Tag<'_>) -> bool,
{
let mut builder = NoteBuilder::new();
builder = builder.content(note.content());
builder = builder.options(NoteBuildOptions::default());
builder = builder.kind(note.kind());
builder = builder.pubkey(note.pubkey());
for tag in note.tags() {
if let Some(skip) = &skip_tag {
if skip(&tag) {
continue;
}
}
builder = builder.start_tag();
for tag_item in tag {
builder = match tag_item.variant() {
nostrdb::NdbStrVariant::Id(i) => builder.tag_id(i),
nostrdb::NdbStrVariant::Str(s) => builder.tag_str(s),
};
}
}
builder
}
enum FollowAction<'a> {
Follow(&'a Pubkey),
Unfollow(&'a Pubkey),
}
fn send_kind_3_event(ndb: &Ndb, pool: &mut RelayPool, accounts: &Accounts, action: FollowAction) {
let Some(kp) = accounts.get_selected_account().key.to_full() else {
return;
};
let txn = Transaction::new(ndb).expect("txn");
let ContactState::Received {
contacts: _,
note_key,
} = accounts.get_selected_account().data.contacts.get_state()
else {
return;
};
let contact_note = match ndb.get_note_by_key(&txn, *note_key).ok() {
Some(n) => n,
None => {
tracing::error!("Somehow we are in state ContactState::Received but the contact note key doesn't exist");
return;
}
};
if contact_note.kind() != 3 {
tracing::error!("Something very wrong just occured. The key for the supposed contact note yielded a note which was not a contact...");
return;
}
let builder = match action {
FollowAction::Follow(pubkey) => {
builder_from_note(contact_note, None::<fn(&nostrdb::Tag<'_>) -> bool>)
.start_tag()
.tag_str("p")
.tag_str(&pubkey.hex())
}
FollowAction::Unfollow(pubkey) => builder_from_note(
contact_note,
Some(|tag: &nostrdb::Tag<'_>| {
if tag.count() < 2 {
return false;
}
let Some("p") = tag.get_str(0) else {
return false;
};
let Some(cur_val) = tag.get_id(1) else {
return false;
};
cur_val == pubkey.bytes()
}),
),
};
send_note_builder(builder, ndb, pool, kp);
}
fn send_note_builder(builder: NoteBuilder, ndb: &Ndb, pool: &mut RelayPool, kp: FilledKeypair) {
let note = builder
.sign(&kp.secret_key.secret_bytes())
.build()
.expect("build note");
let raw_msg = format!("[\"EVENT\",{}]", note.json().unwrap());
let _ = ndb.process_event_with(
raw_msg.as_str(),
nostrdb::IngestMetadata::new().client(true),
);
info!("sending {}", raw_msg);
pool.send(&enostr::ClientMessage::raw(raw_msg));
}
pub fn send_new_contact_list(kp: FilledKeypair, ndb: &Ndb, pool: &mut RelayPool) {
let builder = construct_new_contact_list(kp.pubkey);
send_note_builder(builder, ndb, pool, kp);
}
fn construct_new_contact_list<'a>(pk: &'a Pubkey) -> NoteBuilder<'a> {
NoteBuilder::new()
.content("")
.kind(3)
.options(NoteBuildOptions::default())
.start_tag()
.tag_str("p")
.tag_str(&pk.hex())
}

51
crates/notedeck_columns/src/timeline/mod.rs
View File

@@ -7,7 +7,8 @@ use crate::{
};
use notedeck::{
filter, CachedNote, FilterError, FilterState, FilterStates, NoteCache, NoteRef, UnknownIds,
filter, Accounts, CachedNote, FilterError, FilterState, FilterStates, NoteCache, NoteRef,
UnknownIds,
};
use egui_virtual_list::VirtualList;
@@ -474,6 +475,7 @@ pub fn setup_new_timeline(
pool: &mut RelayPool,
note_cache: &mut NoteCache,
since_optimize: bool,
accounts: &Accounts,
) {
// if we're ready, setup local subs
if is_timeline_ready(ndb, pool, note_cache, timeline) {
@@ -483,7 +485,7 @@ pub fn setup_new_timeline(
}
for relay in &mut pool.relays {
send_initial_timeline_filter(ndb, since_optimize, subs, relay, timeline);
send_initial_timeline_filter(since_optimize, subs, relay, timeline, accounts);
}
}
@@ -492,29 +494,29 @@ pub fn setup_new_timeline(
/// situations where you are adding a new timeline, use
/// setup_new_timeline.
pub fn send_initial_timeline_filters(
ndb: &Ndb,
since_optimize: bool,
timeline_cache: &mut TimelineCache,
subs: &mut Subscriptions,
pool: &mut RelayPool,
relay_id: &str,
accounts: &Accounts,
) -> Option<()> {
info!("Sending initial filters to {}", relay_id);
let relay = &mut pool.relays.iter_mut().find(|r| r.url() == relay_id)?;
for (_kind, timeline) in timeline_cache.timelines.iter_mut() {
send_initial_timeline_filter(ndb, since_optimize, subs, relay, timeline);
send_initial_timeline_filter(since_optimize, subs, relay, timeline, accounts);
}
Some(())
}
pub fn send_initial_timeline_filter(
ndb: &Ndb,
can_since_optimize: bool,
subs: &mut Subscriptions,
relay: &mut PoolRelay,
timeline: &mut Timeline,
accounts: &Accounts,
) {
let filter_state = timeline.filter.get_mut(relay.url());
@@ -572,34 +574,27 @@ pub fn send_initial_timeline_filter(
}
// we need some data first
FilterState::NeedsRemote(filter) => {
fetch_contact_list(filter.to_owned(), ndb, subs, relay, timeline)
}
FilterState::NeedsRemote(_filter) => fetch_contact_list(relay.url(), timeline, accounts),
}
}
fn fetch_contact_list(
filter: Vec<Filter>,
ndb: &Ndb,
subs: &mut Subscriptions,
relay: &mut PoolRelay,
timeline: &mut Timeline,
) {
let sub_kind = SubKind::FetchingContactList(timeline.kind.clone());
let sub_id = subscriptions::new_sub_id();
let local_sub = ndb.subscribe(&filter).expect("sub");
pub fn fetch_contact_list(relay_url: &str, timeline: &mut Timeline, accounts: &Accounts) {
let account_subs = accounts.get_subs();
let local = account_subs.contacts.local;
timeline.filter.set_relay_state(
relay.url().to_string(),
FilterState::fetching_remote(sub_id.clone(), local_sub),
);
let filter_state = match accounts.get_selected_account().data.contacts.get_state() {
notedeck::ContactState::Unreceived => {
FilterState::fetching_remote(account_subs.contacts.remote.clone(), local)
}
notedeck::ContactState::Received {
contacts: _,
note_key: _,
} => FilterState::GotRemote(local),
};
subs.subs.insert(sub_id.clone(), sub_kind);
info!("fetching contact list from {}", relay.url());
if let Err(err) = relay.subscribe(sub_id, filter) {
error!("error subscribing: {err}");
}
timeline
.filter
.set_relay_state(relay_url.to_owned(), filter_state);
}
fn setup_initial_timeline(

10
crates/notedeck_columns/src/timeline/route.rs
View File

@@ -116,7 +116,7 @@ pub fn render_profile_route(
note_context: &mut NoteContext,
jobs: &mut JobsCache,
) -> Option<RenderNavAction> {
let action = ProfileView::new(
let profile_view = ProfileView::new(
pubkey,
accounts,
col,
@@ -128,7 +128,7 @@ pub fn render_profile_route(
)
.ui(ui);
if let Some(action) = action {
if let Some(action) = profile_view {
match action {
ui::profile::ProfileViewAction::EditProfile => accounts
.get_full(pubkey)
@@ -136,6 +136,12 @@ pub fn render_profile_route(
ui::profile::ProfileViewAction::Note(note_action) => {
Some(RenderNavAction::NoteAction(note_action))
}
ui::profile::ProfileViewAction::Follow(target_key) => Some(
RenderNavAction::ProfileAction(ProfileAction::Follow(target_key)),
),
ui::profile::ProfileViewAction::Unfollow(target_key) => Some(
RenderNavAction::ProfileAction(ProfileAction::Unfollow(target_key)),
),
}
} else {
None

2
crates/notedeck_columns/src/ui/add_column.rs
View File

@@ -623,6 +623,7 @@ pub fn render_add_column_routes(
ctx.pool,
ctx.note_cache,
app.since_optimize,
ctx.accounts,
);
app.columns_mut(ctx.accounts)
@@ -664,6 +665,7 @@ pub fn render_add_column_routes(
ctx.pool,
ctx.note_cache,
app.since_optimize,
ctx.accounts,
);
app.columns_mut(ctx.accounts)

7
crates/notedeck_columns/src/ui/note/custom_zap.rs
View File

@@ -9,9 +9,10 @@ use nostrdb::{Ndb, ProfileRecord, Transaction};
use notedeck::{
fonts::get_font_size, get_profile_url, name::get_display_name, Images, NotedeckTextStyle,
};
use notedeck_ui::{app_images, colors, profile::display_name_widget, AnimationHelper, ProfilePic};
use crate::ui::widgets::styled_button_toggleable;
use notedeck_ui::{
app_images, colors, profile::display_name_widget, widgets::styled_button_toggleable,
AnimationHelper, ProfilePic,
};
pub struct CustomZapView<'a> {
images: &'a mut Images,

73
crates/notedeck_columns/src/ui/profile/mod.rs
View File

@@ -4,6 +4,7 @@ pub use edit::EditProfileView;
use egui::{vec2, Color32, CornerRadius, Layout, Rect, RichText, ScrollArea, Sense, Stroke};
use enostr::Pubkey;
use nostrdb::{ProfileRecord, Transaction};
use notedeck_ui::profile::follow_button;
use tracing::error;
use crate::{
@@ -11,8 +12,8 @@ use crate::{
ui::timeline::{tabs_ui, TimelineTabView},
};
use notedeck::{
name::get_display_name, profile::get_profile_url, Accounts, MuteFun, NoteAction, NoteContext,
NotedeckTextStyle,
name::get_display_name, profile::get_profile_url, Accounts, IsFollowing, MuteFun, NoteAction,
NoteContext, NotedeckTextStyle,
};
use notedeck_ui::{
app_images,
@@ -35,6 +36,8 @@ pub struct ProfileView<'a, 'd> {
pub enum ProfileViewAction {
EditProfile,
Note(NoteAction),
Unfollow(Pubkey),
Follow(Pubkey),
}
impl<'a, 'd> ProfileView<'a, 'd> {
@@ -79,8 +82,8 @@ impl<'a, 'd> ProfileView<'a, 'd> {
.ndb
.get_profile_by_pubkey(&txn, self.pubkey.bytes())
{
if self.profile_body(ui, profile) {
action = Some(ProfileViewAction::EditProfile);
if let Some(profile_view_action) = self.profile_body(ui, profile) {
action = Some(profile_view_action);
}
}
let profile_timeline = self
@@ -131,8 +134,12 @@ impl<'a, 'd> ProfileView<'a, 'd> {
output.inner
}
fn profile_body(&mut self, ui: &mut egui::Ui, profile: ProfileRecord<'_>) -> bool {
let mut action = false;
fn profile_body(
&mut self,
ui: &mut egui::Ui,
profile: ProfileRecord<'_>,
) -> Option<ProfileViewAction> {
let mut action = None;
ui.vertical(|ui| {
banner(
ui,
@@ -169,13 +176,49 @@ impl<'a, 'd> ProfileView<'a, 'd> {
ui.ctx().copy_text(to_copy)
}
if self.accounts.contains_full_kp(self.pubkey) {
ui.with_layout(Layout::right_to_left(egui::Align::Max), |ui| {
if ui.add(edit_profile_button()).clicked() {
action = true;
ui.with_layout(Layout::right_to_left(egui::Align::RIGHT), |ui| {
ui.add_space(24.0);
let target_key = self.pubkey;
let selected = self.accounts.get_selected_account();
let profile_type = if selected.key.secret_key.is_none() {
ProfileType::ReadOnly
} else if &selected.key.pubkey == self.pubkey {
ProfileType::MyProfile
} else {
ProfileType::Followable(selected.is_following(target_key))
};
match profile_type {
ProfileType::MyProfile => {
if ui.add(edit_profile_button()).clicked() {
action = Some(ProfileViewAction::EditProfile);
}
}
});
}
ProfileType::Followable(is_following) => {
let follow_button = ui.add(follow_button(is_following));
if follow_button.clicked() {
action = match is_following {
IsFollowing::Unknown => {
// don't do anything, we don't have contact list
None
}
IsFollowing::Yes => {
Some(ProfileViewAction::Unfollow(target_key.to_owned()))
}
IsFollowing::No => {
Some(ProfileViewAction::Follow(target_key.to_owned()))
}
};
}
}
ProfileType::ReadOnly => {}
}
});
});
ui.add_space(18.0);
@@ -215,6 +258,12 @@ impl<'a, 'd> ProfileView<'a, 'd> {
}
}
enum ProfileType {
MyProfile,
ReadOnly,
Followable(IsFollowing),
}
fn handle_link(ui: &mut egui::Ui, website_url: &str) {
let img = if ui.visuals().dark_mode {
app_images::link_image()

3
crates/notedeck_columns/src/ui/timeline.rs
View File

@@ -154,6 +154,9 @@ fn timeline_ui(
error!("tried to render timeline in column, but timeline was missing");
// TODO (jb55): render error when timeline is missing?
// this shouldn't happen...
//
// NOTE (jb55): it can easily happen if you add a timeline column without calling
// add_new_timeline_column, since that sets up the initial subs, etc
return None;
};

46
crates/notedeck_columns/src/ui/widgets.rs
View File

@@ -1,49 +1,7 @@
use egui::{Button, Widget};
use notedeck::NotedeckTextStyle;
use egui::Widget;
use notedeck_ui::widgets::styled_button_toggleable;
/// Sized and styled to match the figma design
pub fn styled_button(text: &str, fill_color: egui::Color32) -> impl Widget + '_ {
styled_button_toggleable(text, fill_color, true)
}
pub fn styled_button_toggleable(
text: &str,
fill_color: egui::Color32,
enabled: bool,
) -> impl Widget + '_ {
move |ui: &mut egui::Ui| -> egui::Response {
let painter = ui.painter();
let text_color = if ui.visuals().dark_mode {
egui::Color32::WHITE
} else {
egui::Color32::BLACK
};
let galley = painter.layout(
text.to_owned(),
NotedeckTextStyle::Body.get_font_id(ui.ctx()),
text_color,
ui.available_width(),
);
let size = galley.rect.expand2(egui::vec2(16.0, 8.0)).size();
let mut button = Button::new(galley).corner_radius(8.0);
if !enabled {
button = button
.sense(egui::Sense::focusable_noninteractive())
.fill(ui.visuals().noninteractive().bg_fill)
.stroke(ui.visuals().noninteractive().bg_stroke);
} else {
button = button.fill(fill_color);
}
let mut resp = ui.add_sized(size, button);
if !enabled {
resp = resp.on_hover_cursor(egui::CursorIcon::NotAllowed);
}
resp
}
}

17
crates/notedeck_ui/src/profile/mod.rs
View File

@@ -8,9 +8,9 @@ pub use picture::ProfilePic;
pub use preview::ProfilePreview;
use egui::{load::TexturePoll, Label, RichText};
use notedeck::{NostrName, NotedeckTextStyle};
use notedeck::{IsFollowing, NostrName, NotedeckTextStyle};
use crate::app_images;
use crate::{app_images, colors, widgets::styled_button_toggleable};
pub fn display_name_widget<'a>(
name: &'a NostrName<'a>,
@@ -115,3 +115,16 @@ pub fn banner(ui: &mut egui::Ui, banner_url: Option<&str>, height: f32) -> egui:
.unwrap_or_else(|| ui.label(""))
})
}
pub fn follow_button(following: IsFollowing) -> impl egui::Widget + 'static {
move |ui: &mut egui::Ui| -> egui::Response {
let (bg_color, text) = match following {
IsFollowing::Unknown => (ui.visuals().noninteractive().bg_fill, "Unknown"),
IsFollowing::Yes => (ui.visuals().widgets.inactive.bg_fill, "Unfollow"),
IsFollowing::No => (colors::PINK, "Follow"),
};
let enabled = following != IsFollowing::Unknown;
ui.add(styled_button_toggleable(text, bg_color, enabled))
}
}

44
crates/notedeck_ui/src/widgets.rs
View File

@@ -1,5 +1,6 @@
use crate::anim::{AnimationHelper, ICON_EXPANSION_MULTIPLE};
use egui::{emath::GuiRounding, Pos2, Stroke};
use notedeck::NotedeckTextStyle;
pub fn x_button(rect: egui::Rect) -> impl egui::Widget {
move |ui: &mut egui::Ui| -> egui::Response {
@@ -33,3 +34,46 @@ pub fn x_button(rect: egui::Rect) -> impl egui::Widget {
helper.take_animation_response()
}
}
/// Button styled in the Notedeck theme
pub fn styled_button_toggleable(
text: &str,
fill_color: egui::Color32,
enabled: bool,
) -> impl egui::Widget + '_ {
move |ui: &mut egui::Ui| -> egui::Response {
let painter = ui.painter();
let text_color = if ui.visuals().dark_mode {
egui::Color32::WHITE
} else {
egui::Color32::BLACK
};
let galley = painter.layout(
text.to_owned(),
NotedeckTextStyle::Button.get_font_id(ui.ctx()),
text_color,
ui.available_width(),
);
let size = galley.rect.expand2(egui::vec2(16.0, 8.0)).size();
let mut button = egui::Button::new(galley).corner_radius(8.0);
if !enabled {
button = button
.sense(egui::Sense::focusable_noninteractive())
.fill(ui.visuals().noninteractive().bg_fill)
.stroke(ui.visuals().noninteractive().bg_stroke);
} else {
button = button.fill(fill_color);
}
let mut resp = ui.add_sized(size, button);
if !enabled {
resp = resp.on_hover_cursor(egui::CursorIcon::NotAllowed);
}
resp
}
}