1use async_trait::async_trait;
2
3use crate::dto::{
4    GetCurrentUserRequest, GetUserRequest, HasUserRequest, ListUserRepositoriesRequest,
5    RepositoryResponse, UserResponse,
6};
7use crate::error::UserError;
8use crate::repository::{
9    RepositoryRepository, RepositoryRepositoryImpl, UserRepository, UserRepositoryImpl,
10};
11use crate::util::auth::is_reserved_name;
12
13#[async_trait]
14pub trait UserService: Send + Sync + 'static {
15    async fn has_user(&self, request: HasUserRequest) -> Result<(), UserError>;
16
17    async fn get_current_user(
18        &self,
19        request: GetCurrentUserRequest,
20    ) -> Result<UserResponse, UserError>;
21
22    async fn get_user(&self, request: GetUserRequest) -> Result<UserResponse, UserError>;
23
24    async fn list_repositories(
25        &self,
26        request: ListUserRepositoriesRequest,
27    ) -> Result<Vec<RepositoryResponse>, UserError>;
28}
29
30#[derive(Debug, Clone)]
31pub struct UserServiceImpl<U, R>
32where
33    U: UserRepository,
34    R: RepositoryRepository,
35{
36    user_repo: U,
37    repo_repo: R,
38}
39
40impl UserServiceImpl<UserRepositoryImpl, RepositoryRepositoryImpl> {
41    pub fn new(user_repo: UserRepositoryImpl, repo_repo: RepositoryRepositoryImpl) -> Self {
42        Self {
43            user_repo,
44            repo_repo,
45        }
46    }
47}
48
49#[async_trait]
50impl<U, R> UserService for UserServiceImpl<U, R>
51where
52    U: UserRepository,
53    R: RepositoryRepository,
54{
55    async fn has_user(&self, request: HasUserRequest) -> Result<(), UserError> {
56        let name = request.name.to_string();
57
58        if is_reserved_name(&name) || self.user_repo.is_name_taken(&name).await? {
59            return Ok(());
60        }
61        Err(UserError::NotFound(name))
62    }
63
64    async fn get_current_user(
65        &self,
66        request: GetCurrentUserRequest,
67    ) -> Result<UserResponse, UserError> {
68        let user = self
69            .user_repo
70            .get_by_id(request.user_id)
71            .await?
72            .ok_or_else(|| UserError::NotFound(request.user_id.to_string()))?;
73        Ok(user.into())
74    }
75
76    async fn get_user(&self, request: GetUserRequest) -> Result<UserResponse, UserError> {
77        let user_name = request.user_name.to_string();
78        let user = self
79            .user_repo
80            .get(&user_name)
81            .await?
82            .ok_or_else(|| UserError::NotFound(user_name))?;
83        Ok(user.into())
84    }
85
86    async fn list_repositories(
87        &self,
88        request: ListUserRepositoriesRequest,
89    ) -> Result<Vec<RepositoryResponse>, UserError> {
90        let user_name = request.user_name.to_string();
91        let user = self
92            .user_repo
93            .get(&user_name)
94            .await?
95            .ok_or_else(|| UserError::NotFound(user_name.clone()))?;
96
97        let repositories = self.repo_repo.list_by_owner(&user_name).await?;
98
99        let is_owner = request.viewer_id.map(|id| id == user.id).unwrap_or(false);
100        let repositories = if is_owner {
101            repositories
102        } else {
103            repositories.into_iter().filter(|r| r.is_public()).collect()
104        };
105
106        Ok(repositories.into_iter().map(|r| r.into()).collect())
107    }
108}
109