refactor: Rename use case classes and update references for consistency

Author: ViniciusBerti

src/modules/create_user/app/create_user_controller.py

@@ -1,5 +1,5 @@
 from src.shared.helpers.external_interfaces.external_interface import IResponse, IRequest
-from .create_user_usecase import CreateUserUsecase
+from .create_user_usecase import CreateUserUseCase
 from .create_user_viewmodel import CreateUserViewmodel
 from src.shared.helpers.errors.controller_errors import MissingParameters, WrongTypeParameter
 from src.shared.helpers.errors.domain_errors import EntityError
@@ -9,8 +9,8 @@
 
 class CreateUserController:
 
-    def __init__(self, usecase: CreateUserUsecase):
-        self.CreateUserUsecase = usecase
+    def __init__(self, usecase: CreateUserUseCase):
+        self.CreateUserUseCase = usecase
 
     def __call__(self, request: IRequest) -> IResponse:
         try:
@@ -19,7 +19,7 @@ def __call__(self, request: IRequest) -> IResponse:
             if request.data.get('email') is None:
                 raise MissingParameters('email')
 
-            user = self.CreateUserUsecase(
+            user = self.CreateUserUseCase(
                 name=request.data.get('name'),
                 email=request.data.get('email')
             )

src/modules/create_user/app/create_user_presenter.py

@@ -1,10 +1,10 @@
 from .create_user_controller import CreateUserController
-from .create_user_usecase import CreateUserUsecase
+from .create_user_usecase import CreateUserUseCase
 from src.shared.environments import Environments
 from src.shared.helpers.external_interfaces.http_lambda_requests import LambdaHttpRequest, LambdaHttpResponse
 
 repo = Environments.get_user_repo()()
-usecase = CreateUserUsecase(repo)
+usecase = CreateUserUseCase(repo)
 controller = CreateUserController(usecase)
 
 def lambda_handler(event, context):

src/modules/create_user/app/create_user_usecase.py

@@ -6,7 +6,7 @@
 from src.shared.helpers.errors.domain_errors import EntityError
 
 
-class CreateUserUsecase:
+class CreateUserUseCase:
     def __init__(self, repo: IUserRepository):
         self.repo = repo
 

src/modules/get_subscription/app/get_subscription_controller.py

@@ -1,5 +1,5 @@
 from typing import List
-from .get_user_subscriptions_usecase import GetUserSubscriptionsUsecase
+from .get_subscription_usecase import GetUserSubscriptionsUseCase
 from src.shared.helpers.errors.controller_errors import MissingParameters, WrongTypeParameter
 from src.shared.helpers.errors.domain_errors import EntityError
 from src.shared.helpers.errors.usecase_errors import NoItemsFound
@@ -8,27 +8,35 @@
 
 class GetUserSubscriptionsController:
 
-    def __init__(self, usecase: GetUserSubscriptionsUsecase, observability=None):
-        self.usecase = usecase
+    def __init__(self, usecase: GetUserSubscriptionsUseCase):
+        self.get_subscription_usecase = usecase
 
     def __call__(self, request: IRequest) -> IResponse:
         try:
             user_id = request.data.get("user_id")
             if user_id is None:
                 raise MissingParameters("user_id")
             if not isinstance(user_id, str):
-                raise WrongTypeParameter("user_id", "str", type(user_id).__name__)
+                raise WrongTypeParameter(
+                    fieldName="user_id",
+                    fieldTypeExpected="str",
+                    fieldTypeReceived=type(user_id).__name__,
+                )
             if not user_id.strip():
                 raise EntityError("user_id")
 
-            subscriptions = self.usecase(user_id=user_id)  
-            result = [s.to_dict() for s in subscriptions]
+            subscriptions = self.get_subscription_usecase(user_id=user_id)
+            result = [subscription.to_dict() for subscription in subscriptions]
 
             return OK(result)
 
         except NoItemsFound as err:
             return NotFound(body=err.message)
-        except (MissingParameters, WrongTypeParameter, EntityError) as err:
+        except MissingParameters as err:
+            return BadRequest(body=err.message)
+        except WrongTypeParameter as err:
+            return BadRequest(body=err.message)
+        except EntityError as err:
             return BadRequest(body=err.message)
         except Exception as err:
             return InternalServerError(body=str(err))

src/modules/get_subscription/app/get_subscription_presenter.py

@@ -1,10 +1,10 @@
 from .get_subscription_controller import GetSubscriptionController
-from .get_subscription_usecase import GetSubscriptionUsecase
+from .get_subscription_usecase import GetSubscriptionUseCase
 from src.shared.environments import Environments
 from src.shared.helpers.external_interfaces.http_lambda_requests import LambdaHttpRequest, LambdaHttpResponse
 
 repo = Environments.get_subscription_repo()()
-usecase = GetSubscriptionUsecase(repo=repo)
+usecase = GetSubscriptionUseCase(repo=repo)
 controller = GetSubscriptionController(usecase=usecase)
 
 def lambda_handler(event, context):

src/modules/get_subscription/app/get_subscription_usecase.py

@@ -4,7 +4,7 @@
 from src.shared.helpers.errors.domain_errors import EntityError
 from src.shared.helpers.errors.usecase_errors import NoItemsFound
 
-class GetUserSubscriptionsUsecase:
+class GetUserSubscriptionsUseCase:
     def __init__(self, repo: ISubscriptionRepository, observability=None):
         self.repo = repo
 
@@ -14,5 +14,5 @@ def __call__(self, user_id: str) -> List[Subscription]:
 
         subs = self.repo.get_all_by_user(user_id)
         if not subs:
-            raise NoItemsFound(f"No subscriptions found for user {user_id}")
+            raise NoItemsFound(f"Nenhuma assinatura encontrada para o usuário {user_id}")
         return subs

src/modules/get_transactions_by_user/app/get_transactions_by_user_controller.py

@@ -1,4 +1,4 @@
-from .get_transactions_by_user_usecase import GetTransactionsByUserUsecase
+from .get_transactions_by_user_usecase import GetTransactionsByUserUseCase
 from src.shared.helpers.errors.controller_errors import MissingParameters, WrongTypeParameter
 from src.shared.helpers.errors.domain_errors import EntityError
 from src.shared.helpers.errors.usecase_errors import NoItemsFound
@@ -7,7 +7,7 @@
 
 class GetTransactionsByUserController:
 
-    def __init__(self, usecase: GetTransactionsByUserUsecase, observability=None):
+    def __init__(self, usecase: GetTransactionsByUserUseCase):
         self.usecase = usecase
 
     def __call__(self, request: IRequest) -> IResponse:
@@ -25,24 +25,26 @@ def __call__(self, request: IRequest) -> IResponse:
                 raise EntityError("user_id")
 
             transactions = self.usecase(user_id=user_id)
-
-            result = []
-            for t in transactions:
-                result.append({
+            result = [
+                {
                     "id": t.id,
                     "user_id": t.user_id,
                     "plan": t.plan.name,
                     "value": t.value,
                     "create_date": t.create_date
-                })
+                }
+                for t in transactions
+            ]
 
             return OK(result)
 
         except NoItemsFound as err:
             return NotFound(body=err.message)
-
-        except (MissingParameters, WrongTypeParameter, EntityError) as err:
+        except MissingParameters as err:
+            return BadRequest(body=err.message)
+        except WrongTypeParameter as err:
+            return BadRequest(body=err.message)
+        except EntityError as err:
             return BadRequest(body=err.message)
-
         except Exception as err:
-            return InternalServerError(body=str(err))
+            return InternalServerError(body=str(err))

src/modules/get_transactions_by_user/app/get_transactions_by_user_presenter.py

@@ -1,10 +1,10 @@
 from .get_transactions_by_user_controller import GetTransactionsByUserController
-from .get_transactions_by_user_usecase import GetTransactionsByUserUsecase
+from .get_transactions_by_user_usecase import GetTransactionsByUserUseCase
 from src.shared.environments import Environments
 from src.shared.helpers.external_interfaces.http_lambda_requests import LambdaHttpRequest, LambdaHttpResponse
 
 repo = Environments.get_transaction_repo()()
-usecase = GetTransactionsByUserUsecase(repo=repo)
+usecase = GetTransactionsByUserUseCase(repo=repo)
 controller = GetTransactionsByUserController(usecase=usecase)
 
 def lambda_handler(event, context):

src/modules/get_transactions_by_user/app/get_transactions_by_user_usecase.py

@@ -5,7 +5,7 @@
 from src.shared.helpers.errors.domain_errors import EntityError
 from src.shared.helpers.errors.usecase_errors import NoItemsFound
 
-class GetTransactionsByUserUsecase:
+class GetTransactionsByUserUseCase:
     def __init__(self, repo: ITransactionRepository, observability=None):
         self.repo = repo
 

src/modules/update_subscription/app/update_subscription_usecase.py

@@ -1,22 +1,22 @@
-from uuid import UUID
+from typing import List
 from src.shared.domain.entities.subscription import Subscription
 from src.shared.domain.enums.plan_enum import PLAN
 from src.shared.domain.repositories.subscription_repository_interface import ISubscriptionRepository
 from src.shared.helpers.errors.domain_errors import EntityError
 
-class UpdateSubscriptionUsecase:
+class UpdateSubscriptionUseCase:
     def __init__(self, repo: ISubscriptionRepository):
         self.repo = repo
 
-    def __call__(self, subscription_id: str, new_plan: PLAN) -> Subscription:
-        if not Subscription.validate_id(subscription_id):
-            raise EntityError("subscription_id")
+    def __call__(self, user_id: str, new_plan: PLAN) -> Subscription:
+        if not isinstance(user_id, str) or not user_id.strip():
+            raise EntityError("user_id")
 
         if not isinstance(new_plan, PLAN):
             raise EntityError("new_plan")
 
         updated_subscription = self.repo.update_subscription(
-            subscription_id=subscription_id,
+            subscription_id=user_id,
             new_plan=new_plan
         )
         return updated_subscription