Raven/osirose-new
SHA256
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects 6 Releases Wiki Activity

- update: auth system to work with the website auth

Browse Source
This commit is contained in:
raven
2025-03-16 01:35:44 -04:00
parent cbd71d1ab1
commit cf9efc9866
11 changed files with 93 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
database-service/src/characters.rs
View File

@@ -8,7 +8,7 @@ use utils::redis_cache::{Cache, RedisCache};
#[derive(Debug, FromRow, Serialize, Deserialize)]
pub struct Character {
pub id: i32,
pub user_id: i32,
pub user_id: String,
pub name: String,
pub money: i64,
pub inventory: serde_json::Value,
@@ -49,9 +49,9 @@ impl CharacterRepository {
// Fetch from database
let character = sqlx::query_as::<_, Character>(
"SELECT id, user_id, name, money, inventory, stats, skills, looks, position, \
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",
"SELECT id, userId as user_id, name, money, inventory, stats, skills, looks, position, \
createdAt as created_at, updatedAt as updated_at, extract(epoch from (deletedAt - now()))::BIGINT as deleted_at, isActive as is_active \
FROM character WHERE id = $1 AND isActive = true",
)
.bind(character_id)
.fetch_one(&self.pool)
@@ -69,7 +69,7 @@ impl CharacterRepository {
pub async fn create_character(
&self,
user_id: i32,
user_id: String,
name: &str,
inventory: serde_json::Value,
skills: serde_json::Value,
@@ -78,10 +78,10 @@ impl CharacterRepository {
position: serde_json::Value,
) -> Result<i32, sqlx::Error> {
let result = sqlx::query(
"INSERT INTO characters (user_id, name, inventory, stats, skills, looks, position, created_at, updated_at, is_active) \
"INSERT INTO character (userId, name, inventory, stats, skills, looks, position, createdAt, updatedAt, isActive) \
VALUES ($1, $2, $3, $4, $5, $6, $7, NOW(), NOW(), true) RETURNING id",
)
.bind(user_id)
.bind(&user_id)
.bind(name)
.bind(inventory)
.bind(stats)
@@ -107,9 +107,9 @@ impl CharacterRepository {
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";
let mut query = "UPDATE character SET updatedAt = NOW(), deletedAt = NOW() + '24 hours' WHERE id = $1 RETURNING userId, extract(epoch from (deletedAt - now()))::BIGINT as deletedAt";
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";
query = "UPDATE character SET updatedAt = NOW(), deletedAt = null WHERE id = $1 RETURNING userId, 0::BIGINT as deletedAt";
}
let result = sqlx::query(query)
.bind(character_id)
@@ -154,7 +154,7 @@ impl CharacterRepository {
// Fetch from database
let characters = sqlx::query_as::<_, Character>(
"SELECT id, user_id, name, money, inventory, stats, skills, 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",
"SELECT id, userId as user_id, name, money, inventory, stats, skills, looks, position, createdAt as created_at, updatedAt as updated_at, extract(epoch from (deletedAt - now()))::BIGINT as deleted_at, isActive as is_active FROM character WHERE userId = $1 AND isActive = true",
)
.bind(user_id)
.fetch_all(&self.pool)

34
database-service/src/grpc/user_service.rs
View File

@@ -1,7 +1,7 @@
use crate::grpc::database_service::MyDatabaseService;
use crate::grpc::user_service_server::UserService;
use crate::grpc::{
CreateUserRequest, CreateUserResponse, GetUserByEmailRequest, GetUserByUsernameRequest,
GetUserByEmailRequest, GetUserByUsernameRequest,
GetUserRequest, GetUserResponse,
};
use tonic::{Request, Response, Status};
@@ -23,30 +23,12 @@ impl UserService for MyDatabaseService {
Ok(Response::new(GetUserResponse {
user_id: user.id,
username: user.username,
username: user.name,
email: user.email,
hashed_password: user.hashed_password,
roles: user.roles.unwrap_or_else(Vec::new),
role: user.role,
}))
}
async fn create_user(
&self,
request: Request<CreateUserRequest>,
) -> Result<Response<CreateUserResponse>, Status> {
let req = request.into_inner();
let user_id = self
.db
.user_repo
.create_user(&req.username, &req.email, &req.hashed_password)
.await
.map_err(|_| Status::internal("Failed to create user"))?;
// Return the newly created user ID
Ok(Response::new(CreateUserResponse { user_id }))
}
async fn get_user_by_username(
&self,
request: Request<GetUserByUsernameRequest>,
@@ -62,10 +44,9 @@ impl UserService for MyDatabaseService {
Ok(Response::new(GetUserResponse {
user_id: user.id,
username: user.username,
username: user.name,
email: user.email,
hashed_password: user.hashed_password,
roles: user.roles.unwrap_or_else(Vec::new),
role: user.role,
}))
}
@@ -84,10 +65,9 @@ impl UserService for MyDatabaseService {
Ok(Response::new(GetUserResponse {
user_id: user.id,
username: user.username,
username: user.name,
email: user.email,
hashed_password: user.hashed_password,
roles: user.roles.unwrap_or_else(Vec::new),
role: user.role,
}))
}
}

82
database-service/src/users.rs
View File

@@ -2,15 +2,14 @@ use serde::{Deserialize, Serialize};
use sqlx::{FromRow, Row};
use std::sync::Arc;
use tokio::sync::Mutex;
use utils::redis_cache::{Cache, RedisCache}; // Import RedisCache and Cache Trait
use utils::redis_cache::{Cache, RedisCache};
#[derive(Debug, FromRow, Serialize, Deserialize)]
pub struct User {
pub id: i32,
pub username: String,
pub name: String,
pub email: String,
pub hashed_password: String,
pub roles: Option<Vec<String>>,
pub role: String,
pub created_at: chrono::NaiveDateTime,
pub updated_at: chrono::NaiveDateTime,
}
@@ -40,7 +39,7 @@ impl UserRepository {
}
let user = sqlx::query_as::<_, User>(
"SELECT id, username, email, hashed_password, roles, created_at, updated_at FROM users WHERE id = $1",
"SELECT id, name, email, role, createdAt, updatedAt FROM user WHERE id = $1",
)
.bind(user_id)
.fetch_one(&self.pool)
@@ -70,7 +69,7 @@ impl UserRepository {
}
let user = sqlx::query_as::<_, User>(
"SELECT id, username, email, hashed_password, roles, created_at, updated_at FROM users WHERE username = $1",
"SELECT id, name, email, role, createdAt, updatedAt FROM user WHERE name = $1",
)
.bind(username)
.fetch_one(&self.pool)
@@ -100,7 +99,7 @@ impl UserRepository {
}
let user = sqlx::query_as::<_, User>(
"SELECT id, username, email, hashed_password, roles, created_at, updated_at FROM users WHERE email = $1",
"SELECT id, name, email, role, createdAt, updatedAt FROM user WHERE email = $1",
)
.bind(email)
.fetch_one(&self.pool)
@@ -115,62 +114,33 @@ impl UserRepository {
Ok(user)
}
pub async fn create_user(
&self,
username: &str,
email: &str,
hashed_password: &str,
) -> Result<i32, sqlx::Error> {
let row = sqlx::query(
r#"
INSERT INTO users (username, email, hashed_password)
VALUES ($1, $2, $3)
RETURNING id
"#,
pub async fn get_user_by_session(&self, session: &str) -> Result<User, sqlx::Error> {
let cache_key = format!("user:session:{}", session);
if let Some(user) = self
.cache
.lock()
.await
.get::<User>(&cache_key)
.await
.map_err(|_| sqlx::Error::RowNotFound)?
{
return Ok(user);
}
let user = sqlx::query_as::<_, User>(
"SELECT id, name, email, role, createdAt, updatedAt FROM user WHERE email = $1",
)
.bind(username)
.bind(email)
.bind(hashed_password)
.fetch_one(&self.pool)
.await?;
Ok(row.get(0))
}
pub async fn update_user_email(
&self,
user_id: i32,
new_email: &str,
) -> Result<(), sqlx::Error> {
sqlx::query("UPDATE users SET email = $1, updated_at = NOW() WHERE id = $2")
.bind(new_email)
.bind(user_id)
.execute(&self.pool)
.bind(session)
.fetch_one(&self.pool)
.await?;
let cache_key = format!("user:{}", user_id);
self.cache
.lock()
.await
.delete(&cache_key)
.set(&cache_key, &user, 300)
.await
.map_err(|_| sqlx::Error::RowNotFound)?;
Ok(())
}
pub async fn delete_user(&self, user_id: i32) -> Result<(), sqlx::Error> {
sqlx::query("DELETE FROM users WHERE id = $1")
.bind(user_id)
.execute(&self.pool)
.await?;
let cache_key = format!("user:{}", user_id);
self.cache
.lock()
.await
.delete(&cache_key)
.await
.map_err(|_| sqlx::Error::RowNotFound)?;
Ok(())
Ok(user)
}
}