- add: ability to refresh the current session

- add: delete type to delete character request
- add: ability to update key in redis
- add: handle alive packet to refresh the session
- fix: delete now actually returns the time remaining correctly
- fix: character list now has the correct time until character deletion

utils/src/redis_cache.rs

@@ -1,6 +1,6 @@
 use async_trait::async_trait;
 use deadpool_redis::{Config, Pool, Runtime};
-use redis::{AsyncCommands, RedisError};
+use redis::{AsyncCommands, Commands, RedisError};
 use serde::{Deserialize, Serialize};
 
 #[async_trait]
@@ -12,6 +12,13 @@ pub trait Cache {
         ttl: u64,
     ) -> Result<(), redis::RedisError>;
 
+    async fn update<T: Serialize + Send + Sync>(
+        &self,
+        key: &String,
+        value: Option<&T>,
+        ttl: Option<u64>,
+    ) -> Result<(), redis::RedisError>;
+
     async fn get<T: for<'de> serde::Deserialize<'de> + Send + Sync>(
         &self,
         key: &String,
@@ -83,6 +90,38 @@ impl Cache for RedisCache {
         }
     }
 
+    async fn update<T: Serialize + Send + Sync>(
+        &self,
+        key: &String,
+        value: Option<&T>,
+        ttl: Option<u64>,
+    ) -> Result<(), redis::RedisError> {
+        let mut conn = self.pool.get().await
+            .map_err(|err| {
+                redis::RedisError::from((
+                    redis::ErrorKind::IoError,
+                    "Failed to get Redis connection",
+                    format!("{:?}", err),
+                ))
+            })?;
+        let serialized_value;
+        if value.is_some() {
+            serialized_value = serde_json::to_string(&value)
+                .map_err(|err| RedisError::from((
+                    redis::ErrorKind::IoError,
+                    "Serialization error",
+                    format!("Serialization error: {}", err),
+                )))?;
+        } else {
+            serialized_value = conn.get(key).await?;
+        }
+        if ttl != None {
+            conn.set_ex(key, serialized_value, ttl.unwrap()).await
+        } else {
+            conn.set(key, serialized_value).await
+        }
+    }
+
     async fn delete(&mut self, key: &str) -> redis::RedisResult<()> {
         let mut conn = self.pool.get().await
             .map_err(|err| {