middleware and respnse models updated

ApiLayers/ApiServices/Cluster/create_router.py

@@ -20,14 +20,17 @@ class CreateEndpointFromCluster:
 
     def attach_router(self):
         method = getattr(self.router, self.method_endpoint.METHOD.lower())
-        
+
         # Create a unique operation ID based on the endpoint path, method, and a unique identifier
         kwargs = {
             "path": self.method_endpoint.URL,
             "summary": self.method_endpoint.SUMMARY,
             "description": self.method_endpoint.DESCRIPTION,
         }
-        if hasattr(self.method_endpoint, 'RESPONSE_MODEL') and self.method_endpoint.RESPONSE_MODEL is not None:
+        if (
+            hasattr(self.method_endpoint, "RESPONSE_MODEL")
+            and self.method_endpoint.RESPONSE_MODEL is not None
+        ):
             kwargs["response_model"] = self.method_endpoint.RESPONSE_MODEL
-        
+
         method(**kwargs)(self.method_endpoint.endpoint_callable)

ApiLayers/ApiServices/Cluster/handle_cluster.py

@@ -2,4 +2,3 @@ from Services.Redis import RedisActions, AccessToken
 from Services.Redis.Models.cluster import RedisList
 
 redis_list = RedisList(redis_key="test")
-

ApiLayers/ApiServices/Login/user_login_handler.py

@@ -1,9 +1,7 @@
-from typing import Any,  Dict
-
-from ApiLayers.ErrorHandlers import HTTPExceptionApi
 from ApiLayers.ApiValidations.Request.authentication import Login
 from ApiLayers.ApiLibrary.token.password_module import PasswordModule
 from ApiLayers.ApiLibrary.common.line_number import get_line_number_for_error
+from ApiLayers.ErrorHandlers import HTTPExceptionApi
 
 
 class UserLoginModule:
@@ -11,13 +9,27 @@ class UserLoginModule:
     def __init__(self, request: "Request"):
         self.request = request
         self.user = None
+        self.access_object = None
+        self.access_token = None
+        self.refresh_token = None
+
+    @property
+    def as_dict(self) -> dict:
+        return {
+            "user": self.user,
+            "access_object": self.access_object,
+            "access_token": self.access_token,
+            "refresh_token": self.refresh_token,
+        }
 
     @staticmethod
     def check_user_exists(access_key: str):
         from ApiLayers.Schemas import Users
 
-        """Check if user exists."""
-        db_session = Users.new_session()
+        """
+        Check if the user exists in the database.
+        """
+        db_session = Users.new_session()  # Check if user exists.
         if "@" in access_key:
             found_user: Users = Users.filter_one(
                 Users.email == access_key.lower(), db=db_session
@@ -31,39 +43,48 @@ class UserLoginModule:
                 error_code="HTTP_400_BAD_REQUEST",
                 lang="en",
                 loc=get_line_number_for_error(),
-                sys_msg="User not found",
+                sys_msg="check_user_exists: User not found",
             )
         return found_user
 
-    def login_user_via_credentials(self, access_data: "Login") -> Dict[str, Any]:
+    def login_user_via_credentials(self, access_data: "Login") -> None:
         from ApiLayers.ApiServices.Token.token_handler import TokenService
         from ApiLayers.Schemas import Users
 
+        """
+        Login the user via the credentials.
+        """
+
         # Get the actual data from the BaseRequestModel if needed
         found_user: Users = self.check_user_exists(access_key=access_data.access_key)
-        self.user = found_user
         if len(found_user.hash_password) < 5:
             raise HTTPExceptionApi(
                 error_code="HTTP_400_BAD_REQUEST",
                 lang=found_user.lang,
                 loc=get_line_number_for_error(),
-                sys_msg="Invalid password create a password to user first",
+                sys_msg="login_user_via_credentials: Invalid password create a password to user first",
             )
+        # Check if the password is correct
         if PasswordModule.check_password(
-            domain=access_data.domain,
-            id_=found_user.uu_id,
-            password=access_data.password,
-            password_hashed=found_user.hash_password,
+            domain=access_data.domain, id_=found_user.uu_id,
+            password=access_data.password, password_hashed=found_user.hash_password,
         ):
-            return TokenService.set_access_token_to_redis(
-                request=self.request,
-                user=found_user,
-                domain=access_data.domain,
-                remember=access_data.remember_me,
+            # Set the access token to the redis
+            token_response = TokenService.set_access_token_to_redis(
+                request=self.request, user=found_user, domain=access_data.domain, remember=access_data.remember_me,
             )
+            # Set the user and token information to the instance
+            self.user = found_user.get_dict()
+            self.access_token = token_response.get("access_token")
+            self.refresh_token = token_response.get("refresh_token")
+            self.access_object = {
+                "user_type": token_response.get("user_type", None),
+                "selection_list": token_response.get("selection_list", {})
+            }
+            return None
         raise HTTPExceptionApi(
             error_code="HTTP_400_BAD_REQUEST",
-            lang=found_user.lang,
+            lang="tr",
             loc=get_line_number_for_error(),
-            sys_msg="login_user_via_credentials raised error",
+            sys_msg="login_user_via_credentials: raised an unknown error",
         )

ApiLayers/ApiServices/Token/token_handler.py

@@ -250,7 +250,7 @@ class TokenService:
             return {
                 "access_token": access_token,
                 "user_type": UserType.employee.name,
-                "companies_list": companies_list,
+                "selection_list": companies_list,
             }
         raise HTTPExceptionApi(
             error_code="",
@@ -264,8 +264,8 @@ class TokenService:
         """Remove all tokens for a user with specific domain."""
         redis_rows = cls._get_user_tokens(user)
         for redis_row in redis_rows.all:
-            if redis_row.data.get("domain") == domain:
-                RedisActions.delete_key(redis_row.key)
+            if redis_row.row.get("domain") == domain:
+                redis_row.delete()
 
     @classmethod
     def remove_all_token(cls, user: Users) -> None: