chore: normalize code

imphnen-iam/src/v1/users/mod.rs

@@ -0,0 +1,28 @@
+use axum::{
+	Router,
+	routing::{delete, get, post, put},
+};
+
+pub mod users_controller;
+pub mod users_dto;
+pub mod users_repository;
+pub mod users_schema;
+pub mod users_service;
+
+pub use users_controller::*;
+pub use users_dto::*;
+pub use users_repository::*;
+pub use users_schema::*;
+pub use users_service::*;
+
+pub fn users_router() -> Router {
+	Router::new()
+		.route("/", get(get_user_list))
+		.route("/activate/{id}", put(patch_user_active_status))
+		.route("/create", post(post_create_user))
+		.route("/me", get(get_user_me))
+		.route("/delete/{id}", delete(delete_user))
+		.route("/detail/{id}", get(get_user_by_id))
+		.route("/update/{id}", put(put_update_user))
+		.route("/update/me", put(put_update_user_me))
+}

imphnen-iam/src/v1/users/users_controller.rs

@@ -0,0 +1,242 @@
+use axum::extract::{Path, Query};
+use axum::http::HeaderMap;
+use axum::response::IntoResponse;
+use axum::{Extension, Json};
+
+use crate::{
+	permissions_guard, MessageResponseDto, PermissionsEnum, ResponseListSuccessDto,
+	ResponseSuccessDto, UsersActiveInactiveRequestDto, UsersCreateRequestDto,
+	UsersDetailItemDto,
+};
+use crate::{v1::users_service::UsersService, AppState, MetaRequestDto};
+
+use super::{UsersListItemDto, UsersUpdateRequestDto};
+
+#[utoipa::path(
+	get,
+	security(
+        ("Bearer" = [])
+    ),
+	path = "/v1/users",
+	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 = "Get user list", body = ResponseListSuccessDto<Vec<UsersListItemDto>>)
+	),
+	tag = "Users"
+)]
+pub async fn get_user_list(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Query(meta): Query<MetaRequestDto>,
+) -> impl IntoResponse {
+	match permissions_guard(
+		&headers,
+		state.clone(),
+		vec![PermissionsEnum::ReadListUsers],
+	)
+	.await
+	{
+		Ok(_) => UsersService::get_user_list(&state, meta).await,
+		Err(response) => response,
+	}
+}
+
+#[utoipa::path(
+	get,
+	security(
+        ("Bearer" = [])
+    ),
+	path = "/v1/users/detail/{id}",
+	params(
+		("id" = String, Path, description = "User ID")
+	),
+	responses(
+		(status = 200, description = "Get user by ID", body = ResponseSuccessDto<UsersDetailItemDto>)
+	),
+	tag = "Users"
+)]
+pub async fn get_user_by_id(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+) -> impl IntoResponse {
+	match permissions_guard(
+		&headers,
+		state.clone(),
+		vec![PermissionsEnum::ReadDetailUsers],
+	)
+	.await
+	{
+		Ok(_) => UsersService::get_user_by_id(&state, id).await,
+		Err(response) => response,
+	}
+}
+
+#[utoipa::path(
+	get,
+	security(
+        ("Bearer" = [])
+    ),
+	path = "/v1/users/me",
+	responses(
+		(status = 200, description = "Get user by ID", body = ResponseSuccessDto<UsersDetailItemDto>)
+	),
+	tag = "Users"
+)]
+pub async fn get_user_me(
+	Extension(state): Extension<AppState>,
+	headers: HeaderMap,
+) -> impl IntoResponse {
+	match permissions_guard(&headers, state.clone(), vec![]).await {
+		Ok(_) => UsersService::get_user_me(headers, &state).await,
+		Err(response) => response,
+	}
+}
+
+#[utoipa::path(
+	post,
+	security(
+        ("Bearer" = [])
+    ),
+	path = "/v1/users/create",
+	request_body = UsersCreateRequestDto,
+	responses(
+		(status = 201, description = "Create new user", body = MessageResponseDto)
+	),
+	tag = "Users"
+)]
+pub async fn post_create_user(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Json(payload): Json<UsersCreateRequestDto>,
+) -> impl IntoResponse {
+	match permissions_guard(
+		&headers,
+		state.clone(),
+		vec![PermissionsEnum::CreateUsers],
+	)
+	.await
+	{
+		Ok(_) => UsersService::create_user(&state, payload).await,
+		Err(response) => response,
+	}
+}
+
+#[utoipa::path(
+	put,
+	security(
+        ("Bearer" = [])
+    ),
+	path = "/v1/users/update/{id}",
+	request_body = UsersUpdateRequestDto,
+	responses(
+		(status = 200, description = "Update user", body = MessageResponseDto)
+	),
+	tag = "Users"
+)]
+pub async fn put_update_user(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+	Json(payload): Json<UsersUpdateRequestDto>,
+) -> impl IntoResponse {
+	match permissions_guard(
+		&headers,
+		state.clone(),
+		vec![PermissionsEnum::UpdateUsers],
+	)
+	.await
+	{
+		Ok(_) => UsersService::update_user(&state, id, payload).await,
+		Err(response) => response,
+	}
+}
+
+#[utoipa::path(
+	put,
+	security(
+        ("Bearer" = [])
+    ),
+	path = "/v1/users/update/me",
+	request_body = UsersUpdateRequestDto,
+	responses(
+		(status = 200, description = "Update user me", body = MessageResponseDto)
+	),
+	tag = "Users"
+)]
+pub async fn put_update_user_me(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Json(payload): Json<UsersUpdateRequestDto>,
+) -> impl IntoResponse {
+	match permissions_guard(&headers, state.clone(), vec![]).await {
+		Ok(_) => UsersService::update_user_me(&state, headers, payload).await,
+		Err(response) => response,
+	}
+}
+
+#[utoipa::path(
+	put,
+	security(
+        ("Bearer" = [])
+    ),
+	path = "/v1/users/activate/{id}",
+	request_body = UsersActiveInactiveRequestDto,
+	responses(
+		(status = 200, description = "Set user active/inactive", body = MessageResponseDto)
+	),
+	tag = "Users"
+)]
+pub async fn patch_user_active_status(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+	Json(payload): Json<UsersActiveInactiveRequestDto>,
+) -> impl IntoResponse {
+	match permissions_guard(
+		&headers,
+		state.clone(),
+		vec![PermissionsEnum::UpdateUsers],
+	)
+	.await
+	{
+		Ok(_) => UsersService::set_user_active_status(&state, id, payload).await,
+		Err(response) => response,
+	}
+}
+
+#[utoipa::path(
+	delete,
+	security(
+        ("Bearer" = [])
+    ),
+	path = "/v1/users/delete/{id}",
+	responses(
+		(status = 200, description = "Soft delete user", body = MessageResponseDto)
+	),
+	tag = "Users"
+)]
+pub async fn delete_user(
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Path(id): Path<String>,
+) -> impl IntoResponse {
+	match permissions_guard(
+		&headers,
+		state.clone(),
+		vec![PermissionsEnum::DeleteUsers],
+	)
+	.await
+	{
+		Ok(_) => UsersService::delete_user(&state, id).await,
+		Err(response) => response,
+	}
+}

