1use async_trait::async_trait;
2
3use crate::dto::{
4    AddMemberRequest, CreateOrganizationRequest, GetOrganizationRequest,
5    ListOrganizationRepositoriesRequest, OrganizationMemberResponse, OrganizationResponse,
6    RepositoryResponse,
7};
8use crate::error::OrganizationError;
9use crate::repository::{
10    OrganizationRepository, OrganizationRepositoryImpl, RepositoryRepository,
11    RepositoryRepositoryImpl, UserRepository, UserRepositoryImpl,
12};
13
14#[async_trait]
15pub trait OrganizationService: Send + Sync + 'static {
16    async fn create_organization(
17        &self,
18        request: CreateOrganizationRequest,
19    ) -> Result<OrganizationResponse, OrganizationError>;
20
21    async fn get_organization(
22        &self,
23        request: GetOrganizationRequest,
24    ) -> Result<OrganizationResponse, OrganizationError>;
25
26    async fn add_member(
27        &self,
28        request: AddMemberRequest,
29    ) -> Result<OrganizationMemberResponse, OrganizationError>;
30
31    async fn list_repositories(
32        &self,
33        request: ListOrganizationRepositoriesRequest,
34    ) -> Result<Vec<RepositoryResponse>, OrganizationError>;
35}
36
37#[derive(Debug, Clone)]
38pub struct OrganizationServiceImpl<O, U, R>
39where
40    O: OrganizationRepository,
41    U: UserRepository,
42    R: RepositoryRepository,
43{
44    org_repo: O,
45    user_repo: U,
46    repo_repo: R,
47}
48
49impl
50    OrganizationServiceImpl<
51        OrganizationRepositoryImpl,
52        UserRepositoryImpl,
53        RepositoryRepositoryImpl,
54    >
55{
56    pub fn new(
57        org_repo: OrganizationRepositoryImpl,
58        user_repo: UserRepositoryImpl,
59        repo_repo: RepositoryRepositoryImpl,
60    ) -> Self {
61        Self {
62            org_repo,
63            user_repo,
64            repo_repo,
65        }
66    }
67}
68
69#[async_trait]
70impl<O, U, R> OrganizationService for OrganizationServiceImpl<O, U, R>
71where
72    O: OrganizationRepository,
73    U: UserRepository,
74    R: RepositoryRepository,
75{
76    async fn create_organization(
77        &self,
78        request: CreateOrganizationRequest,
79    ) -> Result<OrganizationResponse, OrganizationError> {
80        let org_name = request.org_name.to_string();
81        if self.org_repo.get(&org_name).await?.is_some() {
82            return Err(OrganizationError::Duplicate(org_name));
83        }
84        if self.user_repo.get(&org_name).await?.is_some() {
85            return Err(OrganizationError::Duplicate(org_name));
86        }
87
88        let org = self.org_repo.create(&org_name, request.owner_id).await?;
89        Ok(org.into())
90    }
91
92    async fn get_organization(
93        &self,
94        request: GetOrganizationRequest,
95    ) -> Result<OrganizationResponse, OrganizationError> {
96        let org_name = request.org_name.to_string();
97        let org = self
98            .org_repo
99            .get(&org_name)
100            .await?
101            .ok_or_else(|| OrganizationError::NotFound(org_name))?;
102        Ok(org.into())
103    }
104
105    async fn add_member(
106        &self,
107        request: AddMemberRequest,
108    ) -> Result<OrganizationMemberResponse, OrganizationError> {
109        let org_name = request.org_name.to_string();
110        let user_name = request.user_name.to_string();
111
112        let member = self
113            .org_repo
114            .add_member(&org_name, &user_name, request.role)
115            .await?;
116
117        match member {
118            Some(m) => Ok(m.into()),
119            None => {
120                if self.org_repo.get(&org_name).await?.is_none() {
121                    return Err(OrganizationError::NotFound(org_name));
122                }
123                if self.user_repo.get(&user_name).await?.is_none() {
124                    return Err(OrganizationError::UserNotFound(user_name));
125                }
126                Err(OrganizationError::MemberAlreadyExists(user_name))
127            }
128        }
129    }
130
131    async fn list_repositories(
132        &self,
133        request: ListOrganizationRepositoriesRequest,
134    ) -> Result<Vec<RepositoryResponse>, OrganizationError> {
135        let org_name = request.org_name.to_string();
136        let org = self
137            .org_repo
138            .get(&org_name)
139            .await?
140            .ok_or_else(|| OrganizationError::NotFound(org_name.clone()))?;
141
142        let repositories = self.repo_repo.list_by_owner(&org_name).await?;
143
144        let is_member = match request.viewer_id {
145            Some(viewer_id) => self.org_repo.is_member(org.id, viewer_id).await?,
146            None => false,
147        };
148        let repositories = if is_member {
149            repositories
150        } else {
151            repositories.into_iter().filter(|r| r.is_public()).collect()
152        };
153
154        Ok(repositories.into_iter().map(|r| r.into()).collect())
155    }
156}
157