postgress

imphnen-gacha/src/lib.rs

@@ -24,20 +24,15 @@ pub use imphnen_libs::{
 };
 
 pub use imphnen_utils::{
-    bind_filter,
     csrf_token,
     extract_email,
     generate_date,
     generate_otp,
-    get_id,
     logger,
     make_thing,
-    query_builder,
-    query_list,
     response_format,
-    serde_helpers,
     validator,
 };
 
 // Re-export public v1 API
-pub use v1::gacha_router;
+pub use v1::gacha_router;

imphnen-gacha/src/v1/gacha_claims/gacha_claims_controller.rs

@@ -1,66 +1,66 @@
-use axum::Extension;
-use axum::http::HeaderMap;
-use axum::response::IntoResponse;
-use axum::{Json, extract::Path};
-use imphnen_iam::{PermissionsEnum, permissions_guard};
-use crate::AppState;
-use imphnen_entities::{MessageResponseDto, ResponseSuccessDto};
-use crate::v1::gacha_claims::{GachaClaimItemDto, GachaClaimRequestDto, GachaClaimService};
-
-#[utoipa::path(
-	get,
-	path = "/v1/gacha/claims/detail/{id}",
-	security(
-        ("Bearer" = [])
-    ),
-	params(("id" = String, Path, description = "Gacha Claim ID")),
-	responses(
-	    (status = 200, description = "[ADMIN] Get Gacha Claim by ID", body = ResponseSuccessDto<GachaClaimItemDto>)
-	),
-	tag = "Gacha"
-)]
-pub async fn get_detail_gacha_claim(
-	headers: axum::http::HeaderMap,
-	Extension(state): Extension<AppState>,
-	Path(id): Path<String>,
-) -> impl IntoResponse {
-	match permissions_guard(
-		headers,
-		Extension(state),
-		vec![PermissionsEnum::ReadDetailGachaClaims],
-	)
-	.await
-	{
-		Ok((_user, state)) => GachaClaimService::get_gacha_claim_by_id(&state, id).await,
-		Err(response) => response,
-	}
-}
-
-#[utoipa::path(
-	post,
-	security(
-        ("Bearer" = [])
-    ),
-	path = "/v1/gacha/claims/create",
-	request_body = GachaClaimRequestDto,
-	responses(
-	    (status = 201, description = "[ADMIN] Create new gacha claim", body = MessageResponseDto)
-	),
-	tag = "Gacha"
-)]
-pub async fn post_create_gacha_claim(
-	headers: HeaderMap,
-	Extension(state): Extension<AppState>,
-	Json(payload): Json<GachaClaimRequestDto>,
-) -> impl IntoResponse {
-	match permissions_guard(
-		headers,
-		Extension(state),
-		vec![PermissionsEnum::CreateGachaClaims],
-	)
-	.await
-	{
-		Ok((_user, state)) => GachaClaimService::create_gacha_claim(&state, payload).await,
-		Err(response) => response,
-	}
-}
+use axum::Extension;
+use axum::http::HeaderMap;
+use axum::response::IntoResponse;
+use axum::{Json, extract::Path};
+use imphnen_iam::{PermissionsEnum, permissions_guard};
+use crate::AppState;
+use imphnen_entities::{MessageResponseDto, ResponseSuccessDto};
+use crate::v1::gacha_claims::{GachaClaimItemDto, GachaClaimRequestDto, GachaClaimService};
+
+#[utoipa::path(
+	get,
+	path = "/v1/gacha/claims/detail/{id}",
+	security(
+        ("Bearer" = [])
+    ),
+	params(("id" = String, Path, description = "Gacha Claim ID")),
+	responses(
+	    (status = 200, description = "[ADMIN] Get Gacha Claim by ID", body = ResponseSuccessDto<GachaClaimItemDto>)
+	),
+	tag = "Gacha"
+)]
+pub async fn get_detail_gacha_claim(
+	headers: axum::http::HeaderMap,
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+) -> impl IntoResponse {
+	match permissions_guard(
+		headers,
+		Extension(state),
+		vec![PermissionsEnum::ReadDetailGachaClaims],
+	)
+	.await
+	{
+		Ok((_user, state)) => GachaClaimService::get_gacha_claim_by_id(&state, id).await,
+		Err(response) => response,
+	}
+}
+
+#[utoipa::path(
+	post,
+	security(
+        ("Bearer" = [])
+    ),
+	path = "/v1/gacha/claims/create",
+	request_body = GachaClaimRequestDto,
+	responses(
+	    (status = 201, description = "[ADMIN] Create new gacha claim", body = MessageResponseDto)
+	),
+	tag = "Gacha"
+)]
+pub async fn post_create_gacha_claim(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Json(payload): Json<GachaClaimRequestDto>,
+) -> impl IntoResponse {
+	match permissions_guard(
+		headers,
+		Extension(state),
+		vec![PermissionsEnum::CreateGachaClaims],
+	)
+	.await
+	{
+		Ok((_user, state)) => GachaClaimService::create_gacha_claim(&state, payload).await,
+		Err(response) => response,
+	}
+}

imphnen-gacha/src/v1/gacha_claims/gacha_claims_dto.rs

@@ -4,7 +4,6 @@ use imphnen_iam::{UsersDetailItemDto, UsersDetailQueryDto};
 use lazy_static::lazy_static;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
-use surrealdb::sql::Thing;
 use utoipa::ToSchema;
 use validator::{Validate, ValidationError};
 
