- chore: ran cargo fix on the codebase

character-service/src/character_service.rs

@@ -1,11 +1,14 @@
-use std::sync::Arc;
-use tracing::debug;
-use tonic::{Request, Response, Status};
-use utils::null_string::NullTerminatedString;
 use crate::character_db_client::CharacterDbClient;
 use crate::character_service::character::character_service_server::CharacterService;
-use crate::character_service::character::{CreateCharacterRequest, CreateCharacterResponse, DeleteCharacterRequest, DeleteCharacterResponse, GetCharacterListRequest, GetCharacterListResponse, GetCharacterRequest, GetCharacterResponse};
-use crate::character_service::character_common::{Character, CharacterFull, Looks, Stats};
+use crate::character_service::character::{
+    CreateCharacterRequest, CreateCharacterResponse, DeleteCharacterRequest,
+    DeleteCharacterResponse, GetCharacterListRequest, GetCharacterListResponse,
+    GetCharacterRequest, GetCharacterResponse,
+};
+use crate::character_service::character_common::{Character, CharacterFull};
+use std::sync::Arc;
+use tonic::{Request, Response, Status};
+use tracing::debug;
 
 pub mod character_common {
     tonic::include_proto!("character_common");
@@ -20,60 +23,103 @@ pub struct MyCharacterService {
 
 #[tonic::async_trait]
 impl CharacterService for MyCharacterService {
-    async fn get_character_list(&self, request: Request<GetCharacterListRequest>) -> Result<Response<GetCharacterListResponse>, Status> {
+    async fn get_character_list(
+        &self,
+        request: Request<GetCharacterListRequest>,
+    ) -> Result<Response<GetCharacterListResponse>, Status> {
         let req = request.into_inner();
 
         let user_id = req.user_id;
         debug!("Character list for User ID: {}", user_id);
 
-        let character_list = self.character_db_client.as_ref().clone().get_character_list(&user_id).await
+        let character_list = self
+            .character_db_client
+            .as_ref()
+            .clone()
+            .get_character_list(&user_id)
+            .await
             .map_err(|_| Status::aborted("Unable to get character list"))?;
         debug!("{:?}", character_list.characters);
 
         let mut characters: Vec<Character> = vec![];
         for character in character_list.characters {
-            characters.push(
-                Character {
-                    character_id: character.id.to_string(),
-                    name: character.name,
-                    last_played: 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(),
-                }
-            )
+            characters.push(Character {
+                character_id: character.id.to_string(),
+                name: character.name,
+                last_played: 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(),
+            })
         }
 
         let response = GetCharacterListResponse { characters };
         Ok(Response::new(response))
     }
 
-    async fn create_character(&self, request: Request<CreateCharacterRequest>) -> Result<Response<CreateCharacterResponse>, Status> {
+    async fn create_character(
+        &self,
+        request: Request<CreateCharacterRequest>,
+    ) -> Result<Response<CreateCharacterResponse>, Status> {
         let req = request.into_inner();
         debug!("{:?}", req);
-        
-        let create_character_response = self.character_db_client.as_ref().clone().create_character(&req.user_id, &req.name, req.race, req.face, req.hair, req.stone)
+
+        let create_character_response = self
+            .character_db_client
+            .as_ref()
+            .clone()
+            .create_character(
+                &req.user_id,
+                &req.name,
+                req.race,
+                req.face,
+                req.hair,
+                req.stone,
+            )
             .await
             .map_err(|_| Status::aborted("Unable to create character"))?;
-        
-        let response = CreateCharacterResponse { result: create_character_response.result };
+
+        let response = CreateCharacterResponse {
+            result: create_character_response.result,
+        };
         Ok(Response::new(response))
     }
 
-    async fn delete_character(&self, request: Request<DeleteCharacterRequest>) -> Result<Response<DeleteCharacterResponse>, Status> {
+    async fn delete_character(
+        &self,
+        request: Request<DeleteCharacterRequest>,
+    ) -> Result<Response<DeleteCharacterResponse>, Status> {
         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, 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 };
+        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))
     }
 
-    async fn get_character(&self, request: Request<GetCharacterRequest>) -> Result<Response<GetCharacterResponse>, Status> {
+    async fn get_character(
+        &self,
+        request: Request<GetCharacterRequest>,
+    ) -> Result<Response<GetCharacterResponse>, Status> {
         let req = request.into_inner();
         debug!("{:?}", req);
-        let get_character_response = self.character_db_client.as_ref().clone().get_character(&req.user_id, &req.char_id).await.map_err(|_| Status::not_found("Character not found"))?;
+        let get_character_response = self
+            .character_db_client
+            .as_ref()
+            .clone()
+            .get_character(&req.user_id, &req.char_id)
+            .await
+            .map_err(|_| Status::not_found("Character not found"))?;
 
         let character = CharacterFull {
             character_id: get_character_response.id.to_string(),
@@ -84,8 +130,10 @@ impl CharacterService for MyCharacterService {
             skills: serde_json::from_str(&get_character_response.skills).unwrap(),
             items: serde_json::from_str(&get_character_response.inventory).unwrap(),
         };
-        
-        let response = GetCharacterResponse { character: Some(character) };
+
+        let response = GetCharacterResponse {
+            character: Some(character),
+        };
         Ok(Response::new(response))
     }
-}
+}