imphnen-iam/src/v1/users/users_dto.rs

@@ -0,0 +1,143 @@
+use crate::{RolesDetailQueryDto, RolesItemDto};
+use lazy_static::lazy_static;
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+use surrealdb::sql::Thing;
+use utoipa::ToSchema;
+use validator::Validate;
+
+lazy_static! {
+	static ref PASSWORD_REGEX: Regex = Regex::new(r"^[A-Za-z\d@$!%*?&]{8,}$").unwrap();
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
+pub struct UsersCreateRequestDto {
+	#[validate(
+		length(min = 1, message = "Email cannot be empty"),
+		email(message = "Email not valid")
+	)]
+	pub email: String,
+
+	#[validate(length(
+		min = 8,
+		message = "Password must have at least 8 characters"
+	))]
+	#[validate(regex(
+		path = "PASSWORD_REGEX",
+		message = "Password must include uppercase, lowercase, number, and special character"
+	))]
+	pub password: String,
+
+	#[validate(length(min = 2, message = "Fullname at least have 2 character"))]
+	pub fullname: String,
+
+	#[validate(length(
+		min = 10,
+		message = "Phone number at least have 10 character"
+	))]
+	pub phone_number: String,
+	pub is_active: bool,
+	pub role_id: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema, Validate)]
+pub struct UsersUpdateRequestDto {
+	#[validate(
+		length(min = 1, message = "Email cannot be empty"),
+		email(message = "Email not valid")
+	)]
+	pub email: String,
+	#[validate(length(
+		min = 8,
+		message = "Password must have at least 8 characters"
+	))]
+	#[validate(length(min = 2, message = "Fullname at least have 2 character"))]
+	pub fullname: String,
+	#[validate(length(
+		min = 10,
+		message = "Phone number at least have 10 character"
+	))]
+	pub phone_number: String,
+	pub is_active: bool,
+	#[validate(length(min = 1, message = "Gender is required"))]
+	pub gender: Option<String>,
+	#[validate(length(min = 1, message = "Birthdate is required"))]
+	pub birthdate: Option<String>,
+	#[validate(length(min = 1, message = "Avatar is required"))]
+	pub avatar: Option<String>,
+	pub role_id: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct UsersDetailItemDto {
+	pub id: String,
+	pub role: RolesItemDto,
+	pub fullname: String,
+	pub email: String,
+	pub avatar: Option<String>,
+	pub phone_number: String,
+	pub is_active: bool,
+	pub gender: Option<String>,
+	pub birthdate: Option<String>,
+	pub created_at: String,
+	pub updated_at: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct UsersListItemDto {
+	pub id: String,
+	pub role: String,
+	pub fullname: String,
+	pub email: String,
+	pub avatar: Option<String>,
+	pub phone_number: String,
+	pub is_active: bool,
+	pub created_at: String,
+	pub updated_at: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct UsersListQueryDto {
+	pub id: Thing,
+	pub role: RolesDetailQueryDto,
+	pub fullname: String,
+	pub email: String,
+	pub avatar: Option<String>,
+	pub phone_number: String,
+	pub is_active: bool,
+	pub created_at: String,
+	pub updated_at: String,
+}
+
+impl UsersListQueryDto {
+	pub fn list_from(&self, role: String) -> UsersListItemDto {
+		UsersListItemDto {
+			id: self.id.id.to_raw(),
+			role,
+			fullname: self.fullname.clone(),
+			email: self.email.clone(),
+			avatar: self.avatar.clone(),
+			phone_number: self.phone_number.clone(),
+			is_active: self.is_active,
+			created_at: self.created_at.clone(),
+			updated_at: self.updated_at.clone(),
+		}
+	}
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct UsersDetailQueryDto {
+	pub id: Thing,
+	pub fullname: String,
+	pub email: String,
+	pub avatar: Option<String>,
+	pub phone_number: String,
+	pub is_active: bool,
+	pub is_deleted: bool,
+	pub gender: Option<String>,
+	pub birthdate: Option<String>,
+	pub password: String,
+	pub role: RolesDetailQueryDto,
+	pub created_at: String,
+	pub updated_at: String,
+}

imphnen-iam/src/v1/users/users_repository.rs

@@ -0,0 +1,296 @@
+use super::{UsersDetailQueryDto, UsersListItemDto, UsersListQueryDto, UsersSchema};
+use crate::{
+	AppState, MetaRequestDto, PermissionsItemDto, PermissionsItemDtoRaw, ResourceEnum,
+	ResponseListSuccessDto, RolesDetailQueryDto, extract_id, get_id, make_thing,
+	query_list_with_meta,
+};
+use anyhow::{Result, bail};
+
+pub struct UsersRepository<'a> {
+	state: &'a AppState,
+}
+
+pub fn build_user_by_field_query(field: &str) -> String {
+	format!(
+		r#"
+		SELECT *, role AS role 
+		FROM {} 
+		WHERE {} = $value AND is_deleted = false 
+		LIMIT 1 
+		FETCH role, role.permissions
+		"#,
+		ResourceEnum::Users.to_string(),
+		field
+	)
+}
+
+impl<'a> UsersRepository<'a> {
+	pub fn new(state: &'a AppState) -> Self {
+		Self { state }
+	}
+
+	pub async fn query_user_list(
+		&self,
+		meta: MetaRequestDto,
+	) -> Result<ResponseListSuccessDto<Vec<UsersListItemDto>>> {
+		let db = &self.state.surrealdb_ws;
+
+		let raw_result = query_list_with_meta::<UsersListQueryDto>(
+			db,
+			&ResourceEnum::Users.to_string(),
+			&meta,
+			vec!["is_deleted = false".into()],
+			None,
+			"fullname",
+			Some(vec![
+				"email",
+				"fullname",
+				"id",
+				"is_active",
+				"is_deleted",
+				"role",
+				"role.permissions",
+			]),
+		)
+		.await?;
+
+		let data = raw_result
+			.data
+			.into_iter()
+			.map(|schema| {
+				let role = schema.clone().role.name;
+				schema.list_from(role)
+			})
+			.collect::<Vec<_>>();
+
+		Ok(ResponseListSuccessDto {
+			data,
+			meta: raw_result.meta,
+		})
+	}
+
+	pub async fn query_user_by_email(
+		&self,
+		email: String,
+	) -> Result<UsersDetailQueryDto> {
+		let db = &self.state.surrealdb_ws;
+
+		let sql = build_user_by_field_query("email");
+
+		let user_opt: Option<UsersDetailQueryDto> = db
+			.query(sql)
+			.bind(("email", email.clone()))
+			.await?
+			.take(0)?;
+
+		let Some(user) = user_opt else {
+			bail!("User not found");
+		};
+
+		if user.role.is_deleted {
+			bail!("User not found");
+		}
+
+		let permissions = user
+			.role
+			.permissions
+			.into_iter()
+			.map(|perm| PermissionsItemDtoRaw {
+				id: perm.id,
+				name: perm.name,
+				created_at: perm.created_at,
+				updated_at: perm.updated_at,
+			})
+			.collect();
+
+		Ok(UsersDetailQueryDto {
+			id: user.id,
+			fullname: user.fullname,
+			email: user.email,
+			avatar: user.avatar,
+			phone_number: user.phone_number,
+			is_active: user.is_active,
+			is_deleted: user.is_deleted,
+			gender: user.gender,
+			birthdate: user.birthdate,
+			password: user.password,
+			created_at: user.created_at,
+			updated_at: user.updated_at,
+			role: RolesDetailQueryDto {
+				id: user.role.id,
+				name: user.role.name,
+				created_at: user.role.created_at,
+				updated_at: user.role.updated_at,
+				is_deleted: user.role.is_deleted,
+				permissions,
+			},
+		})
+	}
+
+	pub async fn query_user_by_id(&self, id: String) -> Result<UsersDetailQueryDto> {
+		let db = &self.state.surrealdb_ws;
+
+		let sql = build_user_by_field_query(&make_thing("app_users", &id).to_raw());
+
+		let user_opt: Option<UsersDetailQueryDto> = db
+			.query(sql)
+			.bind(("email", make_thing("app_users", &id).to_raw()))
+			.await?
+			.take(0)?;
+
+		let Some(user) = user_opt else {
+			bail!("User not found");
+		};
+
+		if user.role.is_deleted {
+			bail!("User not found");
+		}
+
+		let permissions = user
+			.role
+			.permissions
+			.into_iter()
+			.map(|perm| PermissionsItemDtoRaw {
+				id: perm.id,
+				name: perm.name,
+				created_at: perm.created_at,
+				updated_at: perm.updated_at,
+			})
+			.collect();
+
+		Ok(UsersDetailQueryDto {
+			id: user.id,
+			fullname: user.fullname,
+			email: user.email,
+			avatar: user.avatar,
+			phone_number: user.phone_number,
+			is_active: user.is_active,
+			is_deleted: user.is_deleted,
+			gender: user.gender,
+			birthdate: user.birthdate,
+			password: user.password,
+			created_at: user.created_at,
+			updated_at: user.updated_at,
+			role: RolesDetailQueryDto {
+				id: user.role.id,
+				name: user.role.name,
+				created_at: user.role.created_at,
+				updated_at: user.role.updated_at,
+				is_deleted: user.role.is_deleted,
+				permissions,
+			},
+		})
+	}
+
+	pub async fn query_create_user(&self, data: UsersSchema) -> Result<String> {
+		let db = &self.state.surrealdb_ws;
+		let record: Option<UsersSchema> = db
+			.create(ResourceEnum::Users.to_string())
+			.content(data)
+			.await?;
+		match record {
+			Some(_) => Ok("Success create user".into()),
+			None => bail!("Failed to create user"),
+		}
+	}
+
+	pub async fn query_update_user(&self, data: UsersSchema) -> Result<String> {
+		let db = &self.state.surrealdb_ws;
+		let record_key = get_id(&data.id)?;
+		let existing = self.query_user_by_id(data.id.id.to_raw()).await?;
+		if existing.is_deleted {
+			bail!("User already deleted");
+		}
+		let merged = UsersSchema {
+			password: existing.password,
+			created_at: existing.created_at,
+			role: make_thing("app_roles", &existing.role.id),
+			..data.clone()
+		};
+		let record: Option<UsersSchema> = db.update(record_key).merge(merged).await?;
+		match record {
+			Some(_) => Ok("Success update user".into()),
+			None => bail!("Failed to update user"),
+		}
+	}
+
+	pub async fn query_active_inactive_user(
+		&self,
+		email: String,
+		data: UsersActiveInactiveSchema,
+	) -> Result<String> {
+		let db = &self.state.surrealdb_ws;
+		let user = self.query_user_by_email(email.clone()).await?;
+		if user.is_deleted {
+			bail!("User already deleted");
+		}
+		let record_key = get_id(&user.id)?;
+		let record: Option<UsersSchema> = db
+			.update(record_key)
+			.merge(UsersActiveInactiveSchema {
+				is_active: data.is_active,
+			})
+			.await?;
+		match record {
+			Some(_) => Ok("Success update user".into()),
+			None => bail!("Failed to update user"),
+		}
+	}
+
+	pub async fn query_active_inactive_user_by_id(
+		&self,
+		id: String,
+		data: UsersActiveInactiveSchema,
+	) -> Result<String> {
+		let db = &self.state.surrealdb_ws;
+		let record: Option<UsersSchema> = db
+			.update((ResourceEnum::Users.to_string(), id))
+			.merge(UsersActiveInactiveSchema {
+				is_active: data.is_active,
+			})
+			.await?;
+		match record {
+			Some(_) => Ok("Success update user".into()),
+			None => bail!("Failed to update user"),
+		}
+	}
+
+	pub async fn query_update_password_user(
+		&self,
+		email: String,
+		data: UsersSetNewPasswordSchema,
+	) -> Result<String> {
+		let db = &self.state.surrealdb_ws;
+		let user = self.query_user_by_email(email).await?;
+		let record: Option<UsersSetNewPasswordSchema> = db
+			.update((ResourceEnum::Users.to_string(), user.id.id.to_raw()))
+			.merge(UsersSetNewPasswordSchema {
+				password: data.password.clone(),
+			})
+			.await?;
+		dbg!(record.clone());
+		match record {
+			Some(_) => Ok("Success update password user".into()),
+			None => bail!("Failed to update password user"),
+		}
+	}
+
+	pub async fn query_delete_user(&self, id: String) -> Result<String> {
+		let db = &self.state.surrealdb_ws;
+		let user_id = make_thing(&ResourceEnum::Users.to_string(), &id);
+		let user = self.query_user_by_id(user_id.id.to_raw()).await?;
+		if user.is_deleted {
+			bail!("User already deleted");
+		}
+		let id = make_thing(&ResourceEnum::Users.to_string(), &user.id);
+		let record_key = get_id(&id)?;
+		let record: Option<UsersSchema> = db
+			.update(record_key)
+			.merge(serde_json::json!({ "is_deleted": true }))
+			.await?;
+		match record {
+			Some(_) => Ok("Success delete user".into()),
+			None => bail!("Failed to delete user"),
+		}
+	}
+}

imphnen-iam/src/v1/users/users_schema.rs

@@ -0,0 +1,66 @@
+use super::{UsersDetailItemDto, UsersListItemDto};
+use crate::RolesItemDto;
+use imphnen_utils::Crud;
+use serde::{Deserialize, Serialize};
+use surrealdb::sql::Thing;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct UsersSchema {
+	pub id: Thing,
+	pub fullname: String,
+	pub email: String,
+	pub password: String,
+	pub avatar: Option<String>,
+	pub phone_number: String,
+	pub is_active: bool,
+	pub is_deleted: bool,
+	pub gender: Option<String>,
+	pub birthdate: Option<String>,
+	pub role: Thing,
+	pub created_at: String,
+	pub updated_at: String,
+}
+
+impl Crud<UsersListItemDto, String> for UsersSchema {
+	fn list(&self, role: String) -> UsersListItemDto {
+		UsersListItemDto {
+			id: self.id.id.to_raw(),
+			role,
+			fullname: self.fullname.clone(),
+			email: self.email.clone(),
+			avatar: self.avatar.clone(),
+			phone_number: self.phone_number.clone(),
+			is_active: self.is_active,
+			created_at: self.created_at.clone(),
+			updated_at: self.updated_at.clone(),
+		}
+	}
+}
+
+impl Crud<UsersDetailItemDto, RolesItemDto> for UsersSchema {
+	fn detail(&self, role: RolesItemDto) -> UsersDetailItemDto {
+		UsersDetailItemDto {
+			id: self.id.id.to_raw(),
+			role,
+			fullname: self.fullname.clone(),
+			email: self.email.clone(),
+			avatar: self.avatar.clone(),
+			phone_number: self.phone_number.clone(),
+			is_active: self.is_active,
+			gender: self.gender.clone(),
+			birthdate: self.birthdate.clone(),
+			created_at: self.created_at.clone(),
+			updated_at: self.updated_at.clone(),
+		}
+	}
+}
+
+impl UsersSchema {
+	pub fn list_from(&self, role: String) -> UsersListItemDto {
+		self.list(role)
+	}
+
+	pub fn detail_from(&self, role: RolesItemDto) -> UsersDetailItemDto {
+		self.detail(role)
+	}
+}

imphnen-iam/src/v1/users/users_service.rs

@@ -0,0 +1,229 @@
+use crate::{
+	common_response, extract_email, get_iso_date, hash_password, make_thing,
+	success_list_response, success_response, validate_request, ResourceEnum,
+	ResponseSuccessDto,
+};
+use crate::{
+	AppState, MetaRequestDto, ResponseListSuccessDto, UsersActiveInactiveSchema,
+	UsersRepository, UsersSchema, UsersSetNewPasswordSchema,
+};
+use axum::http::HeaderMap;
+use axum::{http::StatusCode, response::Response};
+
+use super::{
+	UsersActiveInactiveRequestDto, UsersCreateRequestDto, UsersDetailItemDto,
+	UsersUpdateRequestDto,
+};
+
+pub struct UsersService;
+
+impl UsersService {
+	pub async fn get_user_list(state: &AppState, meta: MetaRequestDto) -> Response {
+		let repo = UsersRepository::new(state);
+		match repo.query_user_list(meta).await {
+			Ok(data) => {
+				let response = ResponseListSuccessDto {
+					data: data.data,
+					meta: data.meta,
+				};
+				success_list_response(response)
+			}
+			Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+		}
+	}
+
+	pub async fn get_user_by_id(state: &AppState, id: String) -> Response {
+		let repo = UsersRepository::new(state);
+		match repo.query_user_by_id(id).await {
+			Ok(user) if !user.is_deleted => success_response(ResponseSuccessDto {
+				data: UsersDetailItemDto {
+					id: user.id,
+					role: user.role,
+					fullname: user.fullname,
+					email: user.email,
+					avatar: user.avatar,
+					phone_number: user.phone_number,
+					is_active: user.is_active,
+					gender: user.gender,
+					birthdate: user.birthdate,
+				},
+			}),
+			Ok(_) => common_response(StatusCode::NOT_FOUND, "User not found"),
+			Err(e) => common_response(StatusCode::NOT_FOUND, &e.to_string()),
+		}
+	}
+
+	pub async fn get_user_me(headers: HeaderMap, state: &AppState) -> Response {
+		let repo = UsersRepository::new(state);
+		let email = extract_email(&headers).unwrap();
+		let user = repo.query_user_by_email(email).await.unwrap();
+		match repo.query_user_by_id(user.id.id.to_raw()).await {
+			Ok(user) => success_response(ResponseSuccessDto {
+				data: UsersDetailItemDto {
+					id: user.id,
+					role: user.role,
+					fullname: user.fullname,
+					email: user.email,
+					avatar: user.avatar,
+					phone_number: user.phone_number,
+					is_active: user.is_active,
+					gender: user.gender,
+					birthdate: user.birthdate,
+				},
+			}),
+			Err(e) => common_response(StatusCode::NOT_FOUND, &e.to_string()),
+		}
+	}
+
+	pub async fn create_user(
+		state: &AppState,
+		new_user: UsersCreateRequestDto,
+	) -> Response {
+		if let Err((status, message)) = validate_request(&new_user) {
+			return common_response(status, &message);
+		}
+		let repo = UsersRepository::new(state);
+		if repo
+			.query_user_by_email(new_user.email.clone())
+			.await
+			.is_ok()
+		{
+			return common_response(StatusCode::BAD_REQUEST, "User already exists");
+		}
+		let role_thing = make_thing(&ResourceEnum::Roles.to_string(), &new_user.role_id);
+		match repo
+			.query_create_user(UsersSchema {
+				email: new_user.email.clone(),
+				fullname: new_user.fullname.clone(),
+				password: hash_password(&new_user.password).unwrap(),
+				phone_number: new_user.phone_number.clone(),
+				is_active: new_user.is_active.clone(),
+				role: role_thing,
+				..Default::default()
+			})
+			.await
+		{
+			Ok(msg) => common_response(StatusCode::CREATED, &msg),
+			Err(err) => {
+				common_response(StatusCode::INTERNAL_SERVER_ERROR, &err.to_string())
+			}
+		}
+	}
+
+	pub async fn update_user(
+		state: &AppState,
+		id: String,
+		user: UsersUpdateRequestDto,
+	) -> Response {
+		let repo = UsersRepository::new(state);
+
+		if let Err((status, message)) = validate_request(&user) {
+			return common_response(status, &message);
+		}
+
+		let user_id = make_thing(&ResourceEnum::Users.to_string(), &id);
+		let role_id = make_thing(&ResourceEnum::Roles.to_string(), "");
+
+		let updated_user = UsersSchema {
+			id: user_id,
+			fullname: user.fullname,
+			email: user.email,
+			phone_number: user.phone_number,
+			is_active: user.is_active,
+			gender: user.gender,
+			birthdate: user.birthdate,
+			avatar: user.avatar,
+			role: role_id,
+			updated_at: get_iso_date(),
+			..Default::default()
+		};
+
+		match repo.query_update_user(updated_user).await {
+			Ok(msg) => common_response(StatusCode::OK, &msg),
+			Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+		}
+	}
+
+	pub async fn update_user_me(
+		state: &AppState,
+		headers: HeaderMap,
+		user: UsersUpdateRequestDto,
+	) -> Response {
+		let repo = UsersRepository::new(state);
+		let email = extract_email(&headers).unwrap();
+		let user_data = repo.query_user_by_email(email).await.unwrap();
+		if let Err((status, message)) = validate_request(&user) {
+			return common_response(status, &message);
+		}
+		let user_id =
+			make_thing(&ResourceEnum::Users.to_string(), &user_data.id.id.to_raw());
+		let role_id = make_thing(&ResourceEnum::Roles.to_string(), "");
+		let updated_user = UsersSchema {
+			id: user_id,
+			fullname: user.fullname,
+			email: user.email,
+			phone_number: user.phone_number,
+
+			is_active: user.is_active,
+
+			gender: user.gender,
+			birthdate: user.birthdate,
+			avatar: user.avatar,
+
+			role: role_id,
+			updated_at: get_iso_date(),
+			..Default::default()
+		};
+		match repo.query_update_user(updated_user).await {
+			Ok(msg) => common_response(StatusCode::OK, &msg),
+			Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+		}
+	}
+
+	pub async fn set_user_active_status(
+		state: &AppState,
+		id: String,
+		status: UsersActiveInactiveRequestDto,
+	) -> Response {
+		let repo = UsersRepository::new(state);
+		let thing_id = make_thing(&ResourceEnum::Users.to_string(), &id);
+		match repo.query_user_by_id(thing_id.id.to_raw()).await {
+			Ok(_) => match repo
+				.query_active_inactive_user_by_id(
+					id,
+					UsersActiveInactiveSchema {
+						is_active: status.is_active,
+					},
+				)
+				.await
+			{
+				Ok(msg) => common_response(StatusCode::OK, &msg),
+				Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+			},
+			Err(err) => common_response(StatusCode::BAD_REQUEST, &err.to_string()),
+		}
+	}
+
+	pub async fn update_user_password(
+		state: &AppState,
+		email: String,
+		new_password: UsersSetNewPasswordSchema,
+	) -> Response {
+		let repo = UsersRepository::new(state);
+		match repo.query_update_password_user(email, new_password).await {
+			Ok(msg) => common_response(StatusCode::OK, &msg),
+			Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+		}
+	}
+
+	pub async fn delete_user(state: &AppState, id: String) -> Response {
+		let repo = UsersRepository::new(state);
+		if repo.query_user_by_id(id.clone()).await.is_err() {
+			return common_response(StatusCode::BAD_REQUEST, "User not found");
+		}
+		match repo.query_delete_user(id).await {
+			Ok(msg) => common_response(StatusCode::OK, &msg),
+			Err(e) => common_response(StatusCode::BAD_REQUEST, &e.to_string()),
+		}
+	}
+}