@@ -45,7 +44,7 @@ pub struct GachaClaimItemDto {
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct GachaClaimQueryDto {
-	pub id: Thing,
+	pub id: String,
 	pub user: UsersDetailQueryDto,
 	pub item: GachaItemSchema,
 	pub is_deleted: bool,
@@ -56,7 +55,7 @@ pub struct GachaClaimQueryDto {
 impl GachaClaimItemDto {
 	pub fn from(dto: &GachaClaimQueryDto) -> Self {
 		Self {
-			id: dto.id.id.to_raw(),
+			id: dto.id.clone(),
 			user: UsersDetailItemDto::from(&dto.user),
 			item: GachaItemDto::from(dto.item.clone()),
 			is_deleted: dto.is_deleted,

imphnen-gacha/src/v1/gacha_claims/gacha_claims_repository.rs

@@ -1,11 +1,14 @@
 use crate::v1::gacha_claims::gacha_claims_dto::GachaClaimQueryDto;
 use crate::v1::gacha_claims::gacha_claims_schema::GachaClaimSchema;
+use crate::v1::gacha_items::gacha_items_schema::GachaItemSchema;
 use crate::AppState;
-use imphnen_libs::ResourceEnum;
-use anyhow::{Result, bail};
-use imphnen_iam::DetailQueryBuilder;
-use std::time::Instant;
-use tracing::{instrument, info};
+use anyhow::{Result, anyhow};
+use imphnen_entities::seaorm::gacha::gacha_claims::{Entity as GachaClaimsEntity, ActiveModel as GachaClaimsActiveModel};
+use imphnen_entities::seaorm::gacha::gacha_items::Entity as GachaItemsEntity;
+use imphnen_iam::{UsersRepository, UsersDetailQueryDto};
+use sea_orm::{EntityTrait, ActiveModelTrait, ActiveValue};
+use tracing::instrument;
+use uuid::Uuid;
 
 pub struct GachaClaimRepository<'a> {
 	state: &'a AppState,
@@ -21,27 +24,55 @@ impl<'a> GachaClaimRepository<'a> {
 		&self,
 		id: String,
 	) -> Result<GachaClaimQueryDto> {
-		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		let builder = DetailQueryBuilder::new(ResourceEnum::GachaClaims.to_string())
-			.with_id(id.clone())
-			.with_select_fields(vec!["*"])
-			.with_fetch("item")
-			.with_fetch("user");
-		let sql = builder.build();
-		info!(query = %sql, "Executing SurrealDB query");
-		let result: Option<GachaClaimQueryDto> =
-			builder.apply_bindings(db.query(sql)).await?.take(0)?;
-		let elapsed = now.elapsed();
-		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
-			== "development"
-		{
-			println!("Query 'query_gacha_claim_by_id' took: {elapsed:.2?}");
-		}
-		match result {
-			Some(claim) if !claim.is_deleted => Ok(claim),
-			_ => bail!("Gacha Claim not found"),
-		}
+		let conn = &self.state.postgres_connection.conn;
+		let claim_uuid = Uuid::parse_str(&id).map_err(|e| anyhow!("Invalid ID format: {}", e))?;
+
+		let claim_model = GachaClaimsEntity::find_by_id(claim_uuid)
+			.one(conn)
+			.await?
+			.ok_or_else(|| anyhow!("Gacha claim not found"))?;
+
+		// Fetch User
+		let user_repo = UsersRepository::new(self.state);
+		let user_dto: UsersDetailQueryDto = user_repo
+			.query_user_by_id(&claim_model.user_id.to_string())
+			.await
+			.map_err(|e| anyhow!("Failed to fetch user: {}", e))?;
+
+		// Fetch Item
+		let item_model = GachaItemsEntity::find_by_id(claim_model.gacha_item_id)
+			.one(conn)
+			.await?
+			.ok_or_else(|| anyhow!("Gacha item not found"))?;
+		
+		// Convert Item Model to Schema
+        let item_schema = GachaItemSchema {
+            id: item_model.id.to_string(),
+            item_code: item_model.item_code,
+            name: item_model.name,
+            description: item_model.description,
+            rarity: item_model.rarity,
+            type_: item_model.type_,
+            category: item_model.category,
+            value: item_model.value,
+            weight: item_model.weight,
+            stock: item_model.stock,
+            is_limited: item_model.is_limited,
+            metadata: item_model.metadata,
+            image_url: "".to_string(), // Field not present in DB model
+            is_deleted: item_model.deleted_at.is_some(),
+            created_at: Some(item_model.created_at.to_rfc3339()),
+            updated_at: Some(item_model.updated_at.to_rfc3339()),
+        };
+
+		Ok(GachaClaimQueryDto {
+			id: claim_model.id.to_string(),
+			user: user_dto,
+			item: item_schema,
+			is_deleted: claim_model.deleted_at.is_some(),
+			created_at: Some(claim_model.created_at.to_rfc3339()),
+			updated_at: Some(claim_model.updated_at.to_rfc3339()),
+		})
 	}
 
 	#[instrument(skip(self, data), err)]
@@ -49,26 +80,43 @@ impl<'a> GachaClaimRepository<'a> {
 		&self,
 		data: GachaClaimSchema,
 	) -> Result<String> {
-		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		info!(
-			resource = %ResourceEnum::GachaClaims.to_string(),
-			content = ?data,
-			"Executing SurrealDB create query"
-		);
-		let record: Option<GachaClaimSchema> = db
-			.create(ResourceEnum::GachaClaims.to_string())
-			.content(data)
-			.await?;
-		let elapsed = now.elapsed();
-		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
-			== "development"
-		{
-			println!("Query 'query_create_gacha_claim' took: {elapsed:.2?}");
-		}
-		match record {
-			Some(_) => Ok("Success create Gacha Claim".into()),
-			None => bail!("Failed to create Gacha Claim"),
-		}
+		let conn = &self.state.postgres_connection.conn;
+        
+        // Extract UUIDs from data (which uses Strings)
+        // GachaClaimSchema uses "thing" format (e.g., "Users:uuid"), we might need to strip prefix if present,
+        // but looking at schema implementation it seems it might store just UUID string or thing string.
+        // Let's assume it's a UUID string or clean it.
+        
+        let user_id_str = data.user.split(':').next_back().unwrap_or(&data.user);
+        let item_id_str = data.item.split(':').next_back().unwrap_or(&data.item);
+        
+		let user_uuid = Uuid::parse_str(user_id_str).map_err(|e| anyhow!("Invalid User UUID: {}", e))?;
+		let item_uuid = Uuid::parse_str(item_id_str).map_err(|e| anyhow!("Invalid Item UUID: {}", e))?;
+        let claim_id = Uuid::new_v4(); // Generate a new ID for the claim record itself
+        let id_uuid = if data.id.is_empty() {
+             Uuid::new_v4()
+        } else {
+             let clean_id = data.id.split(':').next_back().unwrap_or(&data.id);
+             Uuid::parse_str(clean_id).unwrap_or_else(|_| Uuid::new_v4())
+        };
+
+		let active_model = GachaClaimsActiveModel {
+			id: ActiveValue::Set(id_uuid),
+			user_id: ActiveValue::Set(user_uuid),
+			gacha_item_id: ActiveValue::Set(item_uuid),
+			claim_id: ActiveValue::Set(claim_id), // Using random UUID for claim_id as it's required but not in Schema
+			claim_type: ActiveValue::Set("standard".to_string()), // Default value
+			status: ActiveValue::Set("claimed".to_string()), // Default value
+			quantity: ActiveValue::Set(1),
+			metadata: ActiveValue::Set(None),
+			created_at: ActiveValue::Set(chrono::Utc::now()),
+			updated_at: ActiveValue::Set(chrono::Utc::now()),
+            deleted_at: ActiveValue::NotSet,
+            claimed_at: ActiveValue::Set(chrono::Utc::now()),
+		};
+
+		let result = active_model.insert(conn).await?;
+
+		Ok(result.id.to_string())
 	}
 }

imphnen-gacha/src/v1/gacha_claims/gacha_claims_schema.rs

@@ -1,17 +1,17 @@
 use crate::v1::gacha_rolls::gacha_rolls_dto::GachaRollQueryDto;
 use crate::{make_thing};
 use imphnen_iam::get_iso_date;
-use imphnen_libs::ResourceEnum;
+use imphnen_entities::ResourceEnum;
 use serde::{Deserialize, Serialize};
-use surrealdb::{Uuid, sql::Thing};
+use uuid::Uuid;
 
 use crate::v1::gacha_claims::gacha_claims_dto::GachaClaimRequestDto;
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct GachaClaimSchema {
-	pub id: Thing,
-	pub user: Thing,
-	pub item: Thing,
+	pub id: String,
+	pub user: String,
+	pub item: String,
 	pub is_deleted: bool,
 	pub created_at: Option<String>,
 	pub updated_at: Option<String>,
@@ -52,7 +52,7 @@ impl GachaClaimSchema {
 		}
 	}
 
-	pub fn roll(roll: GachaRollQueryDto, user_id: Thing) -> Self {
+	pub fn roll(roll: GachaRollQueryDto, user_id: String) -> Self {
 		Self {
 			id: make_thing(
 				&ResourceEnum::GachaClaims.to_string(),

imphnen-gacha/src/v1/gacha_claims/gacha_claims_service.rs

@@ -1,37 +1,37 @@
-use crate::AppState;
-use imphnen_entities::ResponseSuccessDto;
-use imphnen_utils::{common_response, success_response, validate_request};
-use crate::v1::gacha_claims::gacha_claims_dto::{GachaClaimItemDto, GachaClaimRequestDto};
-use crate::v1::gacha_claims::gacha_claims_repository::GachaClaimRepository;
-use crate::v1::gacha_claims::gacha_claims_schema::GachaClaimSchema;
-use axum::http::StatusCode;
-use axum::response::Response;
-
-pub struct GachaClaimService;
-
-impl GachaClaimService {
-	pub async fn get_gacha_claim_by_id(state: &AppState, id: String) -> Response {
-		let repo = GachaClaimRepository::new(state);
-		match repo.query_gacha_claim_by_id(id).await {
-			Ok(claim) => success_response(ResponseSuccessDto {
-				data: GachaClaimItemDto::from(&claim),
-			}),
-			Err(e) => common_response(StatusCode::NOT_FOUND, &e.to_string()),
-		}
-	}
-
-	pub async fn create_gacha_claim(
-		state: &AppState,
-		payload: GachaClaimRequestDto,
-	) -> Response {
-		if let Err((status, message)) = validate_request(&payload) {
-			return common_response(status, &message);
-		}
-		let repo = GachaClaimRepository::new(state);
-		let schema = GachaClaimSchema::from(payload);
-		match repo.query_create_gacha_claim(schema).await {
-			Ok(msg) => common_response(StatusCode::CREATED, &msg),
-			Err(e) => common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
-		}
-	}
-}
+use crate::AppState;
+use imphnen_entities::ResponseSuccessDto;
+use imphnen_utils::{common_response, success_response, validate_request};
+use crate::v1::gacha_claims::gacha_claims_dto::{GachaClaimItemDto, GachaClaimRequestDto};
+use crate::v1::gacha_claims::gacha_claims_repository::GachaClaimRepository;
+use crate::v1::gacha_claims::gacha_claims_schema::GachaClaimSchema;
+use axum::http::StatusCode;
+use axum::response::Response;
+
+pub struct GachaClaimService;
+
+impl GachaClaimService {
+	pub async fn get_gacha_claim_by_id(state: &AppState, id: String) -> Response {
+		let repo = GachaClaimRepository::new(state);
+		match repo.query_gacha_claim_by_id(id).await {
+			Ok(claim) => success_response(ResponseSuccessDto {
+				data: GachaClaimItemDto::from(&claim),
+			}),
+			Err(e) => common_response(StatusCode::NOT_FOUND, &e.to_string()),
+		}
+	}
+
+	pub async fn create_gacha_claim(
+		state: &AppState,
+		payload: GachaClaimRequestDto,
+	) -> Response {
+		if let Err((status, message)) = validate_request(&payload) {
+			return common_response(status, &message);
+		}
+		let repo = GachaClaimRepository::new(state);
+		let schema = GachaClaimSchema::from(payload);
+		match repo.query_create_gacha_claim(schema).await {
+			Ok(msg) => common_response(StatusCode::CREATED, &msg),
+			Err(e) => common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+		}
+	}
+}

imphnen-gacha/src/v1/gacha_claims/mod.rs

@@ -1,22 +1,22 @@
-use axum::{
-    Router,
-    routing::{get, post},
-};
-
-pub mod gacha_claims_controller;
-pub mod gacha_claims_dto;
-pub mod gacha_claims_repository;
-pub mod gacha_claims_schema;
-pub mod gacha_claims_service;
-
-// Export only public API functions
-pub use gacha_claims_controller::{post_create_gacha_claim, get_detail_gacha_claim};
-pub use gacha_claims_dto::{GachaClaimItemDto, GachaClaimRequestDto};
-pub use gacha_claims_service::GachaClaimService;
-
-/// Creates router for gacha claims endpoints
-pub fn gacha_claim_router() -> Router {
-    Router::new()
-        .route("/create", post(post_create_gacha_claim))
-        .route("/detail/{id}", get(get_detail_gacha_claim))
-}
+use axum::{
+    Router,
+    routing::{get, post},
+};
+
+pub mod gacha_claims_controller;
+pub mod gacha_claims_dto;
+pub mod gacha_claims_repository;
+pub mod gacha_claims_schema;
+pub mod gacha_claims_service;
+
+// Export only public API functions
+pub use gacha_claims_controller::{post_create_gacha_claim, get_detail_gacha_claim};
+pub use gacha_claims_dto::{GachaClaimItemDto, GachaClaimRequestDto};
+pub use gacha_claims_service::GachaClaimService;
+
+/// Creates router for gacha claims endpoints
+pub fn gacha_claim_router() -> Router {
+    Router::new()
+        .route("/create", post(post_create_gacha_claim))
+        .route("/detail/{id}", get(get_detail_gacha_claim))
+}

imphnen-gacha/src/v1/gacha_credits/gacha_credits_controller.rs

@@ -1,35 +1,35 @@
-use axum::{
-    extract::Json,
-    http::HeaderMap,
-    response::Response,
-    Extension,
-};
-use crate::AppState;
-use crate::v1::gacha_credits::gacha_credits_dto::GachaCreditRequestDto;
-use crate::v1::gacha_credits::gacha_credits_service::GachaCreditService;
-
-pub struct GachaCreditController;
-
-impl GachaCreditController {
-    pub async fn get_user_credits(
-        headers: HeaderMap,
-        Extension(state): Extension<AppState>,
-    ) -> Response {
-        GachaCreditService::get_user_credits(&headers, &state).await
-    }
-
-    pub async fn add_user_credits(
-        headers: HeaderMap,
-        Extension(state): Extension<AppState>,
-        Json(payload): Json<GachaCreditRequestDto>,
-    ) -> Response {
-        GachaCreditService::add_user_credits(&headers, &state, payload).await
-    }
-
-    pub async fn consume_user_credit(
-        headers: HeaderMap,
-        Extension(state): Extension<AppState>,
-    ) -> Response {
-        GachaCreditService::consume_user_credit(&headers, &state).await
-    }
+use axum::{
+    extract::Json,
+    http::HeaderMap,
+    response::Response,
+    Extension,
+};
+use crate::AppState;
+use crate::v1::gacha_credits::gacha_credits_dto::GachaCreditRequestDto;
+use crate::v1::gacha_credits::gacha_credits_service::GachaCreditService;
+
+pub struct GachaCreditController;
+
+impl GachaCreditController {
+    pub async fn get_user_credits(
+        headers: HeaderMap,
+        Extension(state): Extension<AppState>,
+    ) -> Response {
+        GachaCreditService::get_user_credits(&headers, &state).await
+    }
+
+    pub async fn add_user_credits(
+        headers: HeaderMap,
+        Extension(state): Extension<AppState>,
+        Json(payload): Json<GachaCreditRequestDto>,
+    ) -> Response {
+        GachaCreditService::add_user_credits(&headers, &state, payload).await
+    }
+
+    pub async fn consume_user_credit(
+        headers: HeaderMap,
+        Extension(state): Extension<AppState>,
+    ) -> Response {
+        GachaCreditService::consume_user_credit(&headers, &state).await
+    }
 }

imphnen-gacha/src/v1/gacha_credits/gacha_credits_dto.rs

@@ -1,38 +1,38 @@
-use serde::{Deserialize, Serialize};
-use utoipa::ToSchema;
-use validator::Validate;
-
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema, Validate)]
-pub struct GachaCreditRequestDto {
-	#[validate(length(min = 1, message = "User ID must not be empty"))]
-	pub user_id: String,
-
-	#[validate(range(
-		min = 1,
-		message = "Amount must be at least 1 credit"
-	))]
-	pub amount: i32,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct GachaCreditResponseDto {
-	pub id: String,
-	pub user_id: String,
-	pub available_rolls: i32,
-	pub is_deleted: bool,
-	pub created_at: Option<String>,
-	pub updated_at: Option<String>,
-}
-
-impl From<&crate::v1::gacha_credits::gacha_credits_schema::GachaCreditSchema> for GachaCreditResponseDto {
-	fn from(credit: &crate::v1::gacha_credits::gacha_credits_schema::GachaCreditSchema) -> Self {
-		Self {
-			id: credit.id.id.to_raw(),
-			user_id: credit.user.id.to_raw(),
-			available_rolls: credit.available_rolls,
-			is_deleted: credit.is_deleted,
-			created_at: credit.created_at.clone(),
-			updated_at: credit.updated_at.clone(),
-		}
-	}
-}
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+use validator::Validate;
+
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema, Validate)]
+pub struct GachaCreditRequestDto {
+	#[validate(length(min = 1, message = "User ID must not be empty"))]
+	pub user_id: String,
+
+	#[validate(range(
+		min = 1,
+		message = "Amount must be at least 1 credit"
+	))]
+	pub amount: i32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GachaCreditResponseDto {
+	pub id: String,
+	pub user_id: String,
+	pub available_rolls: i32,
+	pub is_deleted: bool,
+	pub created_at: Option<String>,
+	pub updated_at: Option<String>,
+}
+
+impl From<&crate::v1::gacha_credits::gacha_credits_schema::GachaCreditSchema> for GachaCreditResponseDto {
+	fn from(credit: &crate::v1::gacha_credits::gacha_credits_schema::GachaCreditSchema) -> Self {
+		Self {
+			id: credit.id.clone(),
+			user_id: credit.user.clone(),
+			available_rolls: credit.available_rolls,
+			is_deleted: credit.is_deleted,
+			created_at: credit.created_at.clone(),
+			updated_at: credit.updated_at.clone(),
+		}
+	}
+}

imphnen-gacha/src/v1/gacha_credits/gacha_credits_repository.rs

@@ -1,130 +1,117 @@
-use crate::v1::gacha_credits::gacha_credits_dto::GachaCreditRequestDto;
-use crate::v1::gacha_credits::gacha_credits_schema::GachaCreditSchema;
-use crate::AppState;
-use imphnen_libs::ResourceEnum;
-use anyhow::{Result, bail};
-use imphnen_iam::make_thing;
-use std::time::Instant;
-use surrealdb::Uuid;
-use tracing::{instrument, info};
-
-pub struct GachaCreditRepository<'a> {
-	state: &'a AppState,
-}
-
-impl<'a> GachaCreditRepository<'a> {
-	pub fn new(state: &'a AppState) -> Self {
-		Self { state }
-	}
-
-	#[instrument(skip(self, user_id), err)]
-	pub async fn query_by_user_id(
-		&self,
-		user_id: String,
-	) -> Result<Option<GachaCreditSchema>> {
-		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		let sql = format!(
-			"SELECT * FROM {} WHERE user = type::thing('{}', $user_id) AND is_deleted = false LIMIT 1",
-			ResourceEnum::GachaCredits,
-			ResourceEnum::Users.as_str()
-		);
-		info!(query = %sql, "Executing SurrealDB query");
-		let result: Vec<GachaCreditSchema> =
-			db.query(sql).bind(("user_id", user_id)).await?.take(0)?;
-		let elapsed = now.elapsed();
-		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
-			== "development"
-		{
-			println!("Query 'query_by_user_id' took: {elapsed:.2?}");
-		}
-		Ok(result.into_iter().next())
-	}
-
-	#[instrument(skip(self, user_id), err)]
-	pub async fn query_consume_credit(&self, user_id: String) -> Result<()> {
-		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		let credit_opt = self.query_by_user_id(user_id).await?;
-		let Some(mut credit) = credit_opt else {
-			let elapsed = now.elapsed();
-			if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
-				== "development"
-			{
-				println!(
-					"Query 'query_consume_credit' took: {elapsed:.2?} (no credit to consume)"
-				);
-			}
-			return Ok(());
-		};
-		if credit.available_rolls <= 0 {
-			let elapsed = now.elapsed();
-			if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
-				== "development"
-			{
-				println!(
-					"Query 'query_consume_credit' took: {elapsed:.2?} (no rolls remaining)"
-				);
-			}
-			bail!("No extra roll credits remaining");
-		}
-		credit.available_rolls -= 1;
-		info!(operation = "update", table = %ResourceEnum::GachaCredits.to_string(), id = %credit.id.id.to_raw(), "Executing SurrealDB update for consume_credit");
-		let _: Option<GachaCreditSchema> = db
-			.update((
-				&ResourceEnum::GachaCredits.to_string(),
-				credit.id.id.to_raw(),
-			))
-			.merge(credit)
-			.await?;
-		let elapsed = now.elapsed();
-		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
-			== "development"
-		{
-			println!("Query 'query_consume_credit' took: {elapsed:.2?}");
-		}
-		Ok(())
-	}
-
-	#[instrument(skip(self, payload), err)]
-	pub async fn query_add_credit(
-		&self,
-		payload: GachaCreditRequestDto,
-	) -> Result<()> {
-		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		if let Some(mut credit) = self.query_by_user_id(payload.user_id.clone()).await? {
-			credit.available_rolls += payload.amount;
-			info!(operation = "update", table = %ResourceEnum::GachaCredits.to_string(), id = %credit.id.id.to_raw(), "Executing SurrealDB update for add_credit");
-			let _: Option<GachaCreditSchema> = db
-				.update((
-					&ResourceEnum::GachaCredits.to_string(),
-					credit.id.id.to_raw(),
-				))
-				.merge(credit)
-				.await?;
-		} else {
-			let data = GachaCreditSchema {
-				id: make_thing(
-					&ResourceEnum::GachaCredits.to_string(),
-					&Uuid::new_v4().to_string(),
-				),
-				user: make_thing(&ResourceEnum::Users.to_string(), &payload.user_id),
-				available_rolls: payload.amount,
-				..Default::default()
-			};
-			info!(operation = "create", table = %ResourceEnum::GachaCredits.to_string(), "Executing SurrealDB create for add_credit");
-			let _: Option<GachaCreditSchema> = db
-				.create(ResourceEnum::GachaCredits.to_string())
-				.content(data)
-				.await?;
-		}
-		let elapsed = now.elapsed();
-		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
-			== "development"
-		{
-			println!("Query 'query_add_credit' took: {elapsed:.2?}");
-		}
-		Ok(())
-	}
-}
+use crate::v1::gacha_credits::gacha_credits_dto::GachaCreditRequestDto;
+use crate::AppState;
+use imphnen_libs::AppStatePostgresExt;
+use imphnen_entities::seaorm::gacha::gacha_credits::{self, Entity as GachaCreditsEntity, Column as GachaCreditsColumn};
+use anyhow::{Result, bail};
+use sea_orm::{QueryFilter, ActiveValue, EntityTrait, ColumnTrait};
+use std::time::Instant;
+use tracing::instrument;
+use uuid::Uuid;
+
+pub struct GachaCreditRepository<'a> {
+	state: &'a AppState,
+}
+
+impl<'a> GachaCreditRepository<'a> {
+	pub fn new(state: &'a AppState) -> Self {
+		Self { state }
+	}
+
+	#[instrument(skip(self, user_id), err)]
+	pub async fn query_by_user_id(
+		&self,
+		user_id: Uuid,
+	) -> Result<Option<gacha_credits::Model>> {
+		let now = Instant::now();
+		let db = self.state.postgres_db();
+
+		let result = GachaCreditsEntity::find()
+			.filter(GachaCreditsColumn::UserId.eq(user_id))
+			.filter(GachaCreditsColumn::IsDeleted.eq(false))
+			.one(db)
+			.await?;
+
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_by_user_id' took: {elapsed:.2?}");
+		}
+		Ok(result)
+	}
+
+	#[instrument(skip(self, user_id), err)]
+	pub async fn query_consume_credit(&self, user_id: Uuid) -> Result<()> {
+		let now = Instant::now();
+		let db = self.state.postgres_db();
+		let credit_opt = self.query_by_user_id(user_id).await?;
+		let Some(credit) = credit_opt else {
+			let elapsed = now.elapsed();
+			if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+				== "development"
+			{
+				println!(
+					"Query 'query_consume_credit' took: {elapsed:.2?} (no credit to consume)"
+				);
+			}
+			return Ok(());
+		};
+		if credit.available_rolls <= 0 {
+			let elapsed = now.elapsed();
+			if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+				== "development"
+			{
+				println!(
+					"Query 'query_consume_credit' took: {elapsed:.2?} (no rolls remaining)"
+				);
+			}
+			bail!("No extra roll credits remaining");
+		}
+
+		let mut active_model: gacha_credits::ActiveModel = credit.clone().into();
+		active_model.available_rolls = ActiveValue::Set(credit.available_rolls - 1);
+
+		GachaCreditsEntity::update(active_model).exec(db).await?;
+
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_consume_credit' took: {elapsed:.2?}");
+		}
+		Ok(())
+	}
+
+	#[instrument(skip(self, payload), err)]
+	pub async fn query_add_credit(
+		&self,
+		payload: GachaCreditRequestDto,
+	) -> Result<()> {
+		let now = Instant::now();
+		let db = self.state.postgres_db();
+		if let Some(credit) = self.query_by_user_id(Uuid::parse_str(&payload.user_id)?).await? {
+			let mut active_model: gacha_credits::ActiveModel = credit.clone().into();
+			active_model.available_rolls = ActiveValue::Set(credit.available_rolls + payload.amount);
+
+			GachaCreditsEntity::update(active_model).exec(db).await?;
+		} else {
+			let active_model = gacha_credits::ActiveModel {
+				id: ActiveValue::Set(uuid::Uuid::new_v4()),
+				user_id: ActiveValue::Set(Uuid::parse_str(&payload.user_id)?),
+				available_rolls: ActiveValue::Set(payload.amount),
+				is_deleted: ActiveValue::Set(false),
+				created_at: ActiveValue::Set(Some(chrono::Utc::now().naive_utc())),
+				updated_at: ActiveValue::Set(Some(chrono::Utc::now().naive_utc())),
+			};
+
+			GachaCreditsEntity::insert(active_model).exec(db).await?;
+		}
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_add_credit' took: {elapsed:.2?}");
+		}
+		Ok(())
+	}
+}

