141 lines
4.8 KiB
Rust
141 lines
4.8 KiB
Rust
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};
|
|
use std::sync::Arc;
|
|
use tonic::{Request, Response, Status};
|
|
use tracing::debug;
|
|
|
|
pub mod character_common {
|
|
tonic::include_proto!("character_common");
|
|
}
|
|
pub mod character {
|
|
tonic::include_proto!("character");
|
|
}
|
|
|
|
pub struct MyCharacterService {
|
|
pub character_db_client: Arc<CharacterDbClient>,
|
|
}
|
|
|
|
#[tonic::async_trait]
|
|
impl CharacterService for MyCharacterService {
|
|
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
|
|
.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(),
|
|
})
|
|
}
|
|
|
|
let response = GetCharacterListResponse { characters };
|
|
Ok(Response::new(response))
|
|
}
|
|
|
|
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,
|
|
)
|
|
.await
|
|
.map_err(|_| Status::aborted("Unable to create character"))?;
|
|
|
|
let response = CreateCharacterResponse {
|
|
result: create_character_response.result,
|
|
};
|
|
Ok(Response::new(response))
|
|
}
|
|
|
|
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,
|
|
};
|
|
Ok(Response::new(response))
|
|
}
|
|
|
|
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 character = CharacterFull {
|
|
character_id: get_character_response.id.to_string(),
|
|
name: get_character_response.name.to_string(),
|
|
money: get_character_response.money,
|
|
position: serde_json::from_str(&get_character_response.position).unwrap(),
|
|
looks: serde_json::from_str(&get_character_response.looks).unwrap(),
|
|
stats: serde_json::from_str(&get_character_response.stats).unwrap(),
|
|
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),
|
|
};
|
|
Ok(Response::new(response))
|
|
}
|
|
}
|