1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

pub mod user_interface {
    use utils::infrastructure::controller::responses::{ErrHttpResponse, ErrorStatus, OkHttpResponse, OkStatus};
    use crate::dtos::user_dto::UserDto;
    use crate::use_case::user_use_case_implementation::UserUseCasesInteractor;
    use crate::use_case::user_use_cases::UserUseCases;
    use crate::repository::user_repository::UserRepositoryConcrete;
    use crate::errors::errors::UsersError;
    
    struct UserInterface {
        use_case: UserUseCasesInteractor<UserRepositoryConcrete>
    }

    impl UserInterface {
        /// create interface
        pub async fn new() -> Self {
            
            let repository = UserRepositoryConcrete::default().await;
            let use_case = UserUseCasesInteractor::new(repository);
            
            Self {
                use_case
            }
        }
        
        async fn add_partner(&self, user_id: &str, partner_id: &str) -> Result<OkHttpResponse<UserDto>, ErrHttpResponse>{

            let result = self.use_case.add_partner(user_id, partner_id).await;
            
            let user= match result {
                Ok(u) => u,
                Err(UsersError::UserNotFind(e)) => {
                    return Err(ErrHttpResponse::new(ErrorStatus::BadRequest, Some(&e)))
                },
                _ => return Err(ErrHttpResponse::new(ErrorStatus::InternalServerError, Some("unexpected error")))
            };
            
            Ok(OkHttpResponse::new(OkStatus::Accepted, user))
        }

        async fn remove_partner(&self, user_id: &str, partner_id: &str) -> Result<OkHttpResponse<UserDto>, ErrHttpResponse>{

            let result = self.use_case.remove_partner(user_id, partner_id).await;

            let user= match result {
                Ok(u) => u,
                Err(UsersError::UserNotFind(e)) => {
                    return Err(ErrHttpResponse::new(ErrorStatus::BadRequest, Some(&e)))
                },
                _ => return Err(ErrHttpResponse::new(ErrorStatus::InternalServerError, Some("unexpected error")))
            };

            Ok(OkHttpResponse::new(OkStatus::Accepted, user))
        }
        
        async fn change_name(&self, user_id: &str, name: &str) -> Result<OkHttpResponse<UserDto>, ErrHttpResponse>{

            let result = self.use_case.change_name(user_id, name).await;

            let user= match result {
                Ok(u) => u,
                Err(UsersError::UserNotFind(e)) => {
                    return Err(ErrHttpResponse::new(ErrorStatus::BadRequest, Some(&e)))
                },
                _ => return Err(ErrHttpResponse::new(ErrorStatus::InternalServerError, Some("unexpected error")))
            };

            Ok(OkHttpResponse::new(OkStatus::Accepted, user))
        }
    }
}