2022-12-25 21:40:42 +00:00
|
|
|
use crate::db::{
|
2022-12-30 18:37:20 +00:00
|
|
|
DbEvent, DbEventHashtag, DbEventRelationship, DbEventSeen, DbEventTag, DbPersonRelay, DbRelay,
|
2022-12-25 21:40:42 +00:00
|
|
|
};
|
2022-12-24 01:02:24 +00:00
|
|
|
use crate::error::Error;
|
|
|
|
use crate::globals::{Globals, GLOBALS};
|
|
|
|
use crate::relationship::Relationship;
|
2022-12-25 21:40:42 +00:00
|
|
|
use nostr_types::{Event, EventKind, Metadata, Tag, Unixtime, Url};
|
2022-12-24 01:02:24 +00:00
|
|
|
|
|
|
|
// This processes a new event, saving the results into the database
|
|
|
|
// and also populating the GLOBALS maps.
|
2022-12-24 02:39:40 +00:00
|
|
|
pub async fn process_new_event(
|
|
|
|
event: &Event,
|
|
|
|
from_relay: bool,
|
|
|
|
seen_on: Option<Url>,
|
2023-01-05 17:56:23 +00:00
|
|
|
_subscription: Option<String>,
|
2022-12-24 02:39:40 +00:00
|
|
|
) -> Result<(), Error> {
|
2022-12-24 01:02:24 +00:00
|
|
|
// Save the event into the database
|
|
|
|
if from_relay {
|
|
|
|
// Convert a nostr Event into a DbEvent
|
|
|
|
let db_event = DbEvent {
|
|
|
|
id: event.id.into(),
|
|
|
|
raw: serde_json::to_string(&event)?,
|
|
|
|
pubkey: event.pubkey.into(),
|
|
|
|
created_at: event.created_at.0,
|
|
|
|
kind: event.kind.into(),
|
|
|
|
content: event.content.clone(),
|
|
|
|
ots: event.ots.clone(),
|
|
|
|
};
|
|
|
|
|
|
|
|
// Save into event table
|
|
|
|
DbEvent::insert(db_event).await?;
|
|
|
|
}
|
|
|
|
|
|
|
|
if from_relay {
|
|
|
|
if let Some(url) = seen_on {
|
2022-12-25 21:40:42 +00:00
|
|
|
let now = Unixtime::now()?.0 as u64;
|
|
|
|
|
|
|
|
// Save event_seen data
|
2022-12-24 01:02:24 +00:00
|
|
|
let db_event_seen = DbEventSeen {
|
|
|
|
event: event.id.as_hex_string(),
|
2022-12-28 19:39:43 +00:00
|
|
|
relay: url.inner().to_owned(),
|
2022-12-25 21:40:42 +00:00
|
|
|
when_seen: now,
|
2022-12-24 01:02:24 +00:00
|
|
|
};
|
|
|
|
DbEventSeen::replace(db_event_seen).await?;
|
2022-12-25 21:40:42 +00:00
|
|
|
|
2022-12-30 09:22:19 +00:00
|
|
|
// Create the person if missing in the database
|
2022-12-30 18:37:20 +00:00
|
|
|
GLOBALS
|
2022-12-30 09:22:19 +00:00
|
|
|
.people
|
|
|
|
.write()
|
|
|
|
.await
|
2022-12-31 02:25:04 +00:00
|
|
|
.create_if_missing(&event.pubkey.into())
|
2022-12-30 18:37:20 +00:00
|
|
|
.await?;
|
2022-12-30 09:22:19 +00:00
|
|
|
|
2022-12-25 21:40:42 +00:00
|
|
|
// Update person_relay.last_fetched
|
2022-12-28 19:39:43 +00:00
|
|
|
DbPersonRelay::upsert_last_fetched(
|
|
|
|
event.pubkey.as_hex_string(),
|
|
|
|
url.inner().to_owned(),
|
|
|
|
now,
|
|
|
|
)
|
|
|
|
.await?;
|
2022-12-24 01:02:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Insert the event into globals map
|
2023-01-06 18:55:17 +00:00
|
|
|
GLOBALS.events.insert(event.id, event.clone());
|
2022-12-24 01:02:24 +00:00
|
|
|
|
|
|
|
// Save the tags into event_tag table
|
|
|
|
if from_relay {
|
|
|
|
for (seq, tag) in event.tags.iter().enumerate() {
|
2022-12-25 21:40:42 +00:00
|
|
|
// Save into database
|
|
|
|
{
|
|
|
|
// convert to vec of strings
|
|
|
|
let v: Vec<String> = serde_json::from_str(&serde_json::to_string(&tag)?)?;
|
2022-12-24 01:02:24 +00:00
|
|
|
|
2022-12-25 21:40:42 +00:00
|
|
|
let db_event_tag = DbEventTag {
|
|
|
|
event: event.id.as_hex_string(),
|
|
|
|
seq: seq as u64,
|
|
|
|
label: v.get(0).cloned(),
|
|
|
|
field0: v.get(1).cloned(),
|
|
|
|
field1: v.get(2).cloned(),
|
|
|
|
field2: v.get(3).cloned(),
|
|
|
|
field3: v.get(4).cloned(),
|
|
|
|
};
|
|
|
|
DbEventTag::insert(db_event_tag).await?;
|
|
|
|
}
|
|
|
|
|
|
|
|
match tag {
|
|
|
|
Tag::Event {
|
|
|
|
id: _,
|
|
|
|
recommended_relay_url: Some(should_be_url),
|
|
|
|
marker: _,
|
|
|
|
} => {
|
2022-12-28 19:39:43 +00:00
|
|
|
let url = Url::new(should_be_url);
|
2022-12-31 07:50:00 +00:00
|
|
|
if url.is_valid_relay_url() {
|
2022-12-25 21:40:42 +00:00
|
|
|
// Insert (or ignore) into relays table
|
2022-12-28 19:39:43 +00:00
|
|
|
let dbrelay = DbRelay::new(url.inner().to_owned())?;
|
2022-12-25 21:40:42 +00:00
|
|
|
DbRelay::insert(dbrelay).await?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Tag::Pubkey {
|
|
|
|
pubkey,
|
|
|
|
recommended_relay_url: Some(should_be_url),
|
|
|
|
petname: _,
|
|
|
|
} => {
|
2022-12-28 19:39:43 +00:00
|
|
|
let url = Url::new(should_be_url);
|
2022-12-31 07:50:00 +00:00
|
|
|
if url.is_valid_relay_url() {
|
2022-12-25 21:40:42 +00:00
|
|
|
// Insert (or ignore) into relays table
|
2022-12-28 19:39:43 +00:00
|
|
|
let dbrelay = DbRelay::new(url.inner().to_owned())?;
|
2022-12-25 21:40:42 +00:00
|
|
|
DbRelay::insert(dbrelay).await?;
|
|
|
|
|
|
|
|
// upsert person_relay.last_suggested_bytag
|
|
|
|
let now = Unixtime::now()?.0 as u64;
|
|
|
|
DbPersonRelay::upsert_last_suggested_bytag(
|
|
|
|
pubkey.as_hex_string(),
|
2022-12-28 19:39:43 +00:00
|
|
|
url.inner().to_owned(),
|
2022-12-25 21:40:42 +00:00
|
|
|
now,
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => {}
|
|
|
|
}
|
2022-12-24 01:02:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Save event relationships
|
|
|
|
{
|
|
|
|
// replies to
|
2022-12-26 08:33:26 +00:00
|
|
|
if let Some((id, _)) = event.replies_to() {
|
2022-12-24 01:02:24 +00:00
|
|
|
if from_relay {
|
|
|
|
let db_event_relationship = DbEventRelationship {
|
|
|
|
original: event.id.as_hex_string(),
|
|
|
|
referring: id.as_hex_string(),
|
|
|
|
relationship: "reply".to_string(),
|
|
|
|
content: None,
|
|
|
|
};
|
|
|
|
db_event_relationship.insert().await?;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Insert into relationships
|
|
|
|
Globals::add_relationship(id, event.id, Relationship::Reply).await;
|
|
|
|
}
|
|
|
|
|
2022-12-26 08:33:26 +00:00
|
|
|
// We desire all ancestors
|
|
|
|
for (id, maybe_url) in event.replies_to_ancestors() {
|
|
|
|
// Insert desired event if relevant
|
2023-01-06 18:55:17 +00:00
|
|
|
if !GLOBALS.events.contains_key(&id) {
|
2022-12-26 08:33:26 +00:00
|
|
|
Globals::store_desired_event(id, maybe_url).await;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-24 01:02:24 +00:00
|
|
|
// reacts to
|
|
|
|
if let Some((id, reaction, maybe_url)) = event.reacts_to() {
|
|
|
|
if from_relay {
|
|
|
|
let db_event_relationship = DbEventRelationship {
|
|
|
|
original: event.id.as_hex_string(),
|
|
|
|
referring: id.as_hex_string(),
|
|
|
|
relationship: "reaction".to_string(),
|
|
|
|
content: Some(reaction.clone()),
|
|
|
|
};
|
|
|
|
db_event_relationship.insert().await?;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Insert desired event if relevant
|
2023-01-06 18:55:17 +00:00
|
|
|
if !GLOBALS.events.contains_key(&id) {
|
2022-12-24 01:02:24 +00:00
|
|
|
Globals::store_desired_event(id, maybe_url).await;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Insert into relationships
|
|
|
|
Globals::add_relationship(id, event.id, Relationship::Reaction(reaction)).await;
|
|
|
|
}
|
|
|
|
|
|
|
|
// deletes
|
|
|
|
if let Some((ids, reason)) = event.deletes() {
|
|
|
|
for id in ids {
|
|
|
|
if from_relay {
|
|
|
|
let db_event_relationship = DbEventRelationship {
|
|
|
|
original: event.id.as_hex_string(),
|
|
|
|
referring: id.as_hex_string(),
|
|
|
|
relationship: "deletion".to_string(),
|
|
|
|
content: Some(reason.clone()),
|
|
|
|
// FIXME: this table should have one more column for optional data
|
|
|
|
};
|
|
|
|
db_event_relationship.insert().await?;
|
|
|
|
}
|
|
|
|
|
|
|
|
// since it is a delete, we don't actually desire the event.
|
|
|
|
|
|
|
|
// Insert into relationships
|
|
|
|
Globals::add_relationship(id, event.id, Relationship::Deletion(reason.clone()))
|
|
|
|
.await;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Save event_hashtags
|
|
|
|
if from_relay {
|
|
|
|
let hashtags = event.hashtags();
|
|
|
|
for hashtag in hashtags {
|
|
|
|
let db_event_hashtag = DbEventHashtag {
|
|
|
|
event: event.id.as_hex_string(),
|
|
|
|
hashtag: hashtag.clone(),
|
|
|
|
};
|
|
|
|
db_event_hashtag.insert().await?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If metadata, update person
|
|
|
|
if event.kind == EventKind::Metadata {
|
|
|
|
let metadata: Metadata = serde_json::from_str(&event.content)?;
|
|
|
|
|
2022-12-30 18:37:20 +00:00
|
|
|
GLOBALS
|
|
|
|
.people
|
|
|
|
.write()
|
|
|
|
.await
|
2022-12-31 02:25:04 +00:00
|
|
|
.update_metadata(&event.pubkey.into(), metadata, event.created_at)
|
2022-12-30 18:37:20 +00:00
|
|
|
.await?;
|
2022-12-24 01:02:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: Handle EventKind::RecommendedRelay
|
|
|
|
|
|
|
|
// FIXME: Handle EventKind::ContactList
|
|
|
|
|
2022-12-30 03:37:59 +00:00
|
|
|
// Save in event_is_new
|
|
|
|
GLOBALS.event_is_new.write().await.push(event.id);
|
|
|
|
|
2022-12-24 01:02:24 +00:00
|
|
|
Ok(())
|
|
|
|
}
|