imphnen-gacha/src/v1/gacha_credits/gacha_credits_router.rs

@@ -1,9 +1,9 @@
-use axum::{Router, routing::get};
-use axum::routing::post;
-
-pub fn gacha_credit_router() -> Router {
-    Router::new()
-        .route("/", get(crate::v1::gacha_credits::GachaCreditController::get_user_credits))
-        .route("/add", post(crate::v1::gacha_credits::GachaCreditController::add_user_credits))
-        .route("/consume", post(crate::v1::gacha_credits::GachaCreditController::consume_user_credit))
+use axum::{Router, routing::get};
+use axum::routing::post;
+
+pub fn gacha_credit_router() -> Router {
+    Router::new()
+        .route("/", get(crate::v1::gacha_credits::GachaCreditController::get_user_credits))
+        .route("/add", post(crate::v1::gacha_credits::GachaCreditController::add_user_credits))
+        .route("/consume", post(crate::v1::gacha_credits::GachaCreditController::consume_user_credit))
 }

imphnen-gacha/src/v1/gacha_credits/gacha_credits_schema.rs

@@ -1,11 +1,11 @@
-use imphnen_iam::get_iso_date;
 use serde::{Deserialize, Serialize};
-use surrealdb::sql::Thing;
+use uuid::Uuid;
+use imphnen_utils::{get_iso_date};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct GachaCreditSchema {
-	pub id: Thing,
-	pub user: Thing,
+	pub id: String,
+	pub user: String,
 	pub available_rolls: i32,
 	pub is_deleted: bool,
 	pub created_at: Option<String>,
@@ -15,8 +15,8 @@ pub struct GachaCreditSchema {
 impl Default for GachaCreditSchema {
 	fn default() -> Self {
 		GachaCreditSchema {
-			id: Thing::from(("app_gacha_credits", "uuid")),
-			user: Thing::from(("app_users", "uuid")),
+			id: Uuid::new_v4().to_string(),
+			user: Uuid::new_v4().to_string(),
 			available_rolls: 0,
 			is_deleted: false,
 			created_at: Some(get_iso_date()),

imphnen-gacha/src/v1/gacha_credits/gacha_credits_service.rs

@@ -1,97 +1,115 @@
-use crate::AppState;
-use imphnen_entities::ResponseSuccessDto;
-use imphnen_utils::{errors::AppError, error_response};
-use imphnen_utils::{common_response, success_response, validate_request};
-use crate::v1::gacha_credits::gacha_credits_dto::{GachaCreditRequestDto, GachaCreditResponseDto};
-use crate::v1::gacha_credits::gacha_credits_repository::GachaCreditRepository;
-use axum::http::StatusCode;
-use axum::response::Response;
-use imphnen_iam::UsersRepository;
-use imphnen_utils::extract_email;
-
-pub struct GachaCreditService;
-
-impl GachaCreditService {
-    pub async fn get_user_credits(headers: &axum::http::HeaderMap, state: &AppState) -> Response {
-        let repo = GachaCreditRepository::new(state);
-        let repo_user = UsersRepository::new(state);
-        let Some(email) = extract_email(headers) else {
-                    return error_response(AppError::AuthenticationError("Unauthorized".into()));
-        };
-        
-        let Ok(user) = repo_user.query_user_by_email(email.to_string()).await else {
-                    return error_response(AppError::NotFoundError("User not found".into()));
-        };
-
-        match repo.query_by_user_id(user.id.id.to_raw()).await {
-            Ok(Some(credit)) => {
-                let response_dto = GachaCreditResponseDto::from(&credit);
-                success_response(ResponseSuccessDto { data: response_dto })
-            }
-            Ok(None) => {
-                // Return empty credits if no record exists
-                let response_dto = GachaCreditResponseDto {
-                    id: "".to_string(),
-                    user_id: user.id.id.to_raw(),
-                    available_rolls: 0,
-                    is_deleted: false,
-                    created_at: None,
-                    updated_at: None,
-                };
-                success_response(ResponseSuccessDto { data: response_dto })
-            }
-            Err(e) => error_response(AppError::InternalServerError(e.to_string())),
-        }
-    }
-
-    pub async fn add_user_credits(
-        headers: &axum::http::HeaderMap,
-        state: &AppState,
-        payload: GachaCreditRequestDto,
-    ) -> Response {
-        if let Err((status, message)) = validate_request(&payload) {
-            return common_response(status, &message);
-        }
-
-        let repo = GachaCreditRepository::new(state);
-        let repo_user = UsersRepository::new(state);
-        let Some(email) = extract_email(headers) else {
-                    return error_response(AppError::AuthenticationError("Unauthorized".into()));
-        };
-        
-        let Ok(user) = repo_user.query_user_by_email(email.to_string()).await else {
-                    return error_response(AppError::NotFoundError("User not found".into()));
-        };
-
-        // Ensure the user can only modify their own credits
-        if payload.user_id != user.id.id.to_raw() {
-            return error_response(AppError::AuthorizationError("You can only modify your own credits".into()));
-        }
-
-        let amount = payload.amount; // Extract amount before moving payload
-        match repo.query_add_credit(payload).await {
-            Ok(_) => common_response(
-                StatusCode::OK,
-                &format!("Added {} credits successfully", amount)
-            ),
-            Err(e) => error_response(AppError::InternalServerError(e.to_string())),
-        }
-    }
-
-    pub async fn consume_user_credit(headers: &axum::http::HeaderMap, state: &AppState) -> Response {
-        let repo = GachaCreditRepository::new(state);
-        let repo_user = UsersRepository::new(state);
-        let Some(email) = extract_email(headers) else {
-                    return error_response(AppError::AuthenticationError("Unauthorized".into()));
-        };
-        
-        let Ok(user) = repo_user.query_user_by_email(email.to_string()).await else {
-                    return error_response(AppError::NotFoundError("User not found".into()));
-        };
-
-        match repo.query_consume_credit(user.id.id.to_raw()).await {
-            Ok(_) => common_response(StatusCode::OK, "Consumed 1 credit successfully"),
-            Err(e) => error_response(AppError::BadRequestError(e.to_string())),
-        }
-    }
+use crate::AppState;
+use imphnen_entities::ResponseSuccessDto;
+use imphnen_utils::{errors::AppError, error_response};
+use imphnen_utils::{common_response, success_response, validate_request};
+use uuid::Uuid;
+use crate::v1::gacha_credits::gacha_credits_dto::{GachaCreditRequestDto, GachaCreditResponseDto};
+use crate::v1::gacha_credits::gacha_credits_repository::GachaCreditRepository;
+use axum::http::StatusCode;
+use axum::response::Response;
+use imphnen_iam::UsersRepository;
+use imphnen_utils::extract_email;
+
+pub struct GachaCreditService;
+
+impl GachaCreditService {
+    pub async fn get_user_credits(headers: &axum::http::HeaderMap, state: &AppState) -> Response {
+        let repo = GachaCreditRepository::new(state);
+        let repo_user = UsersRepository::new(state);
+        let Some(email) = extract_email(headers) else {
+                    return error_response(AppError::AuthenticationError("Unauthorized".into()));
+        };
+        
+        let Ok(user) = repo_user.query_user_by_email(email.to_string()).await else {
+                    return error_response(AppError::NotFoundError("User not found".into()));
+        };
+        
+        let parsed_user_id = match Uuid::parse_str(&user.id) {
+            Ok(uuid) => uuid,
+            Err(e) => return error_response(AppError::BadRequestError(format!("Invalid User ID format: {}", e))),
+        };
+
+        match repo.query_by_user_id(parsed_user_id).await {
+            Ok(Some(credit)) => {
+                let response_dto = GachaCreditResponseDto {
+                    id: credit.id.to_string(),
+                    user_id: credit.user_id.to_string(),
+                    available_rolls: credit.available_rolls,
+                    is_deleted: credit.is_deleted,
+                    created_at: credit.created_at.map(|d| d.to_string()),
+                    updated_at: credit.updated_at.map(|d| d.to_string()),
+                };
+                success_response(ResponseSuccessDto { data: response_dto })
+            }
+            Ok(None) => {
+                // Return empty credits if no record exists
+                let response_dto = GachaCreditResponseDto {
+                    id: "".to_string(),
+                    user_id: user.id,
+                    available_rolls: 0,
+                    is_deleted: false,
+                    created_at: None,
+                    updated_at: None,
+                };
+                success_response(ResponseSuccessDto { data: response_dto })
+            }
+            Err(e) => error_response(AppError::InternalServerError(e.to_string())),
+        }
+    }
+
+    pub async fn add_user_credits(
+        headers: &axum::http::HeaderMap,
+        state: &AppState,
+        payload: GachaCreditRequestDto,
+    ) -> Response {
+        if let Err((status, message)) = validate_request(&payload) {
+            return common_response(status, &message);
+        }
+
+        let repo = GachaCreditRepository::new(state);
+        let repo_user = UsersRepository::new(state);
+        let Some(email) = extract_email(headers) else {
+                    return error_response(AppError::AuthenticationError("Unauthorized".into()));
+        };
+        
+        let Ok(user) = repo_user.query_user_by_email(email.to_string()).await else {
+                    return error_response(AppError::NotFoundError("User not found".into()));
+        };
+
+        // Ensure the user can only modify their own credits
+        if payload.user_id != user.id {
+            return error_response(AppError::AuthorizationError("You can only modify your own credits".into()));
+        }
+
+        let amount = payload.amount; // Extract amount before moving payload
+        match repo.query_add_credit(payload).await {
+            Ok(_) => common_response(
+                StatusCode::OK,
+                &format!("Added {} credits successfully", amount)
+            ),
+            Err(e) => error_response(AppError::InternalServerError(e.to_string())),
+        }
+    }
+
+    pub async fn consume_user_credit(headers: &axum::http::HeaderMap, state: &AppState) -> Response {
+        let repo = GachaCreditRepository::new(state);
+        let repo_user = UsersRepository::new(state);
+        let Some(email) = extract_email(headers) else {
+                    return error_response(AppError::AuthenticationError("Unauthorized".into()));
+        };
+        
+        let Ok(user) = repo_user.query_user_by_email(email.to_string()).await else {
+                    return error_response(AppError::NotFoundError("User not found".into()));
+        };
+
+        let parsed_user_id = match Uuid::parse_str(&user.id) {
+            Ok(uuid) => uuid,
+            Err(e) => return error_response(AppError::BadRequestError(format!("Invalid User ID format: {}", e))),
+        };
+
+        match repo.query_consume_credit(parsed_user_id).await {
+            Ok(_) => common_response(StatusCode::OK, "Consumed 1 credit successfully"),
+            Err(e) => error_response(AppError::BadRequestError(e.to_string())),
+        }
+    }
 }

imphnen-gacha/src/v1/gacha_credits/mod.rs

@@ -1,13 +1,13 @@
-pub mod gacha_credits_controller;
-pub mod gacha_credits_dto;
-pub mod gacha_credits_repository;
-pub mod gacha_credits_schema;
-pub mod gacha_credits_service;
-pub mod gacha_credits_router;
-
-// Export only public types and functions
-pub use gacha_credits_controller::GachaCreditController;
-pub use gacha_credits_dto::{GachaCreditRequestDto, GachaCreditResponseDto};
-pub use gacha_credits_repository::GachaCreditRepository;
-pub use gacha_credits_service::GachaCreditService;
-pub use gacha_credits_router::gacha_credit_router;
+pub mod gacha_credits_controller;
+pub mod gacha_credits_dto;
+pub mod gacha_credits_repository;
+pub mod gacha_credits_schema;
+pub mod gacha_credits_service;
+pub mod gacha_credits_router;
+
+// Export only public types and functions
+pub use gacha_credits_controller::GachaCreditController;
+pub use gacha_credits_dto::{GachaCreditRequestDto, GachaCreditResponseDto};
+pub use gacha_credits_repository::GachaCreditRepository;
+pub use gacha_credits_service::GachaCreditService;
+pub use gacha_credits_router::gacha_credit_router;

imphnen-gacha/src/v1/gacha_items/gacha_items_controller.rs

@@ -1,131 +1,131 @@
-use crate::{AppState, MetaRequestDto, ResponseListSuccessDto, ResponseSuccessDto};
-use imphnen_entities::MessageResponseDto;
-use crate::v1::gacha_items::GachaItemDto;
-use crate::v1::gacha_items::gacha_items_dto::{GachaItemRequestDto, GachaItemUpdateRequestDto};
-use crate::v1::gacha_items::gacha_items_service::GachaItemService;
-use axum::{
-	Extension,
-	extract::{Path, Query},
-	http::HeaderMap,
-	response::IntoResponse,
-};
-use imphnen_iam::{PermissionsEnum, require_permissions};
-use imphnen_libs::ValidatedJson;
-
-#[utoipa::path(
-    get,
-    path = "/v1/gacha/items",
-    security(
-        ("Bearer" = [])
-    ),
-    params(
-        ("page" = Option<i64>, Query, description = "Page number"),
-        ("per_page" = Option<i64>, Query, description = "Items per page"),
-        ("search" = Option<String>, Query, description = "Search keyword"),
-        ("sort_by" = Option<String>, Query, description = "Sort by field"),
-        ("order" = Option<String>, Query, description = "Order ASC or DESC"),
-        ("filter" = Option<String>, Query, description = "Filter value"),
-        ("filter_by" = Option<String>, Query, description = "Field to filter by"),
-    ),
-    responses(
-        (status = 200, description = "[ADMIN] Get gacha item list", body = ResponseListSuccessDto<Vec<GachaItemDto>>)
-    ),
-    tag = "Gacha"
-)]
-pub async fn get_gacha_item_list(
-	headers: HeaderMap,
-	Extension(state): Extension<AppState>,
-	Query(meta): Query<MetaRequestDto>,
-) -> impl IntoResponse {
-	require_permissions!(headers, state, [PermissionsEnum::ReadListGachaItems], {
-		GachaItemService::get_gacha_item_list(&state, meta).await
-	})
-}
-
-#[utoipa::path(
-    get,
-    path = "/v1/gacha/items/detail/{id}",
-    security(
-        ("Bearer" = [])
-    ),
-    params(("id" = String, Path, description = "Gacha Item ID")),
-    responses(
-        (status = 200, description = "[ADMIN] Get gacha item by ID", body = ResponseSuccessDto<GachaItemDto>)
-    ),
-    tag = "Gacha"
-)]
-pub async fn get_gacha_item_by_id(
-	headers: HeaderMap,
-	Extension(state): Extension<AppState>,
-	Path(id): Path<String>,
-) -> impl IntoResponse {
-	require_permissions!(headers, state, [PermissionsEnum::ReadDetailGachaItems], {
-		GachaItemService::get_gacha_item_by_id(&state, id).await
-	})
-}
-
-#[utoipa::path(
-    post,
-    path = "/v1/gacha/items/create",
-    security(
-        ("Bearer" = [])
-    ),
-    request_body = GachaItemRequestDto,
-    responses(
-        (status = 201, description = "[ADMIN] Create gacha item", body = MessageResponseDto)
-    ),
-    tag = "Gacha"
-)]
-pub async fn post_create_gacha_item(
-	headers: HeaderMap,
-	Extension(state): Extension<AppState>,
-	ValidatedJson(payload): ValidatedJson<GachaItemRequestDto>,
-) -> impl IntoResponse {
-	require_permissions!(headers, state, [PermissionsEnum::CreateGachaItems], {
-		GachaItemService::create_gacha_item(&state, payload).await
-	})
-}
-
-#[utoipa::path(
-    put,
-    path = "/v1/gacha/items/update/{id}",
-    security(
-        ("Bearer" = [])
-    ),
-    request_body = GachaItemUpdateRequestDto,
-    responses(
-        (status = 200, description = "[ADMIN] Update gacha item", body = MessageResponseDto)
-    ),
-    tag = "Gacha"
-)]
-pub async fn put_update_gacha_item(
-	headers: HeaderMap,
-	Extension(state): Extension<AppState>,
-	Path(id): Path<String>,
-	ValidatedJson(payload): ValidatedJson<GachaItemUpdateRequestDto>,
-) -> impl IntoResponse {
-	require_permissions!(headers, state, [PermissionsEnum::UpdateGachaItems], {
-		GachaItemService::update_gacha_item(&state, payload, id).await
-	})
-}
-
-#[utoipa::path(
-    delete,
-    path = "/v1/gacha/items/delete/{id}",
-    security(
-        ("Bearer" = [])
-    ),
-    responses(
-        (status = 200, description = "[ADMIN] Delete gacha item", body = MessageResponseDto)
-    ),
-    tag = "Gacha"
-)]
-pub async fn delete_gacha_item(
-	headers: HeaderMap,
-	Extension(state): Extension<AppState>,
-	Path(id): Path<String>,
-) -> impl IntoResponse {
-	require_permissions!(headers, state, [PermissionsEnum::DeleteGachaItems], {
-		GachaItemService::delete_gacha_item(&state, id).await
-	})
-}
+use crate::{AppState, MetaRequestDto, ResponseListSuccessDto, ResponseSuccessDto};
+use imphnen_entities::MessageResponseDto;
+use crate::v1::gacha_items::GachaItemDto;
+use crate::v1::gacha_items::gacha_items_dto::{GachaItemRequestDto, GachaItemUpdateRequestDto};
+use crate::v1::gacha_items::gacha_items_service::GachaItemService;
+use axum::{
+	Extension,
+	extract::{Path, Query},
+	http::HeaderMap,
+	response::IntoResponse,
+};
+use imphnen_iam::{PermissionsEnum, require_permissions};
+use imphnen_libs::ValidatedJson;
+
+#[utoipa::path(
+    get,
+    path = "/v1/gacha/items",
+    security(
+        ("Bearer" = [])
+    ),
+    params(
+        ("page" = Option<i64>, Query, description = "Page number"),
+        ("per_page" = Option<i64>, Query, description = "Items per page"),
+        ("search" = Option<String>, Query, description = "Search keyword"),
+        ("sort_by" = Option<String>, Query, description = "Sort by field"),
+        ("order" = Option<String>, Query, description = "Order ASC or DESC"),
+        ("filter" = Option<String>, Query, description = "Filter value"),
+        ("filter_by" = Option<String>, Query, description = "Field to filter by"),
+    ),
+    responses(
+        (status = 200, description = "[ADMIN] Get gacha item list", body = ResponseListSuccessDto<Vec<GachaItemDto>>)
+    ),
+    tag = "Gacha"
+)]
+pub async fn get_gacha_item_list(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Query(meta): Query<MetaRequestDto>,
+) -> impl IntoResponse {
+	require_permissions!(headers, state, [PermissionsEnum::ReadListGachaItems], {
+		GachaItemService::get_gacha_item_list(&state, meta).await
+	})
+}
+
+#[utoipa::path(
+    get,
+    path = "/v1/gacha/items/detail/{id}",
+    security(
+        ("Bearer" = [])
+    ),
+    params(("id" = String, Path, description = "Gacha Item ID")),
+    responses(
+        (status = 200, description = "[ADMIN] Get gacha item by ID", body = ResponseSuccessDto<GachaItemDto>)
+    ),
+    tag = "Gacha"
+)]
+pub async fn get_gacha_item_by_id(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+) -> impl IntoResponse {
+	require_permissions!(headers, state, [PermissionsEnum::ReadDetailGachaItems], {
+		GachaItemService::get_gacha_item_by_id(&state, id).await
+	})
+}
+
+#[utoipa::path(
+    post,
+    path = "/v1/gacha/items/create",
+    security(
+        ("Bearer" = [])
+    ),
+    request_body = GachaItemRequestDto,
+    responses(
+        (status = 201, description = "[ADMIN] Create gacha item", body = MessageResponseDto)
+    ),
+    tag = "Gacha"
+)]
+pub async fn post_create_gacha_item(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	ValidatedJson(payload): ValidatedJson<GachaItemRequestDto>,
+) -> impl IntoResponse {
+	require_permissions!(headers, state, [PermissionsEnum::CreateGachaItems], {
+		GachaItemService::create_gacha_item(&state, payload).await
+	})
+}
+
+#[utoipa::path(
+    put,
+    path = "/v1/gacha/items/update/{id}",
+    security(
+        ("Bearer" = [])
+    ),
+    request_body = GachaItemUpdateRequestDto,
+    responses(
+        (status = 200, description = "[ADMIN] Update gacha item", body = MessageResponseDto)
+    ),
+    tag = "Gacha"
+)]
+pub async fn put_update_gacha_item(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+	ValidatedJson(payload): ValidatedJson<GachaItemUpdateRequestDto>,
+) -> impl IntoResponse {
+	require_permissions!(headers, state, [PermissionsEnum::UpdateGachaItems], {
+		GachaItemService::update_gacha_item(&state, payload, id).await
+	})
+}
+
+#[utoipa::path(
+    delete,
+    path = "/v1/gacha/items/delete/{id}",
+    security(
+        ("Bearer" = [])
+    ),
+    responses(
+        (status = 200, description = "[ADMIN] Delete gacha item", body = MessageResponseDto)
+    ),
+    tag = "Gacha"
+)]
+pub async fn delete_gacha_item(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+) -> impl IntoResponse {
+	require_permissions!(headers, state, [PermissionsEnum::DeleteGachaItems], {
+		GachaItemService::delete_gacha_item(&state, id).await
+	})
+}

