nostr/gossip
1
0
Fork 0
mirror of https://github.com/mikedilger/gossip.git synced 2024-09-19 19:46:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename EventRelated to FeedEvent, and add the event to it

Browse Source
This commit is contained in:
Mike Dilger 2022-12-21 19:55:22 +13:00
parent fd1954b2fc
commit 6bd043004b
3 changed files with 37 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/event_related.rs → src/feed_event.rs
View File

@ -14,8 +14,9 @@ pub struct Reactions {
/// rendering the event, most of which is gathered from other related /// rendering the event, most of which is gathered from other related
/// events. /// events.
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
pub struct EventRelated { pub struct FeedEvent {
pub id: Id, pub id: Id,
pub event: Option<Event>,
pub feed_related: bool, pub feed_related: bool,
pub replies: Vec<Id>, pub replies: Vec<Id>,
pub in_reply_to: Option<Id>, pub in_reply_to: Option<Id>,
@ -28,10 +29,11 @@ pub struct EventRelated {
pub last_reply_at: Option<i64>, pub last_reply_at: Option<i64>,
} }
impl EventRelated { impl FeedEvent {
pub fn new(id: Id) -> EventRelated { pub fn new(id: Id) -> FeedEvent {
EventRelated { FeedEvent {
id, id,
event: None,
feed_related: false, feed_related: false,
replies: Vec::new(), replies: Vec::new(),
in_reply_to: None, in_reply_to: None,
@ -46,10 +48,11 @@ impl EventRelated {
} }
} }
impl From<&Event> for EventRelated { impl From<&Event> for FeedEvent {
fn from(event: &Event) -> EventRelated { fn from(event: &Event) -> FeedEvent {
EventRelated { FeedEvent {
id: event.id, id: event.id,
event: Some(event.to_owned()),
feed_related: event.kind == EventKind::TextNote, feed_related: event.kind == EventKind::TextNote,
replies: Vec::new(), replies: Vec::new(),
in_reply_to: None, in_reply_to: None,
@ -64,12 +67,13 @@ impl From<&Event> for EventRelated {
} }
} }
impl TryFrom<&DbEvent> for EventRelated { impl TryFrom<&DbEvent> for FeedEvent {
type Error = Error; type Error = Error;
fn try_from(dbevent: &DbEvent) -> Result<EventRelated, Error> { fn try_from(dbevent: &DbEvent) -> Result<FeedEvent, Error> {
Ok(EventRelated { Ok(FeedEvent {
id: dbevent.id.clone().try_into()?, id: dbevent.id.clone().try_into()?,
event: serde_json::from_str(&dbevent.raw)?,
feed_related: dbevent.kind == 1, feed_related: dbevent.kind == 1,
replies: Vec::new(), replies: Vec::new(),
in_reply_to: None, in_reply_to: None,

44
src/globals.rs
View File

@ -1,7 +1,7 @@
use crate::comms::BusMessage; use crate::comms::BusMessage;
use crate::db::{DbPerson, DbPersonRelay, DbRelay}; use crate::db::{DbPerson, DbPersonRelay, DbRelay};
use crate::error::Error; use crate::error::Error;
use crate::event_related::EventRelated; use crate::feed_event::FeedEvent;
use nostr_proto::{Event, EventKind, Id, Metadata, PublicKey, PublicKeyHex, Tag, Unixtime}; use nostr_proto::{Event, EventKind, Id, Metadata, PublicKey, PublicKeyHex, Tag, Unixtime};
use rusqlite::Connection; use rusqlite::Connection;
use std::collections::HashMap; use std::collections::HashMap;
@ -30,7 +30,7 @@ pub struct Globals {
pub events: Mutex<HashMap<Id, Event>>, pub events: Mutex<HashMap<Id, Event>>,
/// All nostr event related data, keyed by the event Id /// All nostr event related data, keyed by the event Id
pub event_relateds: Mutex<HashMap<Id, EventRelated>>, pub feed_events: Mutex<HashMap<Id, FeedEvent>>,
/// All nostr people records currently loaded into memory, keyed by pubkey /// All nostr people records currently loaded into memory, keyed by pubkey
pub people: Mutex<HashMap<PublicKey, DbPerson>>, pub people: Mutex<HashMap<PublicKey, DbPerson>>,
@ -55,7 +55,7 @@ lazy_static! {
to_overlord, to_overlord,
from_minions: Mutex::new(Some(from_minions)), from_minions: Mutex::new(Some(from_minions)),
events: Mutex::new(HashMap::new()), events: Mutex::new(HashMap::new()),
event_relateds: Mutex::new(HashMap::new()), feed_events: Mutex::new(HashMap::new()),
people: Mutex::new(HashMap::new()), people: Mutex::new(HashMap::new()),
need_password: AtomicBool::new(false), need_password: AtomicBool::new(false),
} }
@ -64,8 +64,8 @@ lazy_static! {
#[allow(dead_code)] #[allow(dead_code)]
pub async fn get_feed() -> Vec<Id> { pub async fn get_feed() -> Vec<Id> {
let mut feed: Vec<EventRelated> = GLOBALS let mut feed: Vec<FeedEvent> = GLOBALS
.event_relateds .feed_events
.lock() .lock()
.await .await
.iter() .iter()
@ -80,8 +80,8 @@ pub async fn get_feed() -> Vec<Id> {
#[allow(dead_code)] #[allow(dead_code)]
pub fn blocking_get_feed() -> Vec<Id> { pub fn blocking_get_feed() -> Vec<Id> {
let mut feed: Vec<EventRelated> = GLOBALS let mut feed: Vec<FeedEvent> = GLOBALS
.event_relateds .feed_events
.blocking_lock() .blocking_lock()
.iter() .iter()
.map(|(_, e)| e) .map(|(_, e)| e)
@ -113,13 +113,13 @@ pub async fn add_event(event: &Event) -> Result<(), Error> {
if let Some(m) = marker { if let Some(m) = marker {
if m == "reply" { if m == "reply" {
// Mark our 'in_reply_to' // Mark our 'in_reply_to'
update_event_related(event.id, |er| { update_feed_event(event.id, |er| {
er.in_reply_to = Some(*id); er.in_reply_to = Some(*id);
}) })
.await; .await;
// Add ourself to the parent's replies // Add ourself to the parent's replies
update_event_related(*id, |er| { update_feed_event(*id, |er| {
er.replies.push(event.id); er.replies.push(event.id);
}) })
.await; .await;
@ -128,7 +128,7 @@ pub async fn add_event(event: &Event) -> Result<(), Error> {
let mut xid = *id; let mut xid = *id;
loop { loop {
let mut in_reply_to: Option<Id> = None; let mut in_reply_to: Option<Id> = None;
update_event_related(xid, |er| { update_feed_event(xid, |er| {
if let Some(other) = er.last_reply_at { if let Some(other) = er.last_reply_at {
er.last_reply_at = Some(other.max(event.created_at.0)); er.last_reply_at = Some(other.max(event.created_at.0));
} else { } else {
@ -152,10 +152,10 @@ pub async fn add_event(event: &Event) -> Result<(), Error> {
if other_event.pubkey != event.pubkey { if other_event.pubkey != event.pubkey {
// Invalid delete event // Invalid delete event
GLOBALS.events.lock().await.remove(id); GLOBALS.events.lock().await.remove(id);
GLOBALS.event_relateds.lock().await.remove(id); GLOBALS.feed_events.lock().await.remove(id);
return Ok(()); return Ok(());
} }
update_event_related(*id, |er| { update_feed_event(*id, |er| {
er.deleted_reason = Some(event.content.clone()); er.deleted_reason = Some(event.content.clone());
}) })
.await; .await;
@ -174,20 +174,20 @@ pub async fn add_event(event: &Event) -> Result<(), Error> {
// For now we process these under specific event types. // For now we process these under specific event types.
} }
Tag::Hashtag(s) => { Tag::Hashtag(s) => {
update_event_related(event.id, |er| { update_feed_event(event.id, |er| {
er.hashtags.push(s.to_string()); er.hashtags.push(s.to_string());
}) })
.await; .await;
} }
Tag::Reference(r) => { Tag::Reference(r) => {
update_event_related(event.id, |er| { update_feed_event(event.id, |er| {
er.urls.push(r.to_string()); er.urls.push(r.to_string());
}) })
.await; .await;
} }
Tag::Geohash(_) => {} // not implemented Tag::Geohash(_) => {} // not implemented
Tag::Subject(s) => { Tag::Subject(s) => {
update_event_related(event.id, |er| { update_feed_event(event.id, |er| {
er.subject = Some(s.to_string()); er.subject = Some(s.to_string());
}) })
.await; .await;
@ -195,7 +195,7 @@ pub async fn add_event(event: &Event) -> Result<(), Error> {
Tag::Nonce { .. } => {} // not implemented Tag::Nonce { .. } => {} // not implemented
Tag::Other { tag, data } => { Tag::Other { tag, data } => {
if tag == "client" && !data.is_empty() { if tag == "client" && !data.is_empty() {
update_event_related(event.id, |er| { update_feed_event(event.id, |er| {
er.client = Some(data[0].to_string()); er.client = Some(data[0].to_string());
}) })
.await; .await;
@ -213,15 +213,15 @@ async fn insert_event(event: &Event) {
events.insert(event.id, event.clone()); events.insert(event.id, event.clone());
} }
async fn update_event_related<F>(id: Id, mut f: F) async fn update_feed_event<F>(id: Id, mut f: F)
where where
F: FnMut(&mut EventRelated), F: FnMut(&mut FeedEvent),
{ {
let mut event_relateds = GLOBALS.event_relateds.lock().await; let mut feed_events = GLOBALS.feed_events.lock().await;
let event_related = event_relateds let feed_event = feed_events
.entry(id) .entry(id)
.or_insert_with(|| EventRelated::new(id)); .or_insert_with(|| FeedEvent::new(id));
f(event_related); f(feed_event);
} }
pub async fn update_person_from_event_metadata( pub async fn update_person_from_event_metadata(

2
src/main.rs
View File

@ -8,7 +8,7 @@ mod comms;
mod date_ago; mod date_ago;
mod db; mod db;
mod error; mod error;
mod event_related; mod feed_event;
mod globals; mod globals;
mod overlord; mod overlord;
mod settings; mod settings;