validations updated

ApiEvents/AuthServiceApi/events/auth/auth.py

@@ -11,7 +11,7 @@ from ApiLibrary.common.line_number import get_line_number_for_error
 from ApiLibrary.date_time_actions.date_functions import DateTimeLocal
 from ApiServices.Login.user_login_handler import UserLoginModule
 from ApiServices.Token.token_handler import TokenService
-from ApiValidations.Custom.token_objects import CompanyToken
+from ApiValidations.Custom.token_objects import CompanyToken, OccupantToken
 from ApiValidations.Request.authentication import (
     Login,
     EmployeeSelectionValidation,
@@ -20,11 +20,16 @@ from ApiValidations.Request.authentication import (
     EmployeeSelection,
 )
 from ErrorHandlers import HTTPExceptionApi
+from Schemas.building.build import (
+    BuildLivingSpace,
+    BuildParts,
+    RelationshipEmployee2Build,
+)
 from Schemas.company.company import Companies
 from Schemas.company.department import Departments, Duties, Duty
 from Schemas.company.employee import Staff, Employees
-from Schemas.event.event import Event2Employee
-from Schemas.identity.identity import Users
+from Schemas.event.event import Event2Employee, Event2Occupant
+from Schemas.identity.identity import OccupantTypes, Users
 from Services.Redis.Actions.actions import RedisActions
 from .models import (
     LoginData,
@@ -170,9 +175,7 @@ class AuthenticationSelectEventMethods(MethodToEvent):
             )
 
         # Get reachable events
-        reachable_event_list_id = Event2Employee.get_event_id_by_employee_id(
-            employee_id=employee.id
-        )
+        reachable_event_codes = Event2Employee.get_event_codes(employee_id=employee.id)
 
         # Get staff and duties
         staff = Staff.filter_one(Staff.id == employee.staff_id, db=db_session).data
@@ -189,7 +192,6 @@ class AuthenticationSelectEventMethods(MethodToEvent):
             **Duties.valid_record_dict,
             db=db_session,
         ).data
-
         # Create company token
         company_token = CompanyToken(
             company_uu_id=selected_company.uu_id.__str__(),
@@ -203,7 +205,7 @@ class AuthenticationSelectEventMethods(MethodToEvent):
             staff_uu_id=staff.uu_id.__str__(),
             employee_id=employee.id,
             employee_uu_id=employee.uu_id.__str__(),
-            reachable_event_list_id=reachable_event_list_id,
+            reachable_event_codes=reachable_event_codes,
         )
         try:  # Update Redis
             update_token = TokenService.update_token_at_redis(
@@ -226,12 +228,81 @@ class AuthenticationSelectEventMethods(MethodToEvent):
         request: "Request",
     ):
         """Handle occupant type selection"""