imphnen-gacha/src/v1/gacha_items/gacha_items_dto.rs

@@ -1,67 +1,95 @@
-use crate::v1::gacha_items::gacha_items_schema::GachaItemSchema;
-use lazy_static::lazy_static;
-use regex::Regex;
-use serde::{Deserialize, Serialize};
-use utoipa::ToSchema;
-use validator::{Validate, ValidationError};
-
-// Custom validator for image URLs
-pub fn validate_image_url(url: &str) -> Result<(), ValidationError> {
-	lazy_static! {
-		static ref IMAGE_URL_REGEX: Regex = Regex::new(r"^https?://[^\s]+\.(jpg|jpeg|png|gif|webp)$").unwrap();
-	}
-	if IMAGE_URL_REGEX.is_match(url) {
-		Ok(())
-	} else {
-		Err(ValidationError::new("invalid_image_url"))
-	}
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
-pub struct GachaItemRequestDto {
-	#[validate(length(min = 1, max = 100, message = "Item name must be between 1 and 100 characters"))]
-	pub name: String,
-	
-	#[validate(length(min = 1, message = "Image URL must not be empty"))]
-	#[validate(custom(
-		function = "validate_image_url",
-		message = "Image URL must be a valid URL pointing to JPG, JPEG, PNG, GIF, or WebP image"
-	))]
-	pub image_url: String,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
-pub struct GachaItemUpdateRequestDto {
-	#[validate(length(min = 1, max = 100, message = "Item name must be between 1 and 100 characters"))]
-	#[serde(skip_serializing_if = "Option::is_none")]
-	pub name: Option<String>,
-	
-	#[validate(length(min = 1, message = "Image URL must not be empty"))]
-	#[validate(custom(
-		function = "validate_image_url",
-		message = "Image URL must be a valid URL pointing to JPG, JPEG, PNG, GIF, or WebP image"
-	))]
-	#[serde(skip_serializing_if = "Option::is_none")]
-	pub image_url: Option<String>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
-pub struct GachaItemDto {
-	pub id: String,
-	pub name: String,
-	pub is_deleted: bool,
-	pub created_at: Option<String>,
-	pub updated_at: Option<String>,
-}
-
-impl GachaItemDto {
-	pub fn from(dto: GachaItemSchema) -> Self {
-		Self {
-			id: dto.id.id.to_raw(),
-			name: dto.name,
-			is_deleted: dto.is_deleted,
-			created_at: dto.created_at,
-			updated_at: dto.updated_at,
-		}
-	}
-}
+use crate::v1::gacha_items::gacha_items_schema::GachaItemSchema;
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+use serde_json::Value; // Add this import
+use std::sync::LazyLock;
+use utoipa::ToSchema;
+use validator::{Validate, ValidationError};
+
+// Custom validator for image URLs
+static IMAGE_URL_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^https?://[^\s]+\.(jpg|jpeg|png|gif|webp)$").unwrap());
+
+pub fn validate_image_url(url: &str) -> Result<(), ValidationError> {
+	if IMAGE_URL_REGEX.is_match(url) {
+		Ok(())
+	} else {
+		Err(ValidationError::new("invalid_image_url"))
+	}
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
+pub struct GachaItemRequestDto {
+	#[validate(length(min = 1, max = 100, message = "Item code must be between 1 and 100 characters"))]
+	pub item_code: String,
+
+	#[validate(length(min = 1, max = 100, message = "Item name must be between 1 and 100 characters"))]
+	pub name: String,
+	
+	#[validate(length(min = 1, max = 500, message = "Description must be between 1 and 500 characters"))]
+	pub description: String,
+
+	#[validate(length(min = 1, max = 50, message = "Rarity must be between 1 and 50 characters"))]
+	pub rarity: String,
+
+	#[validate(length(min = 1, max = 50, message = "Type must be between 1 and 50 characters"))]
+	pub type_: String,
+
+	#[validate(length(min = 1, max = 50, message = "Category must be between 1 and 50 characters"))]
+	pub category: String,
+
+	#[validate(range(min = 0, message = "Value must be non-negative"))]
+	pub value: i32,
+
+	#[validate(range(min = 0.0, message = "Weight must be non-negative"))]
+	pub weight: f64,
+
+	#[validate(range(min = 0, message = "Stock must be non-negative"))]
+	pub stock: i32,
+
+	pub is_limited: bool,
+
+	pub metadata: Option<Value>,
+
+	#[validate(length(min = 1, message = "Image URL must not be empty"))]
+	#[validate(custom(
+		function = "validate_image_url",
+		message = "Image URL must be a valid URL pointing to JPG, JPEG, PNG, GIF, or WebP image"
+	))]
+	pub image_url: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
+pub struct GachaItemUpdateRequestDto {
+	#[validate(length(min = 1, max = 100, message = "Item name must be between 1 and 100 characters"))]
+	#[serde(skip_serializing_if = "Option::is_none")]
+	pub name: Option<String>,
+	
+	#[validate(length(min = 1, message = "Image URL must not be empty"))]
+	#[validate(custom(
+		function = "validate_image_url",
+		message = "Image URL must be a valid URL pointing to JPG, JPEG, PNG, GIF, or WebP image"
+	))]
+	#[serde(skip_serializing_if = "Option::is_none")]
+	pub image_url: Option<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct GachaItemDto {
+	pub id: String,
+	pub name: String,
+	pub is_deleted: bool,
+	pub created_at: Option<String>,
+	pub updated_at: Option<String>,
+}
+
+impl GachaItemDto {
+	pub fn from(dto: GachaItemSchema) -> Self {
+		Self {
+			id: dto.id.to_string(),
+			name: dto.name,
+			is_deleted: dto.is_deleted,
+			created_at: dto.created_at,
+			updated_at: dto.updated_at,
+		}
+	}
+}

imphnen-gacha/src/v1/gacha_items/gacha_items_repository.rs

@@ -1,14 +1,13 @@
 use crate::v1::gacha_items::gacha_items_schema::GachaItemSchema;
-use crate::{AppState, MetaRequestDto, ResponseListSuccessDto, get_id, make_thing};
 use crate::v1::gacha_items::GachaItemDto;
