29cc961
use models::users::user;
use models::users::{user_blocks, user_followers};
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, Set};
use time::OffsetDateTime;
use uuid::Uuid;
use super::AuthService;
use crate::errors::AuthError;
use crate::share::types::UserPublic;
impl AuthService {
pub async fn public_user(&self, uid: Uuid) -> Result<UserPublic, AuthError> {
let Some(user) = user::Entity::find_by_id(uid).one(self.db().read()).await? else {
return Err(AuthError::NotFound);
};
Ok(UserPublic {
uid: user.uid,
username: user.username,
display_name: user.display_name,
avatar_url: user.avatar_url,
})
}
pub async fn follow(&self, follower_uid: Uuid, followed_uid: Uuid) -> Result<(), AuthError> {
if follower_uid == followed_uid {
return Err(AuthError::BadRequest(
"cannot follow yourself".to_string(),
));
}
let db = self.db();
let followed_exists = user::Entity::find_by_id(followed_uid).one(db.read()).await?;
if followed_exists.is_none() {
return Err(AuthError::NotFound);
}
let existing = user_followers::Entity::find()
.filter(user_followers::Column::FollowerId.eq(follower_uid))
.filter(user_followers::Column::FollowedId.eq(followed_uid))
.one(db.write())
.await?;
if existing.is_some() {
return Ok(());
}
let row = user_followers::ActiveModel {
id: Set(Uuid::now_v7()),
follower_id: Set(follower_uid),
followed_id: Set(followed_uid),
created_at: Set(OffsetDateTime::now_utc()),
};
row.insert(db.write()).await?;
Ok(())
}
pub async fn unfollow(&self, follower_uid: Uuid, followed_uid: Uuid) -> Result<(), AuthError> {
let db = self.db();
user_followers::Entity::delete_many()
.filter(user_followers::Column::FollowerId.eq(follower_uid))
.filter(user_followers::Column::FollowedId.eq(followed_uid))
.exec(db.write())
.await?;
Ok(())
}
pub async fn followers(&self, uid: Uuid) -> Result<Vec<UserPublic>, AuthError> {
let rows = user_followers::Entity::find()
.filter(user_followers::Column::FollowedId.eq(uid))
.all(self.db().read())
.await?;
let ids: Vec<Uuid> = rows.into_iter().map(|row| row.follower_id).collect();
self.load_users_public(&ids).await
}
pub async fn following(&self, uid: Uuid) -> Result<Vec<UserPublic>, AuthError> {
let rows = user_followers::Entity::find()
.filter(user_followers::Column::FollowerId.eq(uid))
.all(self.db().read())
.await?;
let ids: Vec<Uuid> = rows.into_iter().map(|row| row.followed_id).collect();
self.load_users_public(&ids).await
}
pub async fn block(&self, blocker_uid: Uuid, blocked_uid: Uuid) -> Result<(), AuthError> {
if blocker_uid == blocked_uid {
return Err(AuthError::BadRequest("cannot block yourself".to_string()));
}
let db = self.db();
let blocked_exists = user::Entity::find_by_id(blocked_uid).one(db.read()).await?;
if blocked_exists.is_none() {
return Err(AuthError::NotFound);
}
let existing = user_blocks::Entity::find()
.filter(user_blocks::Column::BlockerId.eq(blocker_uid))
.filter(user_blocks::Column::BlockedId.eq(blocked_uid))
.one(db.write())
.await?;
if existing.is_some() {
return Ok(());
}
let row = user_blocks::ActiveModel {
id: Set(Uuid::now_v7()),
blocker_id: Set(blocker_uid),
blocked_id: Set(blocked_uid),
created_at: Set(OffsetDateTime::now_utc()),
};
row.insert(db.write()).await?;
Ok(())
}
pub async fn unblock(&self, blocker_uid: Uuid, blocked_uid: Uuid) -> Result<(), AuthError> {
let db = self.db();
user_blocks::Entity::delete_many()
.filter(user_blocks::Column::BlockerId.eq(blocker_uid))
.filter(user_blocks::Column::BlockedId.eq(blocked_uid))
.exec(db.write())
.await?;
Ok(())
}
pub async fn blocked_users(&self, uid: Uuid) -> Result<Vec<UserPublic>, AuthError> {
let rows = user_blocks::Entity::find()
.filter(user_blocks::Column::BlockerId.eq(uid))
.all(self.db().read())
.await?;
let ids: Vec<Uuid> = rows.into_iter().map(|row| row.blocked_id).collect();
self.load_users_public(&ids).await
}
async fn load_users_public(&self, ids: &[Uuid]) -> Result<Vec<UserPublic>, AuthError> {
if ids.is_empty() {
return Ok(Vec::new());
}
let rows = user::Entity::find()
.filter(user::Column::Uid.is_in(ids.iter().copied()))
.all(self.db().read())
.await?;
Ok(rows
.into_iter()
.map(|user| UserPublic {
uid: user.uid,
username: user.username,
display_name: user.display_name,
avatar_url: user.avatar_url,
})
.collect())
}
}