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,
+                relay: url.0.clone(),
-                when_seen: Unixtime::now()?.0 as u64,
+                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,19 +57,57 @@ pub async fn process_new_event(
     // Save the tags into event_tag table
     if from_relay {
         for (seq, tag) in event.tags.iter().enumerate() {
-            // convert to vec of strings
+            // Save into database
-            let v: Vec<String> = serde_json::from_str(&serde_json::to_string(&tag)?)?;
+            {
+                // convert to vec of strings
+                let v: Vec<String> = serde_json::from_str(&serde_json::to_string(&tag)?)?;
 
-            let db_event_tag = DbEventTag {
+                let db_event_tag = DbEventTag {
-                event: event.id.as_hex_string(),
+                    event: event.id.as_hex_string(),
-                seq: seq as u64,
+                    seq: seq as u64,
-                label: v.get(0).cloned(),
+                    label: v.get(0).cloned(),
-                field0: v.get(1).cloned(),
+                    field0: v.get(1).cloned(),
-                field1: v.get(2).cloned(),
+                    field1: v.get(2).cloned(),
-                field2: v.get(3).cloned(),
+                    field2: v.get(3).cloned(),
-                field3: v.get(4).cloned(),
+                    field3: v.get(4).cloned(),
-            };
+                };
-            DbEventTag::insert(db_event_tag).await?;
+                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?;
+                    }
+                }
+                _ => {}
+            }
         }
     }