-use imphnen_libs::ResourceEnum;
+use crate::{AppState, MetaRequestDto, ResponseListSuccessDto};
 use anyhow::{Result, bail};
-use imphnen_iam::QueryListBuilder;
-use imphnen_utils::get_iso_date;
-use serde_json::{Map, Value};
+// QueryListBuilder is not available in imphnen-iam, need to implement locally or use alternative
 use std::time::Instant;
 use tracing::instrument;
-use tracing::info;
+use sea_orm::{EntityTrait, ColumnTrait, QueryFilter, QueryOrder, PaginatorTrait, ActiveModelTrait, ActiveValue, QuerySelect};
+use imphnen_entities::seaorm::gacha::gacha_items::{Entity as GachaItemEntity, Column as GachaItemColumn, ActiveModel as GachaItemActiveModel};
+use uuid::Uuid;
 
 pub struct GachaItemRepository<'a> {
 	state: &'a AppState,
@@ -25,57 +24,124 @@ impl<'a> GachaItemRepository<'a> {
 		meta: MetaRequestDto,
 	) -> Result<ResponseListSuccessDto<Vec<GachaItemDto>>> {
 		let now = Instant::now();
-		let surreal_query = format!(
-			"SELECT * FROM {} WHERE is_deleted = false AND name LIKE ?",
-			ResourceEnum::GachaItems
-		);
-		info!(query = %surreal_query, "Executing SurrealDB query");
-		let raw_result: ResponseListSuccessDto<Vec<GachaItemSchema>> =
-			QueryListBuilder::new(
-				&self.state.surrealdb_ws,
-				&ResourceEnum::GachaItems.to_string(),
-				&meta,
-			)
-			.with_condition("is_deleted = false")
-			.search_field("name")
-			.select_fields(vec!["*"])
-			.build()
+		let db = &self.state.postgres_connection.conn;
+		
+		let query = GachaItemEntity::find()
+			.filter(GachaItemColumn::DeletedAt.is_null());
+		
+		// Apply search if provided
+		let query = if let Some(search) = &meta.search {
+			query.filter(GachaItemColumn::Name.contains(search))
+		} else {
+			query
+		};
+		
+		// Apply sorting
+		let query = if let Some(sort_by) = &meta.sort_by {
+			match sort_by.as_str() {
+				"name" => {
+					if meta.order.as_deref() == Some("desc") {
+						query.order_by_desc(GachaItemColumn::Name)
+					} else {
+						query.order_by_asc(GachaItemColumn::Name)
+					}
+				}
+				"created_at" => {
+					if meta.order.as_deref() == Some("desc") {
+						query.order_by_desc(GachaItemColumn::CreatedAt)
+					} else {
+						query.order_by_asc(GachaItemColumn::CreatedAt)
+					}
+				}
+				_ => query.order_by_desc(GachaItemColumn::CreatedAt),
+			}
+		} else {
+			query.order_by_desc(GachaItemColumn::CreatedAt)
+		};
+		
+		// Get total count
+		let total_count = query.clone().count(db).await?;
+		
+		// Apply pagination
+		let page = meta.page.unwrap_or(1);
+		let limit = meta.per_page.unwrap_or(10);
+		let offset = (page - 1) * limit;
+		
+		let items = query
+			.offset(offset)
+			.limit(limit)
+			.all(db)
 			.await?;
+		
+		let data: Vec<GachaItemDto> = items
+			.into_iter()
+			.map(|item| GachaItemDto {
+				id: item.id.to_string(),
+				name: item.name,
+				is_deleted: item.deleted_at.is_some(),
+				created_at: Some(item.created_at.to_string()),
+				updated_at: Some(item.updated_at.to_string()),
+			})
+			.collect();
+		
+		let _total_pages = (total_count as f64 / limit as f64).ceil() as u32;
+		
 		let elapsed = now.elapsed();
 		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
 			== "development"
 		{
 			println!("Query 'query_gacha_item_list' took: {elapsed:.2?}");
 		}
-		let data = raw_result
-			.data
-			.into_iter()
-			.map(GachaItemDto::from)
-			.collect();
+		
 		Ok(ResponseListSuccessDto {
 			data,
-			meta: raw_result.meta,
+			meta: Some(imphnen_libs::MetaResponseDto {
+				page: Some(page),
+				per_page: Some(limit),
+				total: Some(total_count),
+			}),
 		})
 	}
 
 	#[instrument(skip(self, id), err)]
 	pub async fn query_gacha_item_by_id(&self, id: String) -> Result<GachaItemSchema> {
 		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		let surreal_query = format!("SELECT * FROM {} WHERE id = '{}'", ResourceEnum::GachaItems, id);
-		info!(query = %surreal_query, "Executing SurrealDB query");
-		let result: Option<GachaItemSchema> = db
-			.select((ResourceEnum::GachaItems.to_string(), id.clone()))
+		let db = &self.state.postgres_connection.conn;
+		
+		let uuid_id = Uuid::parse_str(&id)?;
+		
+		let item = GachaItemEntity::find_by_id(uuid_id)
+			.filter(GachaItemColumn::DeletedAt.is_null())
+			.one(db)
 			.await?;
+		
 		let elapsed = now.elapsed();
 		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
 			== "development"
 		{
 			println!("Query 'query_gacha_item_by_id' took: {elapsed:.2?}");
 		}
-		match result {
-			Some(item) if !item.is_deleted => Ok(item),
-			_ => bail!("Gacha Item not found"),
+		
+		match item {
+			Some(item) => Ok(GachaItemSchema {
+				id: item.id.to_string(),
+				item_code: item.item_code,
+				name: item.name,
+				description: item.description,
+				rarity: item.rarity,
+				type_: item.type_,
+				category: item.category,
+				value: item.value,
+				weight: item.weight,
+				stock: item.stock,
+				is_limited: item.is_limited,
+				metadata: item.metadata,
+				image_url: "".to_string(), // Not present in DB model
+				is_deleted: item.deleted_at.is_some(),
+				created_at: Some(item.created_at.to_string()),
+				updated_at: Some(item.updated_at.to_string()),
+			}),
+			None => bail!("Gacha Item not found"),
 		}
 	}
 
@@ -85,23 +151,36 @@ impl<'a> GachaItemRepository<'a> {
 		data: GachaItemSchema,
 	) -> Result<String> {
 		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		let surreal_query = format!("CREATE {} CONTENT ...", ResourceEnum::GachaItems);
-		info!(query = %surreal_query, "Executing SurrealDB query");
-		let record: Option<GachaItemSchema> = db
-			.create(ResourceEnum::GachaItems.to_string())
-			.content(data)
-			.await?;
+		let db = &self.state.postgres_connection.conn;
+		
+		let active_model = GachaItemActiveModel {
+			id: ActiveValue::Set(Uuid::new_v4()),
+			item_code: ActiveValue::Set(data.item_code),
+			name: ActiveValue::Set(data.name),
+			description: ActiveValue::Set(data.description),
+			rarity: ActiveValue::Set(data.rarity),
+			type_: ActiveValue::Set(data.type_),
+			category: ActiveValue::Set(data.category),
+			value: ActiveValue::Set(data.value),
+			weight: ActiveValue::Set(data.weight),
+			stock: ActiveValue::Set(data.stock),
+			is_limited: ActiveValue::Set(data.is_limited),
+			metadata: ActiveValue::Set(data.metadata),
+			created_at: ActiveValue::Set(chrono::Utc::now()),
+			updated_at: ActiveValue::Set(chrono::Utc::now()),
+			deleted_at: ActiveValue::NotSet,
+		};
+		
+		let result = active_model.insert(db).await?;
+		
 		let elapsed = now.elapsed();
 		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
 			== "development"
 		{
 			println!("Query 'query_create_gacha_item' took: {elapsed:.2?}");
 		}
-		match record {
-			Some(_) => Ok("Success create Gacha Item".into()),
-			None => bail!("Failed to create Gacha Item"),
-		}
+		
+		Ok(result.id.to_string())
 	}
 
 	#[instrument(skip(self, data), err)]
@@ -110,58 +189,70 @@ impl<'a> GachaItemRepository<'a> {
 		data: GachaItemSchema,
 	) -> Result<String> {
 		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		let record_key = get_id(&data.id)?;
-		let existing = self.query_gacha_item_by_id(data.id.id.to_raw()).await?;
-		if existing.is_deleted {
-			bail!("Gacha Item already deleted");
-		}
-		let merged = GachaItemSchema {
-			created_at: existing.created_at,
-			..data.clone()
-		};
-		let surreal_query = format!("UPDATE {:?} MERGE ...", record_key);
-		info!(query = %surreal_query, "Executing SurrealDB query");
-		let record: Option<GachaItemSchema> =
-			db.update(record_key).merge(merged).await?;
+		let db = &self.state.postgres_connection.conn;
+		
+		let uuid_id = Uuid::parse_str(&data.id)?;
+		
+		let mut active_model: GachaItemActiveModel = GachaItemEntity::find_by_id(uuid_id)
+			.one(db)
+			.await?
+			.ok_or_else(|| anyhow::anyhow!("Gacha Item not found"))?
+			.into();
+		
+		active_model.item_code = ActiveValue::Set(data.item_code);
+		active_model.name = ActiveValue::Set(data.name);
+		active_model.description = ActiveValue::Set(data.description);
+		active_model.rarity = ActiveValue::Set(data.rarity);
+		active_model.type_ = ActiveValue::Set(data.type_);
+		active_model.category = ActiveValue::Set(data.category);
+		active_model.value = ActiveValue::Set(data.value);
+		active_model.weight = ActiveValue::Set(data.weight);
+		active_model.stock = ActiveValue::Set(data.stock);
+		active_model.is_limited = ActiveValue::Set(data.is_limited);
+		active_model.metadata = ActiveValue::Set(data.metadata);
+		active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
+		
+		let _result = active_model.update(db).await?;
+		
 		let elapsed = now.elapsed();
 		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
 			== "development"
 		{
 			println!("Query 'query_update_gacha_item' took: {elapsed:.2?}");
 		}
-		match record {
-			Some(_) => Ok("Success update Gacha Item".into()),
-			None => bail!("Failed to update Gacha Item"),
-		}
+		
+		Ok("Success update Gacha Item".into())
 	}
 
 	#[instrument(skip(self, id), err)]
 	pub async fn query_delete_gacha_item(&self, id: String) -> Result<String> {
 		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		let item_id = make_thing(&ResourceEnum::GachaItems.to_string(), &id);
-		let item = self.query_gacha_item_by_id(item_id.id.to_raw()).await?;
-		if item.is_deleted {
+		let db = &self.state.postgres_connection.conn;
+		
+		let uuid_id = Uuid::parse_str(&id)?;
+		
+		let mut active_model: GachaItemActiveModel = GachaItemEntity::find_by_id(uuid_id)
+			.one(db)
+			.await?
+			.ok_or_else(|| anyhow::anyhow!("Gacha Item not found"))?
+			.into();
+		
+		if active_model.deleted_at.is_set() {
 			bail!("Gacha Item already deleted");
 		}
-		let record_key = get_id(&item.id)?;
-		let mut patch = Map::new();
-		patch.insert("is_deleted".to_string(), Value::Bool(true));
-		patch.insert("updated_at".to_string(), Value::String(get_iso_date()));
-
-		let surreal_query = format!("UPDATE {:?} MERGE ...", record_key);
-		info!(query = %surreal_query, "Executing SurrealDB query");
-		let record: Option<GachaItemSchema> = db.update(record_key).merge(patch).await?;
+		
+		active_model.deleted_at = ActiveValue::Set(Some(chrono::Utc::now()));
+		active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
+		
+		active_model.update(db).await?;
+		
 		let elapsed = now.elapsed();
 		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
 			== "development"
 		{
 			println!("Query 'query_delete_gacha_item' took: {elapsed:.2?}");
 		}
-		match record {
-			Some(_) => Ok("Success soft delete Gacha Item".into()),
-			None => bail!("Failed to soft delete Gacha Item"),
-		}
+		
+		Ok("Success soft delete Gacha Item".into())
 	}
 }

imphnen-gacha/src/v1/gacha_items/gacha_items_schema.rs

@@ -1,15 +1,23 @@
-use crate::make_thing;
-use imphnen_iam::get_iso_date;
-use imphnen_libs::ResourceEnum;
 use serde::{Deserialize, Serialize};
-use surrealdb::{Uuid, sql::Thing};
+use uuid::Uuid;
+use serde_json::Value;
 
 use crate::v1::gacha_items::gacha_items_dto::GachaItemRequestDto;
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct GachaItemSchema {
-	pub id: Thing,
+	pub id: String,
+	pub item_code: String,
 	pub name: String,
+	pub description: String,
+	pub rarity: String,
+	pub type_: String,
+	pub category: String,
+	pub value: i32,
+	pub weight: f64,
+	pub stock: i32,
+	pub is_limited: bool,
+	pub metadata: Option<Value>,
 	pub image_url: String,
 	pub is_deleted: bool,
 	pub created_at: Option<String>,
@@ -19,15 +27,22 @@ pub struct GachaItemSchema {
 impl Default for GachaItemSchema {
 	fn default() -> Self {
 		GachaItemSchema {
-			id: make_thing(
-				&ResourceEnum::GachaItems.to_string(),
-				&Uuid::new_v4().to_string(),
-			),
+			id: Uuid::new_v4().to_string(),
+			item_code: String::new(),
 			name: String::new(),
+			description: String::new(),
+			rarity: String::new(),
+			type_: String::new(),
+			category: String::new(),
+			value: 0,
+			weight: 0.0,
+			stock: 0,
+			is_limited: false,
+			metadata: None,
 			image_url: String::new(),
 			is_deleted: false,
-			created_at: Some(get_iso_date()),
-			updated_at: Some(get_iso_date()),
+			created_at: None,
+			updated_at: None,
 		}
 	}
 }
@@ -35,13 +50,22 @@ impl Default for GachaItemSchema {
 impl GachaItemSchema {
 	pub fn from(dto: GachaItemRequestDto) -> Self {
 		Self {
-			id: make_thing(
-				&ResourceEnum::GachaItems.to_string(),
-				&Uuid::new_v4().to_string(),
-			),
+			id: Uuid::new_v4().to_string(),
+			item_code: dto.item_code,
 			name: dto.name,
+			description: dto.description,
+			rarity: dto.rarity,
+			type_: dto.type_,
+			category: dto.category,
+			value: dto.value,
+			weight: dto.weight,
+			stock: dto.stock,
+			is_limited: dto.is_limited,
+			metadata: dto.metadata,
 			image_url: dto.image_url,
-			..Default::default()
+			is_deleted: false,
+			created_at: None,
+			updated_at: None,
 		}
 	}
 

imphnen-gacha/src/v1/gacha_items/gacha_items_service.rs

@@ -5,7 +5,7 @@ use crate::v1::gacha_items::GachaItemDto;
 use crate::v1::gacha_items::gacha_items_dto::{GachaItemRequestDto, GachaItemUpdateRequestDto};
 use crate::v1::gacha_items::gacha_items_repository::GachaItemRepository;
 use crate::v1::gacha_items::gacha_items_schema::GachaItemSchema;
-use imphnen_libs::ResourceEnum;
+use imphnen_entities::ResourceEnum;
 use axum::http::StatusCode;
 use axum::response::Response;
 use imphnen_utils::get_iso_date;

imphnen-gacha/src/v1/gacha_items/mod.rs

@@ -1,30 +1,30 @@
-use axum::{
-    Router,
-    routing::{delete, get, post, put},
-};
-
-pub mod gacha_items_controller;
-pub mod gacha_items_dto;
-pub mod gacha_items_repository;
-pub mod gacha_items_schema;
-pub mod gacha_items_service;
-
-// Export only public API functions and types
-pub use gacha_items_controller::{
-    get_gacha_item_list,
-    post_create_gacha_item,
-    get_gacha_item_by_id,
-    put_update_gacha_item,
-    delete_gacha_item,
-};
-pub use gacha_items_dto::GachaItemDto;
-
-/// Creates router for gacha items endpoints
-pub fn gacha_item_router() -> Router {
-    Router::new()
-        .route("/", get(get_gacha_item_list))
-        .route("/create", post(post_create_gacha_item))
-        .route("/detail/{id}", get(get_gacha_item_by_id))
-        .route("/update/{id}", put(put_update_gacha_item))
-        .route("/delete/{id}", delete(delete_gacha_item))
-}
+use axum::{
+    Router,
+    routing::{delete, get, post, put},
+};
+
+pub mod gacha_items_controller;
+pub mod gacha_items_dto;
+pub mod gacha_items_repository;
+pub mod gacha_items_schema;
+pub mod gacha_items_service;
+
+// Export only public API functions and types
+pub use gacha_items_controller::{
+    get_gacha_item_list,
+    post_create_gacha_item,
+    get_gacha_item_by_id,
+    put_update_gacha_item,
+    delete_gacha_item,
+};
+pub use gacha_items_dto::GachaItemDto;
+
+/// Creates router for gacha items endpoints
+pub fn gacha_item_router() -> Router {
+    Router::new()
+        .route("/", get(get_gacha_item_list))
+        .route("/create", post(post_create_gacha_item))
+        .route("/detail/{id}", get(get_gacha_item_by_id))
+        .route("/update/{id}", put(put_update_gacha_item))
+        .route("/delete/{id}", delete(delete_gacha_item))
+}

imphnen-gacha/src/v1/gacha_rolls/gacha_rolls_controller.rs

@@ -1,122 +1,136 @@
-use crate::AppState;
-use imphnen_entities::{MessageResponseDto, ResponseSuccessDto};
-use crate::v1::gacha_rolls::gacha_rolls_dto::{GachaRollItemDto, GachaRollRequestDto};
-use crate::v1::gacha_rolls::gacha_rolls_service::GachaRollService;
-use axum::{
-	Extension, Json, extract::Path, http::HeaderMap, response::IntoResponse,
-};
-use imphnen_iam::{PermissionsEnum, permissions_guard};
-
-#[utoipa::path(
-    get,
-    path = "/v1/gacha/rolls/detail/{id}",
-    security(
-        ("Bearer" = [])
-    ),
-    params(("id" = String, Path, description = "Gacha Roll ID")),
-    responses(
-        (status = 200, description = "[ADMIN] Get Gacha Roll by ID", body = ResponseSuccessDto<GachaRollItemDto>)
-    ),
-    tag = "Gacha"
-)]
-pub async fn get_detail_gacha_roll(
-	headers: HeaderMap,
-	Extension(state): Extension<AppState>,
-	Path(id): Path<String>,
-) -> impl IntoResponse {
-	match permissions_guard(
-		headers,
-		Extension(state),
-		vec![PermissionsEnum::ReadDetailGachaRolls],
-	)
-	.await
-	{
-		Ok((_user, state)) => GachaRollService::get_gacha_roll_by_id(&state, id).await,
-		Err(response) => response,
-	}
-}
-
-#[utoipa::path(
-    post,
-    path = "/v1/gacha/rolls/create",
-    security(
-        ("Bearer" = [])
-    ),
-    request_body = GachaRollRequestDto,
-    responses(
-        (status = 201, description = "[ADMIN] Create new gacha roll", body = MessageResponseDto)
-    ),
-    tag = "Gacha"
-)]
-pub async fn post_create_gacha_roll(
-	headers: HeaderMap,
-	Extension(state): Extension<AppState>,
-	Json(payload): Json<GachaRollRequestDto>,
-) -> impl IntoResponse {
-	match permissions_guard(
-		headers,
-		Extension(state),
-		vec![PermissionsEnum::CreateGachaRolls],
-	)
-	.await
-	{
-		Ok((_user, state)) => GachaRollService::create_gacha_roll(&state, payload).await,
-		Err(response) => response,
-	}
-}
-
-#[utoipa::path(
-    post,
-    path = "/v1/gacha/rolls/execute",
-    security(
-        ("Bearer" = [])
-    ),
-    responses(
-        (status = 200, description = "[ADMIN] Execute and get 1 gacha result", body = ResponseSuccessDto<GachaRollItemDto>)
-    ),
-    tag = "Gacha"
-)]
-pub async fn post_execute_gacha_roll(
-	headers: HeaderMap,
-	Extension(state): Extension<AppState>,
-) -> impl IntoResponse {
-	match permissions_guard(
-		headers.clone(),
-		Extension(state),
-		vec![PermissionsEnum::ExecuteGachaRolls],
-	)
-	.await
-	{
-		Ok((_user, state)) => GachaRollService::execute_roll_once(headers, &state).await,
-		Err(response) => response,
-	}
-}
-
-#[utoipa::path(
-    delete,
-    path = "/v1/gacha/rolls/delete/{id}",
-    security(
-        ("Bearer" = [])
-    ),
-    params(("id" = String, Path, description = "Gacha Roll ID")),
-    responses(
-        (status = 200, description = "[ADMIN] Delete Gacha Roll (soft delete)", body = MessageResponseDto)
-    ),
-    tag = "Gacha"
-)]
-pub async fn delete_gacha_roll(
-	headers: HeaderMap,
-	Extension(state): Extension<AppState>,
-	Path(id): Path<String>,
-) -> impl IntoResponse {
-	match permissions_guard(
-		headers,
-		Extension(state),
-		vec![PermissionsEnum::DeleteGachaRolls],
-	)
-	.await
-	{
-		Ok((_user, state)) => GachaRollService::soft_delete_gacha_roll(&state, id).await,
-		Err(response) => response,
-	}
-}
+use crate::AppState;
+use imphnen_entities::{MessageResponseDto, ResponseSuccessDto};
+use crate::v1::gacha_rolls::gacha_rolls_dto::{GachaRollItemDto, GachaRollRequestDto};
+use crate::v1::gacha_rolls::gacha_rolls_service::GachaRollService;
+use axum::{
+	Extension, Json, extract::Path, http::{HeaderMap, StatusCode}, response::IntoResponse,
+};
+use imphnen_iam::{PermissionsEnum, permissions_guard};
+use imphnen_utils::common_response;
+use uuid::Uuid;
+
+#[utoipa::path(
+    get,
+    path = "/v1/gacha/rolls/detail/{id}",
+    security(
+        ("Bearer" = [])
+    ),
+    params(("id" = String, Path, description = "Gacha Roll ID")),
+    responses(
+        (status = 200, description = "[ADMIN] Get Gacha Roll by ID", body = ResponseSuccessDto<GachaRollItemDto>)
+    ),
+    tag = "Gacha"
+)]
+pub async fn get_detail_gacha_roll(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+) -> impl IntoResponse {
+	match permissions_guard(
+		headers,
+		Extension(state),
+		vec![PermissionsEnum::ReadDetailGachaRolls],
+	)
+	.await
+	{
+		Ok((_user, state)) => {
+            let parsed_id = match Uuid::parse_str(&id) {
+                Ok(uuid) => uuid,
+                Err(e) => return common_response(StatusCode::BAD_REQUEST, &format!("Invalid UUID format: {}", e)),
+            };
+            GachaRollService::get_gacha_roll_by_id(&state, parsed_id).await
+        },
+		Err(response) => response,
+	}
+}
+
+#[utoipa::path(
+    post,
+    path = "/v1/gacha/rolls/create",
+    security(
+        ("Bearer" = [])
+    ),
+    request_body = GachaRollRequestDto,
+    responses(
+        (status = 201, description = "[ADMIN] Create new gacha roll", body = MessageResponseDto)
+    ),
+    tag = "Gacha"
+)]
+pub async fn post_create_gacha_roll(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Json(payload): Json<GachaRollRequestDto>,
+) -> impl IntoResponse {
+	match permissions_guard(
+		headers.clone(),
+		Extension(state.clone()),
+		vec![PermissionsEnum::CreateGachaRolls],
+	)
+	.await
+	{
+		Ok((_user, _)) => GachaRollService::create_gacha_roll(headers, &state, payload, "default".to_string()).await,
+		Err(response) => response,
+	}
+}
+
+#[utoipa::path(
+    post,
+    path = "/v1/gacha/rolls/execute",
+    security(
+        ("Bearer" = [])
+    ),
+    responses(
+        (status = 200, description = "[ADMIN] Execute and get 1 gacha result", body = ResponseSuccessDto<GachaRollItemDto>)
+    ),
+    tag = "Gacha"
+)]
+pub async fn post_execute_gacha_roll(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+) -> impl IntoResponse {
+	match permissions_guard(
+		headers.clone(),
+		Extension(state),
+		vec![PermissionsEnum::ExecuteGachaRolls],
+	)
+	.await
+	{
+		Ok((_user, state)) => GachaRollService::execute_roll_once(headers, &state).await,
+		Err(response) => response,
+	}
+}
+
+#[utoipa::path(
+    delete,
+    path = "/v1/gacha/rolls/delete/{id}",
+    security(
+        ("Bearer" = [])
+    ),
+    params(("id" = String, Path, description = "Gacha Roll ID")),
+    responses(
+        (status = 200, description = "[ADMIN] Delete Gacha Roll (soft delete)", body = MessageResponseDto)
+    ),
+    tag = "Gacha"
+)]
+pub async fn delete_gacha_roll(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+) -> impl IntoResponse {
+	match permissions_guard(
+		headers,
+		Extension(state),
+		vec![PermissionsEnum::DeleteGachaRolls],
+	)
+	.await
+	{
+		Ok((_user, state)) => {
+            let parsed_id = match Uuid::parse_str(&id) {
+                Ok(uuid) => uuid,
+                Err(e) => return common_response(StatusCode::BAD_REQUEST, &format!("Invalid UUID format: {}", e)),
+            };
+            GachaRollService::soft_delete_gacha_roll(&state, parsed_id).await
+        },
+		Err(response) => response,
+	}
+}

