92 lines
2.4 KiB
Rust
92 lines
2.4 KiB
Rust
use super::{AuthActiveInactiveRequestDto, AuthRegisterRequestDto};
|
|
use crate::{
|
|
v1::{users_schema::UsersSchema, UsersItemDto},
|
|
AppState, RedisKeyEnum, ResourceEnum,
|
|
};
|
|
use anyhow::{bail, Result};
|
|
use redis::Commands;
|
|
|
|
pub struct AuthRepository<'a> {
|
|
state: &'a AppState,
|
|
}
|
|
|
|
impl<'a> AuthRepository<'a> {
|
|
pub fn new(state: &'a AppState) -> Self {
|
|
Self { state }
|
|
}
|
|
|
|
pub fn query_store_user_data(
|
|
&self,
|
|
user: AuthRegisterRequestDto,
|
|
) -> Result<String> {
|
|
let redis_key = format!("{}:{}", RedisKeyEnum::User, user.email.clone());
|
|
match &self.state.redisdb.get_connection().and_then(|mut conn| {
|
|
conn.set_ex::<_, String, ()>(
|
|
&redis_key,
|
|
serde_json::to_string(&user).unwrap_or_default(),
|
|
86400,
|
|
)
|
|
}) {
|
|
Ok(_) => Ok("Success store user data".to_string()),
|
|
Err(err) => Ok(format!("Redis storage failed: {}", err)),
|
|
}
|
|
}
|
|
|
|
pub fn query_get_stored_user(&self, email: String) -> Result<UsersItemDto> {
|
|
let redis_key = format!("{}:{}", RedisKeyEnum::User, email);
|
|
let mut conn = self.state.redisdb.get_connection()?;
|
|
let data: Option<String> = conn.get(&redis_key)?;
|
|
match data {
|
|
Some(user_json) => {
|
|
let user: UsersItemDto = serde_json::from_str(&user_json)?;
|
|
Ok(user)
|
|
}
|
|
None => bail!("No stored user data found"),
|
|
}
|
|
}
|
|
|
|
pub async fn query_user_by_email(&self, email: String) -> Result<UsersSchema> {
|
|
let db = &self.state.surrealdb;
|
|
let result = db.select((ResourceEnum::Users.to_string(), email)).await?;
|
|
match result {
|
|
Some(response) => Ok(response),
|
|
None => bail!("User not found"),
|
|
}
|
|
}
|
|
|
|
pub async fn query_create_user(
|
|
&self,
|
|
data: AuthRegisterRequestDto,
|
|
) -> Result<String> {
|
|
let db = &self.state.surrealdb;
|
|
let record: Option<UsersItemDto> = db
|
|
.create((ResourceEnum::Users.to_string(), &data.email))
|
|
.content(UsersSchema {
|
|
fullname: data.fullname.clone(),
|
|
email: data.email.clone(),
|
|
password: data.password.clone(),
|
|
is_active: false,
|
|
})
|
|
.await?;
|
|
match record {
|
|
Some(_) => Ok("Success create user".into()),
|
|
None => bail!("Failed to create user"),
|
|
}
|
|
}
|
|
|
|
pub async fn query_active_inactive_user(
|
|
&self,
|
|
data: AuthActiveInactiveRequestDto,
|
|
) -> Result<String> {
|
|
let db = &self.state.surrealdb;
|
|
let record: Option<UsersItemDto> = db
|
|
.update((ResourceEnum::Users.to_string(), &data.email))
|
|
.content(data)
|
|
.await?;
|
|
match record {
|
|
Some(_) => Ok("Success update user".into()),
|
|
None => bail!("Failed to update user"),
|
|
}
|
|
}
|
|
}
|