Update more data on event processing

src/db/person_relay.rs

@@ -164,6 +164,55 @@ impl DbPersonRelay {
         Ok(())
     }
 
+    pub async fn upsert_last_fetched(
+        person: String,
+        relay: String,
+        last_fetched: u64,
+    ) -> Result<(), Error> {
+        let sql = "INSERT INTO person_relay (person, relay, last_fetched) \
+                   VALUES (?, ?, ?) \
+                   ON CONFLICT(person, relay) DO UPDATE SET last_fetched=?";
+
+        spawn_blocking(move || {
+            let maybe_db = GLOBALS.db.blocking_lock();
+            let db = maybe_db.as_ref().unwrap();
+
+            let mut stmt = db.prepare(sql)?;
+            stmt.execute((&person, &relay, &last_fetched, &last_fetched))?;
+            Ok::<(), Error>(())
+        })
+        .await??;
+
+        Ok(())
+    }
+
+    pub async fn upsert_last_suggested_bytag(
+        person: String,
+        relay: String,
+        last_suggested_bytag: u64,
+    ) -> Result<(), Error> {
+        let sql = "INSERT INTO person_relay (person, relay, last_suggested_bytag) \
+                   VALUES (?, ?, ?) \
+                   ON CONFLICT(person, relay) DO UPDATE SET last_suggested_bytag=?";
+
+        spawn_blocking(move || {
+            let maybe_db = GLOBALS.db.blocking_lock();
+            let db = maybe_db.as_ref().unwrap();
+
+            let mut stmt = db.prepare(sql)?;
+            stmt.execute((
+                &person,
+                &relay,
+                &last_suggested_bytag,
+                &last_suggested_bytag,
+            ))?;
+            Ok::<(), Error>(())
+        })
+        .await??;
+
+        Ok(())
+    }
+
     #[allow(dead_code)]
     pub async fn delete(criteria: &str) -> Result<(), Error> {
         let sql = format!("DELETE FROM person_relay WHERE {}", criteria);

src/process.rs

@@ -1,8 +1,11 @@
-use crate::db::{DbEvent, DbEventHashtag, DbEventRelationship, DbEventSeen, DbEventTag, DbPerson};
+use crate::db::{
+    DbEvent, DbEventHashtag, DbEventRelationship, DbEventSeen, DbEventTag, DbPerson, DbPersonRelay,
+    DbRelay,
+};
 use crate::error::Error;
 use crate::globals::{Globals, GLOBALS};
 use crate::relationship::Relationship;
-use nostr_types::{Event, EventKind, Metadata, Unixtime, Url};
+use nostr_types::{Event, EventKind, Metadata, Tag, Unixtime, Url};
 
 // This processes a new event, saving the results into the database
 // and also populating the GLOBALS maps.
@@ -28,15 +31,20 @@ pub async fn process_new_event(
         DbEvent::insert(db_event).await?;
     }
 
-    // Save event_seen data
     if from_relay {
         if let Some(url) = seen_on {
+            let now = Unixtime::now()?.0 as u64;
+
+            // Save event_seen data
             let db_event_seen = DbEventSeen {
                 event: event.id.as_hex_string(),
-                relay: url.0,
-                when_seen: Unixtime::now()?.0 as u64,
+                relay: url.0.clone(),
+                when_seen: now,
             };
             DbEventSeen::replace(db_event_seen).await?;
+
+            // Update person_relay.last_fetched
+            DbPersonRelay::upsert_last_fetched(event.pubkey.as_hex_string(), url.0, now).await?;
         }
     }
 
@@ -49,6 +57,8 @@ pub async fn process_new_event(
     // Save the tags into event_tag table
     if from_relay {
         for (seq, tag) in event.tags.iter().enumerate() {
+            // Save into database
+            {
                 // convert to vec of strings
                 let v: Vec<String> = serde_json::from_str(&serde_json::to_string(&tag)?)?;
 
@@ -63,6 +73,42 @@ pub async fn process_new_event(
                 };
                 DbEventTag::insert(db_event_tag).await?;
             }
+
+            match tag {
+                Tag::Event {
+                    id: _,
+                    recommended_relay_url: Some(should_be_url),
+                    marker: _,
+                } => {
+                    if let Ok(url) = Url::new_validated(should_be_url) {
+                        // Insert (or ignore) into relays table
+                        let dbrelay = DbRelay::new(url.0.clone());
+                        DbRelay::insert(dbrelay).await?;
+                    }
+                }
+                Tag::Pubkey {
+                    pubkey,
+                    recommended_relay_url: Some(should_be_url),
+                    petname: _,
+                } => {
+                    if let Ok(url) = Url::new_validated(should_be_url) {
+                        // Insert (or ignore) into relays table
+                        let dbrelay = DbRelay::new(url.0.clone());
+                        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(),
+                            url.0.clone(),
+                            now,
+                        )
+                        .await?;
+                    }
+                }
+                _ => {}
+            }
+        }
     }
 
     // Save event relationships