imphnen-gacha/src/v1/gacha_rolls/gacha_rolls_dto.rs

@@ -1,65 +1,64 @@
-use crate::v1::gacha_items::GachaItemDto;
-use crate::v1::gacha_items::gacha_items_schema::GachaItemSchema;
-use serde::{Deserialize, Serialize};
-use surrealdb::sql::Thing;
-use utoipa::ToSchema;
-use validator::Validate;
-
-#[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
-pub struct GachaRollRequestDto {
-	#[validate(length(min = 1, max = 100, message = "Item ID must be between 1 and 100 characters"))]
-	pub item_id: String,
-
-	#[validate(range(min = 0.0, max = 1.0, message = "Weight must be between 0.0 and 1.0"))]
-	pub weight: f32,
-
-	#[validate(range(min = 1, max = 100, message = "Quantity must be between 1 and 100"))]
-	pub quantity: i32,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
-pub struct GachaRollItemDto {
-	pub id: String,
-	pub item: GachaItemDto,
-	pub weight: f32,
-	pub quantity: i32,
-	pub is_deleted: bool,
-	pub created_at: Option<String>,
-	pub updated_at: Option<String>,
-}
-
-impl GachaRollItemDto {
-	pub fn from(dto: &GachaRollQueryDto) -> Self {
-		Self {
-			id: dto.id.id.to_raw(),
-			// Handle case where item might be missing
-			item: match &dto.item {
-				Some(item) => GachaItemDto::from(item.clone()),
-				None => GachaItemDto {
-					id: "".to_string(),
-					name: "Unknown".to_string(),
-					is_deleted: false,
-					created_at: None,
-					updated_at: None,
-				}
-			},
-			weight: dto.weight,
-			quantity: dto.quantity,
-			is_deleted: dto.is_deleted,
-			created_at: dto.created_at.clone(),
-			updated_at: dto.updated_at.clone(),
-		}
-	}
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct GachaRollQueryDto {
-	pub id: Thing,
-	// item can be missing in the DB (during partial queries); make optional to allow graceful handling
-	pub item: Option<GachaItemSchema>,
-	pub weight: f32,
-	pub quantity: i32,
-	pub is_deleted: bool,
-	pub created_at: Option<String>,
-	pub updated_at: Option<String>,
-}
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+use validator::Validate;
+use crate::v1::gacha_items::GachaItemDto;
+use crate::v1::gacha_items::gacha_items_schema::GachaItemSchema;
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
+pub struct GachaRollRequestDto {
+	#[validate(length(min = 1, max = 100, message = "Item ID must be between 1 and 100 characters"))]
+	pub item_id: String,
+
+	#[validate(range(min = 0.0, max = 1.0, message = "Weight must be between 0.0 and 1.0"))]
+	pub weight: f32,
+
+	#[validate(range(min = 1, max = 100, message = "Quantity must be between 1 and 100"))]
+	pub quantity: i32,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct GachaRollItemDto {
+	pub id: String,
+	pub item: GachaItemDto,
+	pub weight: f32,
+	pub quantity: i32,
+	pub is_deleted: bool,
+	pub created_at: Option<String>,
+	pub updated_at: Option<String>,
+}
+
+impl GachaRollItemDto {
+	pub fn from(dto: &GachaRollQueryDto) -> Self {
+		Self {
+			id: dto.id.clone(),
+			// Handle case where item might be missing
+			item: match &dto.item {
+				Some(item) => GachaItemDto::from(item.clone()),
+				None => GachaItemDto {
+					id: "".to_string(),
+					name: "Unknown".to_string(),
+					is_deleted: false,
+					created_at: None,
+					updated_at: None,
+				}
+			},
+			weight: dto.weight,
+			quantity: dto.quantity,
+			is_deleted: dto.is_deleted,
+			created_at: dto.created_at.clone(),
+			updated_at: dto.updated_at.clone(),
+		}
+	}
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct GachaRollQueryDto {
+	pub id: String,
+	// item can be missing in the DB (during partial queries); make optional to allow graceful handling
+	pub item: Option<GachaItemSchema>,
+	pub weight: f32,
+	pub quantity: i32,
+	pub is_deleted: bool,
+	pub created_at: Option<String>,
+	pub updated_at: Option<String>,
+}

imphnen-gacha/src/v1/gacha_rolls/gacha_rolls_repository.rs

@@ -1,175 +1,190 @@
-use crate::v1::gacha_rolls::gacha_rolls_dto::GachaRollQueryDto;
-use crate::v1::gacha_rolls::gacha_rolls_schema::GachaRollSchema;
-use crate::AppState;
-use imphnen_libs::ResourceEnum;
-use imphnen_utils::DetailQueryBuilder;
-use crate::{get_id, make_thing};
-use anyhow::{Result, bail};
-
-use rand::prelude::*;
-
-use imphnen_utils::get_iso_date;
-use serde_json::{Map, Value};
-use std::time::Instant;
-use tracing::instrument;
-use tracing::info;
-
-pub struct GachaRollRepository<'a> {
-	state: &'a AppState,
-}
-
-impl<'a> GachaRollRepository<'a> {
-	pub fn new(state: &'a AppState) -> Self {
-		Self { state }
-	}
-
-	#[instrument(skip(self, id), err)]
-	pub async fn query_gacha_roll_by_id(
-		&self,
-		id: String,
-	) -> Result<GachaRollQueryDto> {
-		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		let builder = DetailQueryBuilder::new(ResourceEnum::GachaRolls.to_string())
-			.with_id(id.clone())
-			.with_condition("is_deleted = false")
-			.with_select_fields(vec!["*"])
-			.with_fetch("item");
-		let sql = builder.build();
-		info!(query = %sql, "Executing SurrealDB query");
-		let result: Option<GachaRollQueryDto> =
-			builder.apply_bindings(db.query(sql)).await?.take(0)?;
-		let elapsed = now.elapsed();
-		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
-			== "development"
-		{
-			println!("Query 'query_gacha_roll_by_id' took: {elapsed:.2?}");
-		}
-		match result {
-			Some(roll) if !roll.is_deleted => Ok(roll),
-			_ => bail!("Gacha Roll not found"),
-		}
-	}
-
-	#[instrument(skip(self, data), err)]
-	pub async fn query_create_gacha_roll(
-		&self,
-		data: GachaRollSchema,
-	) -> Result<String> {
-		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		info!(query = "CREATE", "Executing SurrealDB create operation for GachaRolls");
-		let record: Option<GachaRollSchema> = db
-			.create(ResourceEnum::GachaRolls.to_string())
-			.content(data)
-			.await?;
-		let elapsed = now.elapsed();
-		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
-			== "development"
-		{
-			println!("Query 'query_create_gacha_roll' took: {elapsed:.2?}");
-		}
-		match record {
-			Some(_) => Ok("Success create Gacha Roll".into()),
-			None => bail!("Failed to create Gacha Roll"),
-		}
-	}
-
-	#[instrument(skip(self), err)]
-	pub async fn query_all_active_rolls(&self) -> Result<Vec<GachaRollQueryDto>> {
-		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		let table_name = ResourceEnum::GachaRolls.to_string();
-		
-		// Use DetailQueryBuilder to properly fetch related item data
-		let builder = DetailQueryBuilder::new(table_name)
-			.with_condition("is_deleted = false AND quantity > 0")
-			.with_select_fields(vec!["*"])
-			.with_fetch("item");
-		let sql = builder.build();
-		info!(query = %sql, "Executing SurrealDB query for active rolls");
-		
-		let mut result = builder.apply_bindings(db.query(sql)).await?;
-		let results = match result.take(0) {
-			Ok(v) => v,
-			Err(_) => return Ok(Vec::new()),
-		};
-
-		let elapsed = now.elapsed();
-		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
-			== "development"
-		{
-			println!("Query 'query_all_active_rolls' took: {elapsed:.2?}");
-		}
-		Ok(results)
-	}
-
-	#[instrument]
-	pub fn roll_once(rolls: &[GachaRollQueryDto]) -> Option<GachaRollQueryDto> {
-		let filtered: Vec<GachaRollQueryDto> = rolls
-			.iter()
-			.filter(|r| !r.is_deleted && r.quantity > 0)
-			.cloned()
-			.collect();
-		
-		if filtered.is_empty() {
-			return None;
-		}
-
-		// Simple random selection based on quantity weights
-		let total_weight: f32 = filtered.iter()
-			.map(|r| r.weight * r.quantity as f32)
-			.sum();
-
-		if total_weight <= 0.0 {
-			// Fallback to equal probability if weights are invalid
-			let mut rng = rand::rngs::ThreadRng::default();
-			let index = rng.random_range(0..filtered.len());
-			return Some(filtered[index].clone());
-		}
-
-		// Weighted random selection
-		let mut rng = rand::rngs::ThreadRng::default();
-		let random_value = rng.random_range(0.0..total_weight);
-		
-		let mut cumulative_weight = 0.0;
-		for roll in &filtered {
-			cumulative_weight += roll.weight * roll.quantity as f32;
-			if random_value <= cumulative_weight {
-				return Some(roll.clone());
-			}
-		}
-
-		// This should rarely happen but provides a fallback
-		Some(filtered[0].clone())
-	}
-
-	#[instrument(skip(self, id), err)]
-	pub async fn query_soft_delete_gacha_roll(&self, id: String) -> Result<String> {
-		let now = Instant::now();
-		let db = &self.state.surrealdb_ws;
-		let roll_id_thing = make_thing(&ResourceEnum::GachaRolls.to_string(), &id);
-		let roll = self.query_gacha_roll_by_id(id.clone()).await?;
-		if roll.is_deleted {
-			bail!("Gacha Roll already deleted");
-		}
-		let record_key = get_id(&roll_id_thing)?;
-
-		let mut patch = Map::new();
-		patch.insert("is_deleted".to_string(), Value::Bool(true));
-		patch.insert("updated_at".to_string(), Value::String(get_iso_date()));
-
-		info!(query = "UPDATE", record_key = ?record_key, "Executing SurrealDB update operation for GachaRolls");
-		let record: Option<GachaRollSchema> = db.update(record_key).merge(patch).await?;
-		let elapsed = now.elapsed();
-		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
-			== "development"
-		{
-			println!("Query 'query_soft_delete_gacha_roll' took: {elapsed:.2?}");
-		}
-		match record {
-			Some(_) => Ok("Success soft delete Gacha Roll".into()),
-			None => bail!("Failed to soft delete Gacha Roll"),
-		}
-	}
-}
+use crate::v1::gacha_rolls::gacha_rolls_dto::GachaRollQueryDto;
+use crate::v1::gacha_rolls::gacha_rolls_schema::GachaRollSchema;
+use crate::AppState;
+use imphnen_entities::seaorm::gacha::gacha_rolls::{Entity as GachaRollsEntity, ActiveModel as GachaRollActiveModel, Column as GachaRollColumn};
+use anyhow::{Result, bail};
+use chrono::Utc;
+use rand::prelude::*;
+use sea_orm::{EntityTrait, QueryFilter, Set, ColumnTrait, ActiveModelTrait};
+use imphnen_libs::postgres::AppStatePostgresExt;
+use std::time::Instant;
+use tracing::instrument;
+use uuid::Uuid;
+
+pub struct GachaRollRepository<'a> {
+	state: &'a AppState,
+}
+
+impl<'a> GachaRollRepository<'a> {
+	pub fn new(state: &'a AppState) -> Self {
+		Self { state }
+	}
+
+	#[instrument(skip(self, id), err)]
+	pub async fn query_gacha_roll_by_id(
+		&self,
+		id: Uuid,
+	) -> Result<GachaRollQueryDto> {
+		let now = Instant::now();
+		let db = self.state.postgres_db();
+		
+		let result = GachaRollsEntity::find()
+			.filter(GachaRollColumn::Id.eq(id))
+			.filter(GachaRollColumn::IsDeleted.eq(false))
+			.one(db)
+			.await?;
+			
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_gacha_roll_by_id' took: {elapsed:.2?}");
+		}
+		
+		match result {
+			Some(r) => Ok(GachaRollQueryDto {
+				id: r.id.to_string(),
+				item: None,
+				weight: r.weight,
+				quantity: r.quantity,
+				is_deleted: r.is_deleted,
+				created_at: r.created_at.map(|d| d.to_string()),
+				updated_at: r.updated_at.map(|d| d.to_string()),
+			}),
+			None => bail!("Gacha Roll not found"),
+		}
+	}
+
+	#[instrument(skip(self, data), err)]
+	pub async fn query_create_gacha_roll(
+		&self,
+		data: GachaRollSchema,
+	) -> Result<String> {
+		let now = Instant::now();
+		let db = self.state.postgres_db();
+		
+		let active_model = GachaRollActiveModel {
+			id: Set(Uuid::parse_str(&data.id)?),
+			user_id: Set(Uuid::parse_str(&data.user_id)?),
+			gacha_id: Set(data.gacha_id), // gacha_id is String
+			item_id: Set(Uuid::parse_str(&data.item_id)?),
+			quantity: Set(data.quantity),
+			weight: Set(data.weight),
+			is_deleted: Set(false),
+			created_at: Set(Some(Utc::now().naive_utc())),
+			updated_at: Set(Some(Utc::now().naive_utc())),
+		};
+		
+		let _ = GachaRollsEntity::insert(active_model)
+			.exec(db)
+			.await?;
+			
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_create_gacha_roll' took: {elapsed:.2?}");
+		}
+		
+		Ok("Success create Gacha Roll".into())
+	}
+
+	#[instrument(skip(self), err)]
+	pub async fn query_all_active_rolls(&self) -> Result<Vec<GachaRollQueryDto>> {
+		let now = Instant::now();
+		let db = self.state.postgres_db();		
+		let results = GachaRollsEntity::find()
+			.filter(GachaRollColumn::IsDeleted.eq(false))
+			.filter(GachaRollColumn::Quantity.gt(0))
+			.all(db)
+			.await?;
+			
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_all_active_rolls' took: {elapsed:.2?}");
+		}
+		
+		Ok(results.into_iter().map(|r| GachaRollQueryDto {
+			id: r.id.to_string(),
+			item: None,
+			weight: r.weight,
+			quantity: r.quantity,
+			is_deleted: r.is_deleted,
+			created_at: r.created_at.map(|d| d.to_string()),
+			updated_at: r.updated_at.map(|d| d.to_string()),
+		}).collect())
+	}
+
+	#[instrument]
+	pub fn roll_once(rolls: &[GachaRollQueryDto]) -> Option<GachaRollQueryDto> {
+		let filtered: Vec<GachaRollQueryDto> = rolls
+			.iter()
+			.filter(|r| !r.is_deleted && r.quantity > 0)
+			.cloned()
+			.collect();
+		
+		if filtered.is_empty() {
+			return None;
+		}
+
+		// Simple random selection based on quantity weights
+		let total_weight: f64 = filtered.iter()
+			.map(|r| f64::from(r.weight) * f64::from(r.quantity))
+			.sum();
+
+		if total_weight <= 0.0 {
+			// Fallback to equal probability if weights are invalid
+			let mut rng = rand::rngs::ThreadRng::default();
+			let index = rng.random_range(0..filtered.len());
+			return Some(filtered[index].clone());
+		}
+
+		// Weighted random selection
+		let mut rng = rand::rngs::ThreadRng::default();
+		let random_value = rng.random_range(0.0..total_weight);
+		
+		let mut cumulative_weight = 0.0;
+		for roll in &filtered {
+			cumulative_weight += f64::from(roll.weight) * f64::from(roll.quantity);
+			if random_value <= cumulative_weight {
+				return Some(roll.clone());
+			}
+		}
+
+		// This should rarely happen but provides a fallback
+		Some(filtered[0].clone())
+	}
+
+	#[instrument(skip(self, id), err)]
+	pub async fn query_soft_delete_gacha_roll(&self, id: Uuid) -> Result<String> {
+		let now = Instant::now();
+		let db = self.state.postgres_db();
+		
+		let roll = self.query_gacha_roll_by_id(id).await?;
+		if roll.is_deleted {
+			bail!("Gacha Roll already deleted");
+		}
+		
+		let mut active_model: GachaRollActiveModel = GachaRollsEntity::find_by_id(id)
+			.one(db)
+			.await?
+			.ok_or_else(|| anyhow::anyhow!("Gacha Roll not found"))?
+			.into();
+			
+		active_model.is_deleted = Set(true);
+		active_model.updated_at = Set(Some(Utc::now().naive_utc()));
+		
+		let _result = GachaRollActiveModel::update(active_model, db).await?;
+			
+		let elapsed = now.elapsed();
+		if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string())
+			== "development"
+		{
+			println!("Query 'query_soft_delete_gacha_roll' took: {elapsed:.2?}");
+		}
+		
+		Ok("Success soft delete Gacha Roll".into())
+	}
+}