-        raise HTTPExceptionApi(
-            error_code="HTTP_400_BAD_REQUEST",
-            lang=token_dict.lang,
-            loc=get_line_number_for_error(),
-            sys_msg="Occupant selection not implemented",
+        db = BuildLivingSpace.new_session()
+        # Get selected occupant type
+        selected_build_living_space = BuildLivingSpace.filter_one(
+            BuildLivingSpace.uu_id == data.build_living_space_uu_id,
+            db=db,
+        ).data
+        if not selected_build_living_space:
+            raise HTTPExceptionApi(
+                error_code="HTTP_400_BAD_REQUEST",
+                lang=token_dict.lang,
+                loc=get_line_number_for_error(),
+                sys_msg="Selected occupant type not found",
+            )
+
+        # Get reachable events
+        reachable_event_codes = Event2Occupant.get_event_codes(
+            build_living_space_id=selected_build_living_space.id
         )
+        occupant_type = OccupantTypes.filter_one(
+            OccupantTypes.id == selected_build_living_space.occupant_type_id,
+            db=db,
+            system=True,
+        ).data
+        build_part = BuildParts.filter_one(
+            BuildParts.id == selected_build_living_space.build_parts_id,
+            db=db,
+        ).data
+        build = BuildParts.filter_one(
+            BuildParts.id == build_part.build_id,
+            db=db,
+        ).data
+        responsible_employee = Employees.filter_one(
+            Employees.id == build_part.responsible_employee_id,
+            db=db,
+        ).data
+        related_company = RelationshipEmployee2Build.filter_one(
+            RelationshipEmployee2Build.member_id == build.id,
+            db=db,
+        ).data
+        # Get company
+        company_related = Companies.filter_one(
+            Companies.id == related_company.company_id,
+            db=db,
+        ).data
+
+        # Create occupant token
+        occupant_token = OccupantToken(
+            living_space_id=selected_build_living_space.id,
+            living_space_uu_id=selected_build_living_space.uu_id.__str__(),
+            occupant_type_id=occupant_type.id,
+            occupant_type_uu_id=occupant_type.uu_id.__str__(),
+            occupant_type=occupant_type.occupant_type,
+            build_id=build.id,
+            build_uuid=build.uu_id.__str__(),
+            build_part_id=build_part.id,
+            build_part_uuid=build_part.uu_id.__str__(),
+            responsible_employee_id=responsible_employee.id,
+            responsible_employee_uuid=responsible_employee.uu_id.__str__(),
+            responsible_company_id=company_related.id,
+            responsible_company_uuid=company_related.uu_id.__str__(),
+            reachable_event_codes=reachable_event_codes,
+        )
+
+        try:  # Update Redis
+            update_token = TokenService.update_token_at_redis(
+                request=request, add_payload=occupant_token
+            )
+            return update_token
+        except Exception as e:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg=f"{e}",
+            )
 
     @classmethod
     async def authentication_select_company_or_occupant_type(
@@ -246,14 +317,6 @@ class AuthenticationSelectEventMethods(MethodToEvent):
         elif token_dict.is_occupant:
             return cls._handle_occupant_selection(data, token_dict, request)
 
-        # except Exception as e:
-        #     raise HTTPExceptionApi(
-        #         error_code="HTTP_500_INTERNAL_SERVER_ERROR",
-        #         lang="en",
-        #         loc=get_line_number_for_error(),
-        #         sys_msg=str(e),
-        #     )
-
 
 class AuthenticationCheckTokenEventMethods(MethodToEvent):
     event_type = "LOGIN"

ApiEvents/AuthServiceApi/events/auth/endpoints.py

@@ -3,8 +3,8 @@ Authentication endpoint configurations.
 """
 
 from typing import TYPE_CHECKING, Dict, Any, Union, Annotated
-from fastapi import HTTPException, status, Body
 
+from ApiServices.Token.token_handler import TokenService
 from ApiValidations.Request import (
     Logout,
     Login,
@@ -49,7 +49,7 @@ from ApiEvents.abstract_class import (
 )
 
 if TYPE_CHECKING:
-    from fastapi import Request
+    from fastapi import Request, HTTPException, status, Body
 from ApiValidations.Custom.token_objects import EmployeeTokenObject, OccupantTokenObject
 
 
@@ -59,22 +59,18 @@ from ApiValidations.Custom.token_objects import EmployeeTokenObject, OccupantTok
 @endpoint_wrapper("/authentication/select")
 async def authentication_select_company_or_occupant_type(
     request: "Request",
-    data: EndpointBaseRequestModel,
+    data: Union[EmployeeSelection, OccupantSelection],
 ) -> Dict[str, Any]:
     """
     Select company or occupant type.
     """
     auth_dict = authentication_select_company_or_occupant_type.auth
-    if data.data.get("company_uu_id"):
-        data = EmployeeSelection(**data.data)
-    elif data.data.get("build_living_space_uu_id"):
-        data = OccupantSelection(**data.data)
     if await AuthenticationSelectEventMethods.authentication_select_company_or_occupant_type(
         request=request, data=data, token_dict=auth_dict
     ):
-        if isinstance(data, EmployeeSelection):
+        if data.is_employee:
             return {"selected_company": data.company_uu_id}
-        elif isinstance(data, OccupantSelection):
+        elif data.is_occupant:
             return {"selected_occupant": data.build_living_space_uu_id}
 
 
@@ -99,10 +95,18 @@ async def authentication_check_token_is_valid(
     """
     Check if a token is valid.
     """
-    return {
-        "headers": dict(request.headers),
-        "data": data.model_dump(),
-    }
+    try:
+        access_token = TokenService.get_access_token_from_request(request=request)
+        if TokenService.get_object_via_access_key(access_token=access_token):
+            return {
+                "status": True,
+                "message": "Access Token is valid",
+            }
+    except HTTPException:
+        return {
+            "status": False,
+            "message": "Access Token is NOT valid",
+        }
 
 
 @endpoint_wrapper("/authentication/refresh")

ApiEvents/AuthServiceApi/route_configs.py

@@ -6,15 +6,13 @@ to be used by the dynamic route creation system.
 """
 
 from typing import Dict, List, Any
-from .auth.endpoints import AUTH_CONFIG
+from .events.auth.endpoints import AUTH_CONFIG
 
 
 # Registry of all route configurations
-ROUTE_CONFIGS = [
-    AUTH_CONFIG,
-]
+ROUTE_CONFIGS = [AUTH_CONFIG]
 
 
 def get_route_configs() -> List[Dict[str, Any]]:
     """Get all registered route configurations."""
-    return [AUTH_CONFIG]
+    return ROUTE_CONFIGS