Make non-essential dev messages show up way less often

rc_core/src/persist/config/traits.rs

@@ -70,10 +70,7 @@ impl <C: Clone> DevMessageProvider<C> {
     pub fn get(&self, index: usize) -> TypedDevMessage<C> {
         // TODO maybe make this less obtuse -- it works for random, but isn't really obvious for anything else
         if self.messages.is_empty() {
-            TypedDevMessage {
-                message: Typed::Bytes(Vec::default().into()),
-                display_time: Typed::Int(-1),
-            }
+            self.get_empty()
         } else if self.messages.len() == 1 {
             self.messages[0].clone()
         } else {
@@ -81,6 +78,13 @@ impl <C: Clone> DevMessageProvider<C> {
             self.messages[actual_index].clone()
         }
     }
+
+    pub fn get_empty(&self) -> TypedDevMessage<C> {
+        TypedDevMessage {
+            message: Typed::Bytes(Vec::default().into()),
+            display_time: Typed::Int(-1),
+        }
+    }
 }
 
 #[derive(Clone, Debug)]

rc_core/src/persist/user/account_json.rs

@@ -492,4 +492,38 @@ impl <C: Clone> super::User<C> for UserData {
             colour_data: slot.colour_data,
         })
     }
+
+    async fn last_seen(&self) -> Result<u64, i16> {
+        let last_seen_aux_opt = self.db.user_aux_by_user_id_and_descriptor(self.account.id, rc_database::schema::user_aux::Descriptor::LastSeen).await
+            .map_err(|e| {
+                log::error!("Failed to retrieve LastSeen (user_aux) for user_id {}: {}", self.account.id, e);
+                DATABASE_ERR
+            })?;
+        let now = chrono::Utc::now().timestamp();
+        if let Some(last_seen) = last_seen_aux_opt {
+            let to_update = rc_database::schema::user_aux::ActiveModel {
+                data: rc_database::sea_orm::ActiveValue::Set((now as u64).to_string()),
+                ..Default::default()
+            };
+            self.db.update_user_aux_by_user_id_and_descriptor(to_update, self.account.id, rc_database::schema::user_aux::Descriptor::LastSeen).await
+                .map_err(|e| {
+                    log::error!("Failed to update LastSeen (user_aux) for user_id {}: {}", self.account.id, e);
+                    DATABASE_ERR
+                })?;
+            Ok(last_seen.data.parse().unwrap_or_default())
+        } else {
+            let to_insert = rc_database::schema::user_aux::ActiveModel {
+                user_id: rc_database::sea_orm::ActiveValue::Set(self.account.id),
+                creation_time: rc_database::sea_orm::ActiveValue::Set(now),
+                descriptor: rc_database::sea_orm::ActiveValue::Set(rc_database::schema::user_aux::Descriptor::LastSeen),
+                data: rc_database::sea_orm::ActiveValue::Set((now as u64).to_string()),
+                ..Default::default()
+            };
+            self.db.insert_user_aux(vec![to_insert]).await.map_err(|e| {
+                log::error!("Failed to insert LastSeen (user_aux) for user_id {}: {}", self.account.id, e);
+                DATABASE_ERR
+            })?;
+            Ok(0)
+        }
+    }
 }

rc_core/src/persist/user/traits.rs

@@ -72,6 +72,7 @@ pub trait User<C> {
     fn signup_date(&self) -> i64;
     async fn singleplayer_robots(&self) -> Result<polariton::operation::Typed<C>, i16>;
     async fn prepare_factory_upload(&self, vehicle: VehicleUploadData) -> Result<rc_factory::VehicleUploadInfo, i16>;
+    async fn last_seen(&self) -> Result<u64, i16>;
 }
 
 pub struct UserSlots<C> {

rc_database/src/schema/user_aux.rs

@@ -40,4 +40,5 @@ pub enum Descriptor {
     UserFreeCurrency, // u64
     UserPaidCurrency, // u64
     GarageSlotOrder, // Vec<u32>,
+    LastSeen, // u64, seconds since Unix epoch
 }

rc_services_room/src/operations/dev_message.rs

@@ -2,6 +2,10 @@ use polariton_server::operations::{Operation, OperationCode};
 use rand::Rng;
 use rc_core::ConfigProvider;
 
+const MAX_DELTA: u64 = 60 * 60 * 24; // 1 day
+
+const CODE: u8 = 8;
+
 const MESSAGE_PARAM_KEY: u8 = 2;
 const DISPLAY_TIME_PARAM_KEY: u8 = 15;
 
@@ -9,27 +13,39 @@ pub struct DevMessageProvider<C: Clone> {
     messages: rc_core::persist::config::DevMessageProvider<C>,
 }
 
+impl <C: Clone> DevMessageProvider<C> {
+    async fn do_handling(&self, params: polariton::operation::ParameterTable<C>, user: &crate::UserTy) -> Result<polariton::operation::ParameterTable<C>, i16> {
+        let mut params = params.to_dict();
+        let user_info = user.user()?;
+        let last_seen = user_info.last_seen().await?;
+        let now = chrono::Utc::now().timestamp() as u64;
+        if (now - last_seen) > MAX_DELTA {
+            let index = rand::rng().random::<u32>();
+            let dev_msg = self.messages.get(index as _);
+            params.insert(MESSAGE_PARAM_KEY, dev_msg.message);
+            params.insert(DISPLAY_TIME_PARAM_KEY, dev_msg.display_time);
+        } else {
+            let dev_msg = self.messages.get_empty();
+            params.insert(MESSAGE_PARAM_KEY, dev_msg.message);
+            params.insert(DISPLAY_TIME_PARAM_KEY, dev_msg.display_time);
+        }
+
+        Ok(params.into())
+    }
+}
+
+#[async_trait::async_trait]
 impl <C: Clone + Send + Sync + 'static> Operation<C> for DevMessageProvider<C> {
     type User = crate::UserTy;
 
-    fn handle(&self, params: polariton::operation::ParameterTable<C>, _user: &Self::User) -> polariton::operation::OperationResponse<C> {
-        let mut params = params.to_dict();
-        let index = rand::rng().random::<u32>();
-        let dev_msg = self.messages.get(index as _);
-        params.insert(MESSAGE_PARAM_KEY, dev_msg.message);
-        params.insert(DISPLAY_TIME_PARAM_KEY, dev_msg.display_time);
-        polariton::operation::OperationResponse {
-            code: Self::op_code(),
-            return_code: 0,
-            message: polariton::operation::Typed::Null,
-            params: params.into(),
-        }
+    async fn handle_async(&self, params: polariton::operation::ParameterTable<C>, user: &Self::User) -> polariton::operation::OperationResponse<C> {
+        polariton_server::operations::result_to_op_resp::<CODE, C>(self.do_handling(params, user).await)
     }
 }
 
 impl <C: Clone> OperationCode for DevMessageProvider<C> {
     fn op_code() -> u8 {
-        8
+        CODE
     }
 }