imphnen-gacha/src/v1/gacha_rolls/gacha_rolls_schema.rs

@@ -1,53 +1,48 @@
-use crate::make_thing;
-use imphnen_iam::get_iso_date;
-use imphnen_libs::ResourceEnum;
-use serde::{Deserialize, Serialize};
-use surrealdb::{Uuid, sql::Thing};
-
-use crate::v1::gacha_rolls::gacha_rolls_dto::GachaRollRequestDto;
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct GachaRollSchema {
-	pub id: Thing,
-	pub item: Thing,
-	pub weight: f32,
-	pub quantity: i32,
-	pub is_deleted: bool,
-	pub created_at: Option<String>,
-	pub updated_at: Option<String>,
-}
-
-impl Default for GachaRollSchema {
-	fn default() -> Self {
-		GachaRollSchema {
-			id: make_thing(
-				&ResourceEnum::GachaRolls.to_string(),
-				&Uuid::new_v4().to_string(),
-			),
-			item: make_thing(
-				&ResourceEnum::GachaItems.to_string(),
-				&Uuid::new_v4().to_string(),
-			),
-			weight: 0.0,
-			quantity: 0,
-			is_deleted: false,
-			created_at: Some(get_iso_date()),
-			updated_at: Some(get_iso_date()),
-		}
-	}
-}
-
-impl GachaRollSchema {
-	pub fn create(dto: GachaRollRequestDto) -> Self {
-		Self {
-			id: make_thing(
-				&ResourceEnum::GachaRolls.to_string(),
-				&Uuid::new_v4().to_string(),
-			),
-			item: make_thing(&ResourceEnum::GachaItems.to_string(), &dto.item_id),
-			weight: dto.weight,
-			quantity: dto.quantity,
-			..Default::default()
-		}
-	}
-}
+use serde::{Deserialize, Serialize};
+use chrono::{DateTime, Utc};
+use uuid::Uuid;
+
+use crate::v1::gacha_rolls::gacha_rolls_dto::GachaRollRequestDto;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct GachaRollSchema {
+	pub id: String,
+	pub user_id: String,
+	pub gacha_id: String,
+	pub item_id: String,
+	pub weight: f32,
+	pub quantity: i32,
+	pub is_deleted: bool,
+	pub created_at: Option<DateTime<Utc>>,
+	pub updated_at: Option<DateTime<Utc>>,
+}
+
+impl Default for GachaRollSchema {
+	fn default() -> Self {
+		GachaRollSchema {
+			id: Uuid::new_v4().to_string(),
+			user_id: "".to_string(),
+			gacha_id: "".to_string(),
+			item_id: "".to_string(),
+			weight: 0.0,
+			quantity: 0,
+			is_deleted: false,
+			created_at: Some(Utc::now()),
+			updated_at: Some(Utc::now()),
+		}
+	}
+}
+
+impl GachaRollSchema {
+	pub fn create(dto: GachaRollRequestDto, user_id: String, gacha_id: String) -> Self {
+		Self {
+			id: Uuid::new_v4().to_string(),
+			user_id,
+			gacha_id,
+			item_id: dto.item_id,
+			weight: dto.weight,
+			quantity: dto.quantity,
+			..Default::default()
+		}
+	}
+}

