318 lines
8.3 KiB
Rust
318 lines
8.3 KiB
Rust
use super::{
|
|
UsersActiveInactiveSchema, UsersItemDto, UsersItemDtoRaw, UsersListItemDto,
|
|
UsersListItemDtoRaw, UsersSchema, UsersSetNewPasswordSchema,
|
|
};
|
|
use crate::{
|
|
extract_id, get_id, make_thing, query_list_with_meta, AppState, MetaRequestDto,
|
|
PermissionsItemDto, PermissionsItemDtoRaw, ResourceEnum, ResponseListSuccessDto,
|
|
RolesItemDto, RolesItemDtoRaw,
|
|
};
|
|
use anyhow::{anyhow, bail, Result};
|
|
|
|
pub struct UsersRepository<'a> {
|
|
state: &'a AppState,
|
|
}
|
|
|
|
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 mut conditions = vec!["is_deleted = false".to_string()];
|
|
if let Some(search) = meta.search.as_deref() {
|
|
if !search.is_empty() {
|
|
conditions.push("string::contains(fullname ?? '', $search)".to_string());
|
|
}
|
|
}
|
|
if let (Some(filter_by), Some(_filter)) =
|
|
(meta.filter_by.as_ref(), meta.filter.as_ref())
|
|
{
|
|
conditions.push(format!("{} = $filter", filter_by));
|
|
}
|
|
let where_clause = if !conditions.is_empty() {
|
|
format!("WHERE {}", conditions.join(" AND "))
|
|
} else {
|
|
String::new()
|
|
};
|
|
let limit = meta.per_page.unwrap_or(10);
|
|
let page = meta.page.unwrap_or(1);
|
|
if page < 1 || limit < 1 {
|
|
return Err(anyhow!("Invalid pagination parameters"));
|
|
}
|
|
let start = (page - 1) * limit;
|
|
let select_query = format!(
|
|
"
|
|
SELECT
|
|
id,
|
|
role.name AS role,
|
|
fullname,
|
|
email,
|
|
avatar,
|
|
phone_number,
|
|
is_active,
|
|
gender,
|
|
birthdate,
|
|
created_at,
|
|
updated_at
|
|
FROM {}
|
|
{}
|
|
LIMIT {} START {}
|
|
FETCH role
|
|
",
|
|
ResourceEnum::Users.to_string(),
|
|
where_clause,
|
|
limit,
|
|
start
|
|
);
|
|
let raw_result = query_list_with_meta::<UsersListItemDtoRaw>(
|
|
db,
|
|
&ResourceEnum::Users.to_string(),
|
|
&meta,
|
|
vec![],
|
|
Some(select_query),
|
|
)
|
|
.await?;
|
|
let transformed_data = raw_result
|
|
.data
|
|
.into_iter()
|
|
.map(|user| UsersListItemDto {
|
|
id: extract_id(&user.id),
|
|
fullname: user.fullname,
|
|
email: user.email,
|
|
avatar: user.avatar,
|
|
phone_number: user.phone_number,
|
|
is_active: user.is_active,
|
|
role: user.role.unwrap_or_else(|| "-".into()),
|
|
created_at: user.created_at,
|
|
updated_at: user.updated_at,
|
|
})
|
|
.collect::<Vec<_>>();
|
|
Ok(ResponseListSuccessDto {
|
|
data: transformed_data,
|
|
meta: raw_result.meta,
|
|
})
|
|
}
|
|
|
|
pub async fn query_user_by_email(&self, email: String) -> Result<UsersItemDtoRaw> {
|
|
let db = &self.state.surrealdb_ws;
|
|
let sql = format!(
|
|
"SELECT *, role AS role FROM {} WHERE email = $email AND is_deleted = false LIMIT 1 FETCH role, role.permissions",
|
|
ResourceEnum::Users.to_string()
|
|
);
|
|
|
|
let response: Option<UsersItemDtoRaw> = db
|
|
.query(sql)
|
|
.bind(("email", email.clone()))
|
|
.await?
|
|
.take(0)?;
|
|
|
|
match response {
|
|
Some(user) if !user.role.is_deleted => {
|
|
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::<Vec<_>>();
|
|
Ok(UsersItemDtoRaw {
|
|
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: RolesItemDtoRaw {
|
|
id: user.role.id,
|
|
name: user.role.name,
|
|
permissions,
|
|
created_at: user.role.created_at,
|
|
updated_at: user.role.updated_at,
|
|
is_deleted: user.role.is_deleted,
|
|
},
|
|
})
|
|
}
|
|
_ => bail!("User not found"),
|
|
}
|
|
}
|
|
|
|
pub async fn query_user_by_id(&self, id: String) -> Result<UsersItemDto> {
|
|
let db = &self.state.surrealdb_ws;
|
|
|
|
let query = format!(
|
|
"SELECT *, role AS role FROM app_users:⟨{}⟩ FETCH role, role.permissions",
|
|
id
|
|
);
|
|
|
|
let mut result = db.query(query).await?;
|
|
|
|
let response: Option<UsersItemDtoRaw> = result.take(0)?;
|
|
|
|
match response {
|
|
Some(user) if !user.role.is_deleted => {
|
|
let permissions = user
|
|
.role
|
|
.permissions
|
|
.into_iter()
|
|
.map(|perm| PermissionsItemDto {
|
|
id: extract_id(&perm.id),
|
|
name: perm.name,
|
|
created_at: perm.created_at,
|
|
updated_at: perm.updated_at,
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
Ok(UsersItemDto {
|
|
id: extract_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,
|
|
role: RolesItemDto {
|
|
id: extract_id(&user.role.id),
|
|
name: user.role.name,
|
|
permissions,
|
|
created_at: user.role.created_at,
|
|
updated_at: user.role.updated_at,
|
|
},
|
|
created_at: user.created_at,
|
|
updated_at: user.updated_at,
|
|
})
|
|
}
|
|
_ => bail!("User not found"),
|
|
}
|
|
}
|
|
|
|
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"),
|
|
}
|
|
}
|
|
}
|