updated

Author: indpurvesh

src/adapters/grpc_api/auth_user_api.rs

@@ -1,4 +1,4 @@
-use crate::application::use_cases::login_user::LoginUserUseCase;
+use crate::application::use_cases::login_user_use_case::LoginUserUseCase;
 use crate::infra::grpc::auth_user::{auth_server::Auth, LoginRequest, LoginResponse};
 use tonic::{Request, Response, Status};
 

src/adapters/grpc_api/misc_api.rs

@@ -1,40 +1,54 @@
 #[cfg(feature = "ssr")]
 use tonic::{Request, Response, Status};
 
-use crate::infra::grpc::misc::{HealthCheckRequest, HealthCheckResponse, SetupRequest, SetupResponse, misc_server::Misc};
-
+use crate::{
+    application::use_cases::misc_use_case::MiscUseCase,
+    infra::grpc::misc::{
+        misc_server::Misc, HealthCheckRequest, HealthCheckResponse, SetupRequest, SetupResponse,
+    },
+};
 
 
+#[derive(Clone)]
+pub struct MiscGrpcApi {
+    pub misc_use_case: MiscUseCase,
+}
 
-#[derive(Debug, Default)]
-pub struct MyMisc {
-    
+impl MiscGrpcApi {
+    pub fn new(misc_use_case: MiscUseCase) -> Self {
+        Self {
+            misc_use_case,
+        }
+    }
 }
 
+
+
 #[tonic::async_trait]
-impl Misc for MyMisc {
+impl Misc for MiscGrpcApi {
     async fn health_check(
         &self,
         request: Request<HealthCheckRequest>,
     ) -> Result<Response<HealthCheckResponse>, Status> {
         println!("Got a request: {:?}", request);
 
-        let request = HealthCheckResponse {
-            status: true,
-        };
+        let request = HealthCheckResponse { status: true };
 
         Ok(Response::new(request))
     }
 
-    async fn setup (
+    async fn setup(
         &self,
         request: Request<SetupRequest>,
     ) -> Result<Response<SetupResponse>, Status> {
         println!("Got a setup request: {:?}", request);
 
-        let request = SetupResponse {
-            status: true,
+        // Think of implementing a generic result handler
+        let setup_result = match  self.misc_use_case.setup().await {
+            Ok(result) => result,
+            Err(e) => return Err(Status::internal(e.to_string())),
         };
+        let request = SetupResponse { status: setup_result };
 
         Ok(Response::new(request))
     }

src/application/use_cases/login_user.rs …ication/use_cases/login_user_use_case.rssrc/application/use_cases/login_user.rs renamed to src/application/use_cases/login_user_use_case.rs src/application/use_cases/login_user.rs renamed to src/application/use_cases/login_user_use_case.rs

@@ -0,0 +1,18 @@
+use std::sync::Arc;
+use crate::error::Result;
+use crate::infra::repositories::misc_repository::MiscRepository;
+
+#[derive(Clone)]
+pub struct MiscUseCase {
+    pub misc_repository: Arc<dyn MiscRepository>,
+}
+
+impl MiscUseCase {
+    pub fn new(misc_repository: Arc<dyn MiscRepository>) -> Self {
+        Self { misc_repository }
+    }
+
+    pub async fn setup(&self) -> Result<bool> {
+        self.misc_repository.setup().await
+    }
+}

src/application/use_cases/misc_use_case.rs

@@ -1 +1,2 @@
-pub mod login_user;
+pub mod login_user_use_case;
+pub mod misc_use_case;

src/application/use_cases/mod.rs

@@ -27,13 +27,16 @@ pub async fn create_app(state: AppState) -> crate::error::Result<Router> {
     let my_hello_service =
         crate::infra::grpc::helloworld::greeter_server::GreeterServer::new(my_hello_server);
 
-    let my_misc_server = crate::adapters::grpc_api::misc_api::MyMisc::default();
-    let my_misc_service = crate::infra::grpc::misc::misc_server::MiscServer::new(my_misc_server);
-
+        
     let db = init_database().await?;
     let surreal_repository = Arc::new(SurrealUserRepository::new(db));
+    
+    
+    let misc_use_case =
+        crate::application::use_cases::misc_use_case::MiscUseCase::new(surreal_repository.clone());
 
-
+    let misc_grpc_api = crate::adapters::grpc_api::misc_api::MiscGrpcApi::new(misc_use_case);
+    let misc_service = crate::infra::grpc::misc::misc_server::MiscServer::new(misc_grpc_api);
 
     // pub fn new(file_repository: Arc<dyn FileRepository>) -> Self {
     //     Self { file_repository }
@@ -52,7 +55,7 @@ pub async fn create_app(state: AppState) -> crate::error::Result<Router> {
     // );
 
     let login_user_use_case =
-        crate::application::use_cases::login_user::LoginUserUseCase::new(surreal_repository.clone());
+        crate::application::use_cases::login_user_use_case::LoginUserUseCase::new(surreal_repository.clone());
 
     let auth_user_server =
         crate::adapters::grpc_api::auth_user_api::AuthUserGrpcApi::new(login_user_use_case);
@@ -62,8 +65,8 @@ pub async fn create_app(state: AppState) -> crate::error::Result<Router> {
 
     let router = Router::<AppState>::new()
         .route_service("/helloworld.Greeter/SayHello", my_hello_service)
-        .route_service("/misc.Misc/HealthCheck", my_misc_service.clone())
-        .route_service("/misc.Misc/Setup", my_misc_service)
+        .route_service("/misc.Misc/HealthCheck", misc_service.clone())
+        .route_service("/misc.Misc/Setup", misc_service)
         .route_service("/auth_user.Auth/LoginUser", auth_user_service)
         .leptos_routes_with_context(
             &state,

src/infra/app.rs

@@ -4,15 +4,15 @@ use async_trait::async_trait;
 
 #[async_trait]
 pub trait MiscRepository: Send + Sync {
-    async fn setup(&self) -> Result<()>;
+    async fn setup(&self) -> Result<bool>;
 }
 
 
 #[async_trait]
 impl MiscRepository for SurrealUserRepository  {
-    async fn setup(&self) -> Result<()> 
+    async fn setup(&self) -> Result<bool> 
     {    
         println!("Setting up database");   
-        Ok(())
+        Ok(false)
     }
 }