- 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

auth-service/src/grpc.rs

@@ -9,7 +9,7 @@ use crate::users::{hash_password, verify_user};
 use chrono::{Duration, Utc};
 use rand::Rng;
 use tonic::{Request, Response, Status};
-use tracing::{error, info, warn};
+use tracing::{debug, error, info, warn};
 
 pub struct MyAuthService {
     pub db_client: Arc<DatabaseClient>,
@@ -105,11 +105,35 @@ impl AuthService for MyAuthService {
 
         match response {
             Ok(res) => {
-                println!("Session valid: {:?}", res.into_inner());
+                debug!("Session valid: {:?}", res.into_inner());
                 Ok(Response::new(ValidateSessionResponse { valid: true }))
             }
             Err(_) => {
-                println!("Session invalid or not found");
+                debug!("Session invalid or not found");
+                Ok(Response::new(ValidateSessionResponse { valid: false }))
+            }
+        }
+    }
+
+    async fn refresh_session(
+        &self,
+        request: Request<ValidateSessionRequest>,
+    ) -> Result<Response<ValidateSessionResponse>, Status> {
+        let req = request.into_inner();
+        let response = self
+            .session_client.as_ref().clone()
+            .refresh_session(GetSessionRequest {
+                session_id: req.session_id,
+            })
+            .await;
+
+        match response {
+            Ok(res) => {
+                debug!("Session valid: {:?}", res.into_inner());
+                Ok(Response::new(ValidateSessionResponse { valid: true }))
+            }
+            Err(_) => {
+                debug!("Session invalid or not found");
                 Ok(Response::new(ValidateSessionResponse { valid: false }))
             }
         }

character-service/src/character_db_client.rs

@@ -161,10 +161,11 @@ impl CharacterDbClient {
         Ok(response.into_inner())
     }
 
-    pub async fn delete_character(&mut self, user_id: &str, char_id: &str) -> Result<DeleteCharacterResponse, Box<dyn std::error::Error>> {
+    pub async fn delete_character(&mut self, user_id: &str, char_id: &str, delete_type: i32) -> Result<DeleteCharacterResponse, Box<dyn std::error::Error>> {
         let request = tonic::Request::new(DeleteCharacterRequest {
             user_id: user_id.parse().unwrap(),
             character_id: char_id.parse().unwrap(),
+            delete_type,
         });
         let response = self.client.delete_character(request).await?;
         Ok(response.into_inner())

character-service/src/character_service.rs

@@ -38,7 +38,7 @@ impl CharacterService for MyCharacterService {
                     character_id: character.id.to_string(),
                     name: character.name,
                     last_played: 0,
-                    delete_time: 0,
+                    delete_time: character.deleted_at.parse().unwrap_or_default(),
                     stats: serde_json::from_str(&character.stats).unwrap(),
                     looks: serde_json::from_str(&character.looks).unwrap(),
                     items: serde_json::from_str(&character.inventory).unwrap(),
@@ -66,7 +66,7 @@ impl CharacterService for MyCharacterService {
         let req = request.into_inner();
         debug!("{:?}", req);
 
-        let delete_character_response = self.character_db_client.as_ref().clone().delete_character(&req.user_id, &req.char_id).await.map_err(|_| Status::not_found("Character not found"))?;
+        let delete_character_response = self.character_db_client.as_ref().clone().delete_character(&req.user_id, &req.char_id, req.delete_type).await.map_err(|_| Status::not_found("Character not found"))?;
         let response = DeleteCharacterResponse { remaining_time: delete_character_response.remaining_time, name: delete_character_response.name };
         Ok(Response::new(response))
     }

database-service/src/characters.rs

@@ -15,7 +15,7 @@ pub struct Character {
     pub position: serde_json::Value,
     pub created_at: chrono::NaiveDateTime,
     pub updated_at: chrono::NaiveDateTime,
-    pub deleted_at: Option<chrono::NaiveDateTime>,
+    pub deleted_at: Option<i64>,
     pub is_active: bool,
 }
 
@@ -40,7 +40,7 @@ impl CharacterRepository {
         // Fetch from database
         let character = sqlx::query_as::<_, Character>(
             "SELECT id, user_id, name, inventory, stats, looks, position, \
-                    created_at, updated_at, deleted_at, is_active \
+                    created_at, updated_at, extract(epoch from (deleted_at - now()))::BIGINT as deleted_at, is_active \
              FROM characters WHERE id = $1 AND is_active = true",
         )
             .bind(character_id)
@@ -72,9 +72,13 @@ impl CharacterRepository {
         Ok(result.get("id"))
     }
 
-    pub async fn delete_character(&self, character_id: i32) -> Result<(), sqlx::Error> {
+    pub async fn delete_character(&self, character_id: i32, delete_type: i32) -> Result<i64, sqlx::Error> {
+        let mut query = "UPDATE characters SET updated_at = NOW(), deleted_at = NOW() + '24 hours' WHERE id = $1 RETURNING user_id, extract(epoch from (deleted_at - now()))::BIGINT as deleted_at"; 
+        if 0 == delete_type {
+            query = "UPDATE characters SET updated_at = NOW(), deleted_at = null WHERE id = $1 RETURNING user_id, 0::BIGINT as deleted_at";
+        }
         let result = sqlx::query(
-            "UPDATE characters SET deleted_at = NOW(), is_active = false WHERE id = $1 RETURNING user_id",
+            query,
         )
             .bind(character_id)
             .fetch_one(&self.pool)
@@ -85,7 +89,7 @@ impl CharacterRepository {
         self.cache.lock().await.delete(&cache_key).await.map_err(|_| sqlx::Error::RowNotFound)?;
         let cache_key = format!("character:{}", character_id);
         self.cache.lock().await.delete(&cache_key).await.map_err(|_| sqlx::Error::RowNotFound)?;
-        Ok(())
+        Ok(result.get::<i64, &str>("deleted_at"))
     }
 
     pub async fn get_characters_by_user(&self, user_id: i32) -> Result<Vec<Character>, sqlx::Error> {
@@ -98,9 +102,7 @@ impl CharacterRepository {
 
         // Fetch from database
         let characters = sqlx::query_as::<_, Character>(
-            "SELECT id, user_id, name, inventory, stats, looks, position, \
+            "SELECT id, user_id, name, inventory, stats, looks, position, created_at, updated_at, extract(epoch from (deleted_at - now()))::BIGINT as deleted_at, is_active FROM characters WHERE user_id = $1 AND is_active = true",
-                    created_at, updated_at, deleted_at, is_active \
-             FROM characters WHERE user_id = $1 AND is_active = true",
         )
             .bind(user_id)
             .fetch_all(&self.pool)

database-service/src/grpc/character_service.rs

@@ -1,3 +1,4 @@
+use serde_json::Value::Null;
 use crate::grpc::{Character, CharacterRequest, CharacterListRequest, CharacterListResponse, CreateCharacterRequest, CreateCharacterResponse, DeleteCharacterRequest, DeleteCharacterResponse, Empty};
 use crate::grpc::character_service_server::CharacterService;
 use crate::grpc::database_service::MyDatabaseService;
@@ -17,6 +18,11 @@ impl CharacterService for MyDatabaseService {
             .await
             .map_err(|_| Status::not_found("Character not found"))?;
 
+        let mut deleted_at= "".to_string();
+        if character.deleted_at.is_some() {
+            deleted_at = character.deleted_at.unwrap().to_string();
+        }
+        
         let response = Character {
             id: character.id,
             user_id: character.user_id,
@@ -27,6 +33,7 @@ impl CharacterService for MyDatabaseService {
             position: character.position.to_string(),
             created_at: character.created_at.to_string(),
             updated_at: character.updated_at.to_string(),
+            deleted_at,
             is_active: character.is_active,
         };
 
@@ -46,8 +53,13 @@ impl CharacterService for MyDatabaseService {
             .map_err(|_| Status::not_found("Character not found"))?;
         
         let mut character_list: Vec<Character> = Vec::new();
+
         
         for character in characters {
+            let mut deleted_at= "".to_string();
+            if character.deleted_at.is_some() {
+                deleted_at = character.deleted_at.unwrap_or_default().to_string();
+            }
             let character = Character {
                 id: character.id,
                 user_id: character.user_id,
@@ -58,6 +70,7 @@ impl CharacterService for MyDatabaseService {
                 position: character.position.to_string(),
                 created_at: character.created_at.to_string(),
                 updated_at: character.updated_at.to_string(),
+                deleted_at,
                 is_active: character.is_active,
             };
             character_list.push(character);
@@ -111,12 +124,12 @@ impl CharacterService for MyDatabaseService {
         let req = request.into_inner();
         let repo = &self.db.character_repo;
 
-        repo.delete_character(req.character_id)
+        let time_left_in_seconds = repo.delete_character(req.character_id, req.delete_type)
             .await
             .map_err(|_| Status::internal("Failed to delete character"))?;
 
         let response = DeleteCharacterResponse {
-            remaining_time: 0,
+            remaining_time: time_left_in_seconds,
             name: "".to_string(),
         };
         Ok(Response::new(response))

packet-service/src/auth_client.rs

@@ -42,6 +42,15 @@ impl AuthClient {
         Ok(response.into_inner())
     }
 
+    pub async fn refresh_session(&mut self, session_id: &str) -> Result<ValidateSessionResponse, Box<dyn std::error::Error + Send + Sync>> {
+        let request = ValidateSessionRequest {
+            session_id: session_id.to_string()
+        };
+
+        let response = self.client.refresh_session(request).await?;
+        Ok(response.into_inner())
+    }
+
     pub async fn logout(&mut self, session_id: &str) -> Result<Empty, Box<dyn std::error::Error + Send + Sync>> {
         let request = LogoutRequest {
             session_id: session_id.to_string(),

packet-service/src/character_client.rs

@@ -37,10 +37,11 @@ impl CharacterClient {
         Ok(response.into_inner())
     }
 
-    pub async fn delete_character(&mut self, user_id: &str, char_id: &str) -> Result<DeleteCharacterResponse, Box<dyn std::error::Error + Send + Sync>> {
+    pub async fn delete_character(&mut self, user_id: &str, char_id: &str, delete_type: i32) -> Result<DeleteCharacterResponse, Box<dyn std::error::Error + Send + Sync>> {
         let request = DeleteCharacterRequest {
             user_id: user_id.to_string(),
             char_id: char_id.to_string(),
+            delete_type
         };
 
         let response = self.client.delete_character(request).await?;

packet-service/src/handlers/auth.rs

@@ -26,6 +26,23 @@ use crate::connection_service::ConnectionService;
 use crate::packets::cli_logout_req::CliLogoutReq;
 use crate::packets::srv_join_server_reply::SrvJoinServerReply;
 
+
+pub(crate) async fn handle_alive_req(stream: &mut TcpStream, packet: Packet, auth_client: Arc<Mutex<AuthClient>>, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
+    if let Some(mut state) = connection_service.get_connection(&connection_id) {
+        let session_id = state.session_id.clone().unwrap();
+        debug!("Attempting to refresh session {}", session_id);
+        let mut auth_client = auth_client.lock().await;
+        let session = auth_client.refresh_session(&session_id).await?;
+        if (!session.valid) {
+            warn!("Invalid session ID: {}", session_id);
+            return Err("Session not valid".into());
+        }
+        Ok(())
+    } else {
+        Err("Unable to find connection state".into())
+    }
+}
+
 pub(crate) async fn handle_accept_req(stream: &mut TcpStream, packet: Packet) -> Result<(), Box<dyn Error + Send + Sync>> {
     let data = SrvAcceptReply { result: srv_accept_reply::Result::Accepted, rand_value: 0 };
     let response_packet = Packet::new(PacketType::PakssAcceptReply, &data)?;

packet-service/src/handlers/character.rs

@@ -51,7 +51,6 @@ pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet,
     // query the character service for the character list for this user
     let mut character_client = character_client.lock().await;
     let character_list = character_client.get_character_list(&user_id.to_string()).await?;
-    debug!("{:?}", character_list.characters);
     let mut characters = vec![];
     let mut character_id_list:Vec<u8> = Vec::new();
     for character in character_list.characters {
@@ -68,7 +67,6 @@ pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet,
                 };
             }
         }
-        debug!("Item list is created as: {:?}", item_list);
         
         let character_info = CharInfo {
             name: NullTerminatedString(character.name),
@@ -89,7 +87,6 @@ pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet,
         state.character_list = Some(character_id_list); // Save the real character id's for later as the client sends what is selected from 0 index. It does not use the real character idss
     }
 
-    debug!("{:?}", characters);
     let data = SrvCharListReply { characters };
     let response_packet = Packet::new(PacketType::PakccCharListReply, &data)?;
     send_packet(stream, &response_packet).await?;
@@ -144,7 +141,7 @@ pub(crate) async fn handle_delete_char_req(stream: &mut TcpStream, packet: Packe
     }
 
     let mut character_client = character_client.lock().await;
-    let delete_response = character_client.delete_character(&user_id.to_string(), &character_id_list[request.char_id as usize].to_string()).await?;
+    let delete_response = character_client.delete_character(&user_id.to_string(), &character_id_list[request.char_id as usize].to_string(), request.is_delete as i32).await?;
 
     let character_name = request.name;
     let data = SrvDeleteCharReply { remaining_time: delete_response.remaining_time as u32, name: character_name };

packet-service/src/router.rs

@@ -60,8 +60,8 @@ impl PacketRouter {
     pub async fn route_packet(&self, stream: &mut TcpStream, packet: Packet, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
         debug!("Routing packet: {:?}", packet);
         match packet.packet_type {
-            PacketType::PakcsAlive => Ok(()),
             // Generic Server Packets
+            PacketType::PakcsAlive => auth::handle_alive_req(stream, packet, self.auth_client.clone(), self.connection_service.clone(), connection_id).await,
             PacketType::PakcsAcceptReq => auth::handle_accept_req(stream, packet).await,
             PacketType::PakcsJoinServerTokenReq => auth::handle_join_server_req(stream, packet, self.auth_client.clone(), self.connection_service.clone(), connection_id).await,
             // Login Packets

proto/auth.proto

@@ -7,6 +7,7 @@ service AuthService {
     rpc Logout(LogoutRequest) returns (Empty);
     rpc ValidateToken(ValidateTokenRequest) returns (ValidateTokenResponse);
     rpc ValidateSession(ValidateSessionRequest) returns (ValidateSessionResponse);
+    rpc RefreshSession(ValidateSessionRequest) returns (ValidateSessionResponse);
     rpc Register (RegisterRequest) returns (RegisterResponse);
     rpc RequestPasswordReset (PasswordResetRequest) returns (PasswordResetResponse);
     rpc ResetPassword (ResetPasswordRequest) returns (ResetPasswordResponse);

proto/character.proto

@@ -35,6 +35,7 @@ message CreateCharacterResponse {
 message DeleteCharacterRequest {
     string user_id = 1;
     string char_id = 2;
+    int32 delete_type = 3;
 }
 
 message DeleteCharacterResponse {

proto/character_db_api.proto

@@ -39,6 +39,7 @@ message CreateCharacterResponse {
 message DeleteCharacterRequest {
     int32 user_id = 1;
     int32 character_id = 2;
+    int32 delete_type = 3;
 }
 
 message DeleteCharacterResponse {
@@ -56,7 +57,8 @@ message Character {
     string position = 9;
     string created_at = 10;
     string updated_at = 11;
-    bool is_active = 12;
+    string deleted_at = 12;
+    bool is_active = 13;
 }
 
 message Empty {}

proto/session_service_api.proto

@@ -5,6 +5,7 @@ package session_service_api;
 service SessionService {
   rpc CreateSession (CreateSessionRequest) returns (SessionResponse);
   rpc GetSession (GetSessionRequest) returns (SessionResponse);
+  rpc RefreshSession (GetSessionRequest) returns (SessionResponse);
   rpc DeleteSession (DeleteSessionRequest) returns (Empty);
 }
 

session-service/src/session_service.rs

@@ -41,7 +41,7 @@ impl SessionService for SessionServiceImpl {
         let session_data = serde_json::to_string(&session).map_err(|_| Status::internal("Failed to serialize session"))?;
 
         let conn = self.redis.lock().await;
-        conn.set(&session_id.clone(), &session_data, 0).await.map_err(|_| Status::internal("Failed to store session in Redis"))?;
+        conn.set(&session_id.clone(), &session_data, 300).await.map_err(|_| Status::internal("Failed to store session in Redis"))?;
 
         let response = SessionResponse {
             session_id,
@@ -91,4 +91,29 @@ impl SessionService for SessionServiceImpl {
 
         Ok(Response::new(Empty {}))
     }
+    async fn refresh_session(
+        &self,
+        request: Request<GetSessionRequest>,
+    ) -> Result<Response<SessionResponse>, Status> {
+        let req = request.into_inner();
+        let conn = self.redis.lock().await;
+
+        if let Some(session_data) = conn.get::<String>(&req.session_id).await.map_err(|_| Status::internal("Failed to fetch session from Redis"))? {
+            let _ = conn.update(&req.session_id, Some(&session_data), Some(300));
+            let session: Session = serde_json::from_str(&session_data).map_err(|_| Status::internal("Failed to deserialize session"))?;
+
+            let response = SessionResponse {
+                session_id: req.session_id,
+                user_id: session.user_id,
+                username: session.username,
+                character_id: session.character_id,
+                login_time: session.login_time,
+                ip_address: session.ip_address,
+            };
+
+            Ok(Response::new(response))
+        } else {
+            Err(Status::not_found("Session not found"))
+        }
+    }
 }

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| {