imphnen-gacha/src/v1/gacha_rolls/gacha_rolls_service.rs

@@ -1,109 +1,122 @@
-use crate::AppState;
-use imphnen_entities::ResponseSuccessDto;
-use imphnen_utils::{common_response, success_response, validate_request};
-use crate::v1::gacha_claims::gacha_claims_repository::GachaClaimRepository;
-use crate::v1::gacha_claims::gacha_claims_schema::GachaClaimSchema;
-use crate::v1::gacha_rolls::gacha_rolls_dto::{GachaRollItemDto, GachaRollRequestDto};
-use crate::v1::gacha_rolls::gacha_rolls_repository::GachaRollRepository;
-use crate::v1::gacha_rolls::gacha_rolls_schema::GachaRollSchema;
-use crate::v1::gacha_credits::gacha_credits_repository::GachaCreditRepository;
-use axum::http::{HeaderMap, StatusCode};
-use axum::response::Response;
-use imphnen_iam::UsersRepository;
-use imphnen_utils::extract_email;
-
-pub struct GachaRollService;
-
-impl GachaRollService {
-	pub async fn get_gacha_roll_by_id(state: &AppState, id: String) -> Response {
-		let repo = GachaRollRepository::new(state);
-		match repo.query_gacha_roll_by_id(id).await {
-			Ok(roll) => success_response(ResponseSuccessDto {
-				data: GachaRollItemDto::from(&roll),
-			}),
-			Err(e) => common_response(StatusCode::NOT_FOUND, &e.to_string()),
-		}
-	}
-
-	pub async fn create_gacha_roll(
-		state: &AppState,
-		payload: GachaRollRequestDto,
-	) -> Response {
-		if let Err((status, message)) = validate_request(&payload) {
-			return common_response(status, &message);
-		}
-		let schema = GachaRollSchema::create(payload);
-		let repo = GachaRollRepository::new(state);
-		match repo.query_create_gacha_roll(schema).await {
-			Ok(msg) => common_response(StatusCode::CREATED, &msg),
-			Err(e) => common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
-		}
-	}
-
-	pub async fn execute_roll_once(headers: HeaderMap, state: &AppState) -> Response {
-			let repo = GachaRollRepository::new(state);
-			let repo_claim = GachaClaimRepository::new(state);
-			let repo_user = UsersRepository::new(state);
-			let repo_credits = GachaCreditRepository::new(state);
-			let Some(email) = extract_email(&headers) else {
-				return common_response(StatusCode::UNAUTHORIZED, "Unauthorized");
-			};
-			let Ok(user) = repo_user.query_user_by_email(email.to_string()).await else {
-				return common_response(StatusCode::NOT_FOUND, "User not found");
-			};
-			
-			// Check if user has enough credits
-			let credit_opt = repo_credits.query_by_user_id(user.id.id.to_raw()).await;
-			let has_enough_credits = match credit_opt {
-				Ok(Some(credit)) => credit.available_rolls > 0,
-				Ok(None) => false, // No credit record means no credits
-				Err(e) => {
-					return common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string())
-				}
-			};
-			
-			if !has_enough_credits {
-				return common_response(StatusCode::PAYMENT_REQUIRED, "Not enough credits to perform this action");
-			}
-			
-			// Consume one credit
-			match repo_credits.query_consume_credit(user.id.id.to_raw()).await {
-				Err(e) => return common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
-				_ => {}
-			}
-			
-			// Proceed with the roll
-			match repo.query_all_active_rolls().await {
-				Ok(rolls) => match GachaRollRepository::roll_once(&rolls) {
-					Some(roll) => {
-						let user_id_clone = user.id.clone();
-						let claim = GachaClaimSchema::roll(roll.clone(), user_id_clone);
-						match repo_claim.query_create_gacha_claim(claim).await {
-							Ok(_) => success_response(ResponseSuccessDto {
-								data: GachaRollItemDto::from(&roll),
-							}),
-							Err(e) => {
-								// Refund the credit if claim creation fails
-								let user_id = user.id.id.to_raw(); // Extract value before potential move
-								let _ = repo_credits.query_add_credit(crate::v1::gacha_credits::gacha_credits_dto::GachaCreditRequestDto {
-									user_id,
-									amount: 1,
-								}).await;
-								common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string())
-							}
-						}
-					}
-					None => common_response(StatusCode::NOT_FOUND, "No rollable item available"),
-				},
-				Err(e) => common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
-			}
-		}
-
-	pub async fn soft_delete_gacha_roll(state: &AppState, id: String) -> Response {
-		let repo = GachaRollRepository::new(state);
-		match repo.query_soft_delete_gacha_roll(id).await {
-			Ok(msg) => common_response(StatusCode::OK, &msg),
-			Err(e) => common_response(StatusCode::NOT_FOUND, &e.to_string()),
-		}
-	}
-}
+use crate::AppState;
+use imphnen_entities::ResponseSuccessDto;
+use imphnen_utils::{common_response, success_response, validate_request};
+use crate::v1::gacha_claims::gacha_claims_repository::GachaClaimRepository;
+use crate::v1::gacha_claims::gacha_claims_schema::GachaClaimSchema;
+use crate::v1::gacha_rolls::gacha_rolls_dto::{GachaRollItemDto, GachaRollRequestDto};
+use crate::v1::gacha_rolls::gacha_rolls_repository::GachaRollRepository;
+use crate::v1::gacha_rolls::gacha_rolls_schema::GachaRollSchema;
+use crate::v1::gacha_credits::gacha_credits_repository::GachaCreditRepository;
+use axum::http::{HeaderMap, StatusCode};
+use axum::response::Response;
+use imphnen_iam::UsersRepository;
+use imphnen_utils::extract_email;
+use uuid::Uuid;
+
+pub struct GachaRollService;
+
+impl GachaRollService {
+	pub async fn get_gacha_roll_by_id(state: &AppState, id: Uuid) -> Response {
+		let repo = GachaRollRepository::new(state);
+		match repo.query_gacha_roll_by_id(id).await {
+			Ok(roll) => success_response(ResponseSuccessDto {
+				data: GachaRollItemDto::from(&roll),
+			}),
+			Err(e) => common_response(StatusCode::NOT_FOUND, &e.to_string()),
+		}
+	}
+
+	pub async fn create_gacha_roll(
+		headers: HeaderMap, // Add headers
+		state: &AppState,
+		payload: GachaRollRequestDto,
+		gacha_id: String, // Add gacha_id
+	) -> Response {
+		if let Err((status, message)) = validate_request(&payload) {
+			return common_response(status, &message);
+		}
+		let repo_user = UsersRepository::new(state); // Need UsersRepository here
+		let Some(email) = extract_email(&headers) else {
+			return common_response(StatusCode::UNAUTHORIZED, "Unauthorized");
+		};
+		let Ok(user) = repo_user.query_user_by_email(email.to_string()).await else {
+			return common_response(StatusCode::NOT_FOUND, "User not found");
+		};
+		
+		let schema = GachaRollSchema::create(payload, user.id.clone(), gacha_id); // Pass user.id and gacha_id
+		let repo = GachaRollRepository::new(state);
+		match repo.query_create_gacha_roll(schema).await {
+			Ok(msg) => common_response(StatusCode::CREATED, &msg),
+			Err(e) => common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+		}
+	}
+
+	pub async fn execute_roll_once(headers: HeaderMap, state: &AppState) -> Response {
+			let repo = GachaRollRepository::new(state);
+			let repo_claim = GachaClaimRepository::new(state);
+			let repo_user = UsersRepository::new(state);
+			let repo_credits = GachaCreditRepository::new(state);
+			let Some(email) = extract_email(&headers) else {
+				return common_response(StatusCode::UNAUTHORIZED, "Unauthorized");
+			};
+			let Ok(user) = repo_user.query_user_by_email(email.to_string()).await else {
+				return common_response(StatusCode::NOT_FOUND, "User not found");
+			};
+			
+			let parsed_user_id = match Uuid::parse_str(&user.id) {
+                Ok(uuid) => uuid,
+                Err(e) => return common_response(StatusCode::BAD_REQUEST, &format!("Invalid User ID format: {}", e)),
+            };
+
+			// Check if user has enough credits
+			let credit_opt = repo_credits.query_by_user_id(parsed_user_id).await;
+			let has_enough_credits = match credit_opt {
+				Ok(Some(credit)) => credit.available_rolls > 0,
+				Ok(None) => false, // No credit record means no credits
+				Err(e) => {
+					return common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string())
+				}
+			};
+			
+			if !has_enough_credits {
+				return common_response(StatusCode::PAYMENT_REQUIRED, "Not enough credits to perform this action");
+			}
+			
+			// Consume one credit
+			if let Err(e) = repo_credits.query_consume_credit(parsed_user_id).await { return common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()) }
+			
+			// Proceed with the roll
+			match repo.query_all_active_rolls().await {
+				Ok(rolls) => match GachaRollRepository::roll_once(&rolls) {
+					Some(roll) => {
+						let user_id_clone = user.id.clone();
+						let claim = GachaClaimSchema::roll(roll.clone(), user_id_clone);
+						match repo_claim.query_create_gacha_claim(claim).await {
+							Ok(_) => success_response(ResponseSuccessDto {
+								data: GachaRollItemDto::from(&roll),
+							}),
+							Err(e) => {
+								// Refund the credit if claim creation fails
+								let user_id = user.id.clone(); // Extract value before potential move
+								let _ = repo_credits.query_add_credit(crate::v1::gacha_credits::gacha_credits_dto::GachaCreditRequestDto {
+									user_id,
+									amount: 1,
+								}).await;
+								common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string())
+							}
+						}
+					}
+					None => common_response(StatusCode::NOT_FOUND, "No rollable item available"),
+				},
+				Err(e) => common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+			}
+		}
+
+	pub async fn soft_delete_gacha_roll(state: &AppState, id: Uuid) -> Response {
+		let repo = GachaRollRepository::new(state);
+		match repo.query_soft_delete_gacha_roll(id).await {
+			Ok(msg) => common_response(StatusCode::OK, &msg),
+			Err(e) => common_response(StatusCode::NOT_FOUND, &e.to_string()),
+		}
+	}
+}

imphnen-gacha/src/v1/gacha_rolls/mod.rs

@@ -1,26 +1,26 @@
-use axum::{
-    Router,
-    routing::{get, post},
-};
-
-pub mod gacha_rolls_controller;
-pub mod gacha_rolls_dto;
-pub mod gacha_rolls_repository;
-pub mod gacha_rolls_schema;
-pub mod gacha_rolls_service;
-
-// Export only public API functions and types
-pub use gacha_rolls_controller::{
-    post_create_gacha_roll,
-    post_execute_gacha_roll,
-    get_detail_gacha_roll,
-};
-pub use gacha_rolls_dto::GachaRollItemDto;
-
-/// Creates router for gacha rolls endpoints
-pub fn gacha_roll_router() -> Router {
-    Router::new()
-        .route("/create", post(post_create_gacha_roll))
-        .route("/execute", post(post_execute_gacha_roll))
-        .route("/detail/{id}", get(get_detail_gacha_roll))
-}
+use axum::{
+    Router,
+    routing::{get, post},
+};
+
+pub mod gacha_rolls_controller;
+pub mod gacha_rolls_dto;
+pub mod gacha_rolls_repository;
+pub mod gacha_rolls_schema;
+pub mod gacha_rolls_service;
+
+// Export only public API functions and types
+pub use gacha_rolls_controller::{
+    post_create_gacha_roll,
+    post_execute_gacha_roll,
+    get_detail_gacha_roll,
+};
+pub use gacha_rolls_dto::GachaRollItemDto;
+
+/// Creates router for gacha rolls endpoints
+pub fn gacha_roll_router() -> Router {
+    Router::new()
+        .route("/create", post(post_create_gacha_roll))
+        .route("/execute", post(post_execute_gacha_roll))
+        .route("/detail/{id}", get(get_detail_gacha_roll))
+}

imphnen-gacha/src/v1/mod.rs

@@ -1,26 +1,26 @@
-use axum::Router;
-
-pub mod gacha_claims;
-pub mod gacha_credits;
-pub mod gacha_items;
-pub mod gacha_rolls;
-use crate::v1::gacha_items::gacha_items_controller;
-
-// Export only public router functions to avoid namespace pollution
-pub use gacha_credits::gacha_credit_router;
-pub use gacha_items::gacha_item_router;
-pub use gacha_rolls::gacha_roll_router;
-pub use gacha_claims::gacha_claim_router;
-
-/// Creates the main gacha router with all version 1 endpoints
-pub fn gacha_router() -> Router {
-    let mut router = Router::new();
-    router = router.nest("/credits", gacha_credit_router());
-    router = router.nest("/items", gacha_item_router());
-    router = router.nest("/rolls", gacha_roll_router());
-    router = router.nest("/claims", gacha_claim_router());
-    // Minimal admin router mounted at /admin to satisfy test.sh expectations
-    // This will expose GET /v1/gacha/admin -> list items (admin view)
-    router = router.nest("/admin", Router::new().route("/", axum::routing::get(gacha_items_controller::get_gacha_item_list)));
-    router
-}
+use axum::Router;
+
+pub mod gacha_claims;
+pub mod gacha_credits;
+pub mod gacha_items;
+pub mod gacha_rolls;
+use crate::v1::gacha_items::gacha_items_controller;
+
+// Export only public router functions to avoid namespace pollution
+pub use gacha_credits::gacha_credit_router;
+pub use gacha_items::gacha_item_router;
+pub use gacha_rolls::gacha_roll_router;
+pub use gacha_claims::gacha_claim_router;
+
+/// Creates the main gacha router with all version 1 endpoints
+pub fn gacha_router() -> Router {
+    let mut router = Router::new();
+    router = router.nest("/credits", gacha_credit_router());
+    router = router.nest("/items", gacha_item_router());
+    router = router.nest("/rolls", gacha_roll_router());
+    router = router.nest("/claims", gacha_claim_router());
+    // Minimal admin router mounted at /admin to satisfy test.sh expectations
+    // This will expose GET /v1/gacha/admin -> list items (admin view)
+    router = router.nest("/admin", Router::new().route("/", axum::routing::get(gacha_items_controller::get_gacha_item_list)));
+    router
+}