new api service and logic implemented

Events/AllEvents/authentication/__init__.py

@@ -0,0 +1,9 @@
+"""
+Authentication package initialization.
+"""
+
+from .auth import AUTH_CONFIG
+
+__all__ = [
+    "AUTH_CONFIG",
+]

Events/AllEvents/authentication/auth/api_events.py

@@ -0,0 +1,154 @@
+from uuid import UUID
+from Events.Engine.abstract_class import Event
+
+from .models import (
+    LoginSuperUserRequestModel,
+    LoginSuperUserResponseModel,
+    SelectCompanyOrOccupantTypeSuperUserRequestModel,
+    SelectCompanyOrOccupantTypeSuperUserResponseModel,
+    EmployeeSelectionSuperUserRequestModel,
+    EmployeeSelectionSuperUserResponseModel,
+    OccupantSelectionSuperUserRequestModel,
+    OccupantSelectionSuperUserResponseModel,
+)
+from .function_handlers import (
+    authentication_login_with_domain_and_creds,
+    authentication_select_company_or_occupant_type,
+    handle_employee_selection,
+    handle_occupant_selection,
+    authentication_check_token_is_valid,
+    authentication_refresh_user_info,
+    authentication_change_password,
+    authentication_create_password,
+    authentication_disconnect_user,
+    authentication_logout_user,
+    authentication_refresher_token,
+    authentication_forgot_password,
+    authentication_reset_password,
+    authentication_download_avatar,
+)
+
+
+# Auth Login
+authentication_login_super_user_event = Event(
+    key=UUID("a5d2d0d1-3e9b-4b0f-8c7d-6d4a4b4c4d4e"),
+    request_validator=LoginSuperUserRequestModel,
+    response_validator=LoginSuperUserResponseModel,
+    description="Login super user",
+)
+authentication_login_super_user_event.endpoint_callable = authentication_login_with_domain_and_creds
+
+# Auth Select Company or Occupant Type
+authentication_select_company_or_occupant_type_super_user_event = Event(
+    key=UUID("a5d2d0d1-3e9b-4b0f-8c7d-6d4a4b4c4d4e"),
+    request_validator=SelectCompanyOrOccupantTypeSuperUserRequestModel,
+    response_validator=SelectCompanyOrOccupantTypeSuperUserResponseModel,
+    description="Select company or occupant type super user",
+)
+authentication_select_company_or_occupant_type_super_user_event.endpoint_callable = authentication_select_company_or_occupant_type
+
+authentication_employee_selection_super_user_event = Event(
+    key=UUID("a5d2d0d1-3e9b-4b0f-8c7d-6d4a4b4c4d4e"),
+    request_validator=EmployeeSelectionSuperUserRequestModel,
+    response_validator=EmployeeSelectionSuperUserResponseModel,
+    description="Employee selection super user",
+)
+authentication_employee_selection_super_user_event.endpoint_callable = handle_employee_selection
+
+authentication_occupant_selection_super_user_event = Event(
+    key=UUID("a5d2d0d1-3e9b-4b0f-8c7d-6d4a4b4c4d4e"),
+    request_validator=OccupantSelectionSuperUserRequestModel,
+    response_validator=OccupantSelectionSuperUserResponseModel,
+    description="Occupant selection super user",
+)
+authentication_occupant_selection_super_user_event.endpoint_callable = handle_occupant_selection
+
+# Check Token Validity
+authentication_check_token_event = Event(
+    key=UUID("b6e3d1e2-4f9c-5c1g-9d8e-7e5f6f5e5d5f"),
+    request_validator=None,  # TODO: Add request validator
+    response_validator=None,  # TODO: Add response validator
+    description="Check if token is valid",
+)
+authentication_check_token_event.endpoint_callable = authentication_check_token_is_valid
+
+# Refresh User Info
+authentication_refresh_user_info_event = Event(
+    key=UUID("c7f4e2f3-5g0d-6d2h-0e9f-8f6g7g6f6e6g"),
+    request_validator=None,  # TODO: Add request validator
+    response_validator=None,  # TODO: Add response validator
+    description="Refresh user information",
+)
+authentication_refresh_user_info_event.endpoint_callable = authentication_refresh_user_info
+
+# Change Password
+authentication_change_password_event = Event(
+    key=UUID("d8g5f3g4-6h1e-7e3i-1f0g-9g7h8h7g7f7h"),
+    request_validator=None,  # TODO: Add request validator
+    response_validator=None,  # TODO: Add response validator
+    description="Change user password",
+)
+authentication_change_password_event.endpoint_callable = authentication_change_password
+
+# Create Password
+authentication_create_password_event = Event(
+    key=UUID("e9h6g4h5-7i2f-8f4j-2g1h-0h8i9i8h8g8i"),
+    request_validator=None,  # TODO: Add request validator
+    response_validator=None,  # TODO: Add response validator
+    description="Create new password",
+)
+authentication_create_password_event.endpoint_callable = authentication_create_password
+
+# Disconnect User
+authentication_disconnect_user_event = Event(
+    key=UUID("f0i7h5i6-8j3g-9g5k-3h2i-1i9j0j9i9h9j"),
+    request_validator=None,  # TODO: Add request validator
+    response_validator=None,  # TODO: Add response validator
+    description="Disconnect all user sessions",
+)
+authentication_disconnect_user_event.endpoint_callable = authentication_disconnect_user
+
+# Logout User
+authentication_logout_user_event = Event(
+    key=UUID("g1j8i6j7-9k4h-0h6l-4i3j-2j0k1k0j0i0k"),
+    request_validator=None,  # TODO: Add request validator
+    response_validator=None,  # TODO: Add response validator
+    description="Logout user session",
+)
+authentication_logout_user_event.endpoint_callable = authentication_logout_user
+
+# Refresh Token
+authentication_refresher_token_event = Event(
+    key=UUID("h2k9j7k8-0l5i-1i7m-5j4k-3k1l2l1k1j1l"),
+    request_validator=None,  # TODO: Add request validator
+    response_validator=None,  # TODO: Add response validator
+    description="Refresh authentication token",
+)
+authentication_refresher_token_event.endpoint_callable = authentication_refresher_token
+
+# Forgot Password
+authentication_forgot_password_event = Event(
+    key=UUID("i3l0k8l9-1m6j-2j8n-6k5l-4l2m3m2l2k2m"),
+    request_validator=None,  # TODO: Add request validator
+    response_validator=None,  # TODO: Add response validator
+    description="Request password reset",
+)
+authentication_forgot_password_event.endpoint_callable = authentication_forgot_password
+
+# Reset Password
+authentication_reset_password_event = Event(
+    key=UUID("j4m1l9m0-2n7k-3k9o-7l6m-5m3n4n3m3l3n"),
+    request_validator=None,  # TODO: Add request validator
+    response_validator=None,  # TODO: Add response validator
+    description="Reset user password",
+)
+authentication_reset_password_event.endpoint_callable = authentication_reset_password
+
+# Download Avatar
+authentication_download_avatar_event = Event(
+    key=UUID("k5n2m0n1-3o8l-4l0p-8m7n-6n4o5o4n4m4o"),
+    request_validator=None,  # TODO: Add request validator
+    response_validator=None,  # TODO: Add response validator
+    description="Download user avatar and profile info",
+)
+authentication_download_avatar_event.endpoint_callable = authentication_download_avatar

Events/AllEvents/authentication/auth/auth.py

@@ -0,0 +1,168 @@
+"""
+Authentication related API endpoints.
+"""
+
+from typing import Union
+
+from Events.Engine.abstract_class import MethodToEvent
+from Events.base_request_model import SuccessResponse
+
+from ApiLayers.ApiLibrary.common.line_number import get_line_number_for_error
+from ApiLayers.ApiServices.Token.token_handler import OccupantTokenObject, EmployeeTokenObject
+
+from .api_events import (
+    authentication_login_super_user_event,
+    authentication_select_company_or_occupant_type_super_user_event,
+    authentication_employee_selection_super_user_event,
+    authentication_occupant_selection_super_user_event,
+    authentication_check_token_event,
+    authentication_refresh_user_info_event,
+    authentication_change_password_event,
+    authentication_create_password_event,
+    authentication_disconnect_user_event,
+    authentication_logout_user_event,
+    authentication_refresher_token_event,
+    authentication_forgot_password_event,
+    authentication_reset_password_event,
+    authentication_download_avatar_event,
+)
+
+
+# Type aliases for common types
+TokenDictType = Union["EmployeeTokenObject", "OccupantTokenObject"]
+
+
+AuthenticationLoginEventMethods = MethodToEvent(
+    events=[authentication_login_super_user_event],
+    headers=[],
+    errors=[],
+    url="/authentication/login",
+    method="POST",
+    summary="Login via domain and access key : [email] | [phone]",
+    description="Login to the system via domain, access key : [email] | [phone]",
+)
+
+
+AuthenticationSelectEventMethods = MethodToEvent(
+    events=[
+        authentication_select_company_or_occupant_type_super_user_event,
+        authentication_employee_selection_super_user_event,
+        authentication_occupant_selection_super_user_event
+    ],
+    headers=[],
+    errors=[],
+    url="/authentication/select",
+    method="POST",
+    summary="Select company or occupant type",
+    description="Select company or occupant type",
+)
+
+
+AuthenticationCheckTokenEventMethods = MethodToEvent(
+    events=[authentication_check_token_event],
+    headers=[],
+    errors=[],
+    url="/authentication/check-token",
+    method="POST",
+    summary="Check if token is valid",
+    description="Check if access token is valid for user",
+)
+
+
+AuthenticationRefreshEventMethods = MethodToEvent(
+    events=[authentication_refresh_user_info_event],
+    headers=[],
+    errors=[],
+    url="/authentication/refresh",
+    method="POST",
+    summary="Refresh user info",
+    description="Refresh user info using access token",
+)
+
+
+AuthenticationChangePasswordEventMethods = MethodToEvent(
+    events=[authentication_change_password_event],
+    headers=[],
+    errors=[],
+    url="/authentication/change-password",
+    method="POST",
+    summary="Change password",
+    description="Change password with access token",
+)
+
+
+AuthenticationCreatePasswordEventMethods = MethodToEvent(
+    events=[authentication_create_password_event],
+    headers=[],
+    errors=[],
+    url="/authentication/create-password",
+    method="POST",
+    summary="Create password",
+    description="Create password with password reset token requested via email",
+)
+
+
+AuthenticationDisconnectUserEventMethods = MethodToEvent(
+    events=[authentication_disconnect_user_event],
+    headers=[],
+    errors=[],
+    url="/authentication/disconnect",
+    method="POST",
+    summary="Disconnect all sessions",
+    description="Disconnect all sessions of user in access token",
+)
+
+
+AuthenticationLogoutEventMethods = MethodToEvent(
+    events=[authentication_logout_user_event],
+    headers=[],
+    errors=[],
+    url="/authentication/logout",
+    method="POST",
+    summary="Logout user",
+    description="Logout only single session of user which domain is provided",
+)
+
+
+AuthenticationRefreshTokenEventMethods = MethodToEvent(
+    events=[authentication_refresher_token_event],
+    headers=[],
+    errors=[],
+    url="/authentication/refresh-token",
+    method="POST",
+    summary="Refresh token",
+    description="Refresh access token with refresher token",
+)
+
+
+AuthenticationForgotPasswordEventMethods = MethodToEvent(
+    events=[authentication_forgot_password_event],
+    headers=[],
+    errors=[],
+    url="/authentication/forgot-password",
+    method="POST",
+    summary="Request password reset",
+    description="Send an email to user for a valid password reset token",
+)
+
+
+AuthenticationResetPasswordEventMethods = MethodToEvent(
+    events=[authentication_reset_password_event],
+    headers=[],
+    errors=[],
+    url="/authentication/reset-password",
+    method="POST",
+    summary="Reset password",
+    description="Reset user password",
+)
+
+
+AuthenticationDownloadAvatarEventMethods = MethodToEvent(
+    events=[authentication_download_avatar_event],
+    headers=[],
+    errors=[],
+    url="/authentication/download-avatar",
+    method="POST",
+    summary="Download avatar",
+    description="Download avatar icon and profile info of user",
+)

Events/AllEvents/authentication/auth/cluster.py

@@ -0,0 +1,41 @@
+from Events.Engine.abstract_class import CategoryCluster
+
+from .info import authentication_page_info
+from .auth import (
+    AuthenticationLoginEventMethods,
+    AuthenticationLogoutEventMethods,
+    AuthenticationRefreshTokenEventMethods,
+    AuthenticationForgotPasswordEventMethods,
+    AuthenticationChangePasswordEventMethods,
+    AuthenticationCheckTokenEventMethods,
+    AuthenticationCreatePasswordEventMethods,
+    AuthenticationDisconnectUserEventMethods,
+    AuthenticationDownloadAvatarEventMethods,
+    AuthenticationResetPasswordEventMethods,
+    AuthenticationRefreshEventMethods,
+    AuthenticationSelectEventMethods,
+)
+
+
+AuthCluster = CategoryCluster(
+    tags=["authentication"],
+    prefix="/authentication",
+    description="Authentication cluster",
+    pageinfo=authentication_page_info,
+    endpoints=[
+        AuthenticationLoginEventMethods,
+        AuthenticationLogoutEventMethods,
+        AuthenticationRefreshTokenEventMethods,
+        AuthenticationForgotPasswordEventMethods,
+        AuthenticationChangePasswordEventMethods,
+        AuthenticationCheckTokenEventMethods,
+        AuthenticationCreatePasswordEventMethods,
+        AuthenticationDisconnectUserEventMethods,
+        AuthenticationDownloadAvatarEventMethods,
+        AuthenticationResetPasswordEventMethods,
+        AuthenticationRefreshEventMethods,
+        AuthenticationSelectEventMethods,
+    ],
+    include_in_schema=True,
+    sub_category=[],
+)

Events/AllEvents/authentication/auth/function_handlers.py

@@ -0,0 +1,481 @@
+from typing import Any, TYPE_CHECKING, Union
+
+from Events.base_request_model import TokenDictType
+from Events.Engine.abstract_class import MethodToEvent
+from Events.base_request_model import SuccessResponse
+
+from ApiLayers.ApiLibrary.common.line_number import get_line_number_for_error
+from ApiLayers.ApiLibrary.date_time_actions.date_functions import DateTimeLocal
+from ApiLayers.ApiServices.middleware.auth_middleware import AuthMiddlewareModule
+
+from ApiLayers.ApiServices.Login.user_login_handler import UserLoginModule
+from ApiLayers.ApiServices.Token.token_handler import TokenService
+from ApiLayers.ApiValidations.Custom.token_objects import CompanyToken, OccupantToken
+from ApiLayers.ErrorHandlers import HTTPExceptionApi
+from ApiLayers.Schemas import (
+    BuildLivingSpace,
+    BuildParts,
+    RelationshipEmployee2Build,
+    Companies,
+    Departments, 
+    Duties, 
+    Duty,
+    Staff,
+    Employees,
+    Event2Employee,
+    Event2Occupant,
+    OccupantTypes,
+    Users
+)
+from ApiLayers.ApiServices.Token.token_handler import OccupantTokenObject, EmployeeTokenObject
+
+if TYPE_CHECKING:
+    from fastapi import Request
+
+
+# Type aliases for common types
+TokenDictType = Union["EmployeeTokenObject", "OccupantTokenObject"]
+
+
+def authentication_login_with_domain_and_creds(request: Request, data: Any):
+    """
+    Authenticate user with domain and credentials.
+
+    Args:
+        request: FastAPI request object
+        data: Request body containing login credentials
+            {
+                "domain": "evyos.com.tr",
+                "access_key": "karatay.berkay.sup@evyos.com.tr",
+                "password": "string",
+                "remember_me": false
+            }
+    Returns:
+        SuccessResponse containing authentication token and user info
+    """
+    # Get token from login module
+    user_login_module = UserLoginModule(request=request)
+    token = user_login_module.login_user_via_credentials(access_data=data)
+
+    # Return response with token and headers
+    return {
+        "completed": True,
+        "message": "User is logged in successfully",
+        "access_token": token.get("access_token"),
+        "refresh_token": token.get("refresher_token"),
+        "access_object": {
+            "user_type": token.get("user_type"),
+            "companies_list": token.get("companies_list"),
+        },
+        "user": token.get("user"),
+    }
+
+@AuthMiddlewareModule.auth_required
+def handle_employee_selection(request: Request, data: Any, token_dict: TokenDictType):
+    Users.set_user_define_properties(token=token_dict)
+    db_session = Users.new_session()
+
+    if data.company_uu_id not in token_dict.companies_uu_id_list:
+        raise HTTPExceptionApi(
+            error_code="HTTP_400_BAD_REQUEST",
+            lang=token_dict.lang,
+            loc=get_line_number_for_error(),
+            sys_msg="Company not found in token",
+        )
+    selected_company = Companies.filter_one(
+        Companies.uu_id == data.company_uu_id,
+        db=db_session,
+    ).first
+    if not selected_company:
+        raise HTTPExceptionApi(
+            error_code="HTTP_400_BAD_REQUEST",
+            lang=token_dict.lang,
+            loc=get_line_number_for_error(),
+            sys_msg="Company not found in token",
+        )
+
+    # Get department IDs for the company
+    department_ids = [
+        dept.id
+        for dept in Departments.filter_all(
+            Departments.company_id == selected_company.id,
+            db=db_session,
+        ).data
+    ]
+
+    # Get duties IDs for the company
+    duties_ids = [
+        duty.id
+        for duty in Duties.filter_all(
+            Duties.company_id == selected_company.id, db=db_session
+        ).data
+    ]
+
+    # Get staff IDs
+    staff_ids = [
+        staff.id
+        for staff in Staff.filter_all(
+            Staff.duties_id.in_(duties_ids), db=db_session
+        ).data
+    ]
+
+    # Get employee
+    employee = Employees.filter_one(
+        Employees.people_id == token_dict.person_id,
+        Employees.staff_id.in_(staff_ids),
+        db=db_session,
+    ).first
+
+    if not employee:
+        raise HTTPExceptionApi(
+            error_code="HTTP_400_BAD_REQUEST",
+            lang=token_dict.lang,
+            loc=get_line_number_for_error(),
+            sys_msg="Employee not found in token",
+        )
+
+    # Get reachable events
+    reachable_event_codes = Event2Employee.get_event_codes(employee_id=employee.id)
+    reachable_event_endpoints = Event2Employee.get_event_endpoints(
+        employee_id=employee.id
+    )
+
+    # Get staff and duties
+    staff = Staff.filter_one(Staff.id == employee.staff_id, db=db_session).data
+    duties = Duties.filter_one(Duties.id == staff.duties_id, db=db_session).data
+    department = Departments.filter_one(
+        Departments.id == duties.department_id, db=db_session
+    ).data
+
+    # Get bulk duty
+    bulk_id = Duty.filter_by_one(system=True, duty_code="BULK", db=db_session).data
+    bulk_duty_id = Duties.filter_by_one(
+        company_id=selected_company.id,
+        duties_id=bulk_id.id,
+        **Duties.valid_record_dict,
+        db=db_session,
+    ).data
+    # Create company token
+    company_token = CompanyToken(
+        company_uu_id=selected_company.uu_id.__str__(),
+        company_id=selected_company.id,
+        department_id=department.id,
+        department_uu_id=department.uu_id.__str__(),
+        duty_id=duties.id,
+        duty_uu_id=duties.uu_id.__str__(),
+        bulk_duties_id=bulk_duty_id.id,
+        staff_id=staff.id,
+        staff_uu_id=staff.uu_id.__str__(),
+        employee_id=employee.id,
+        employee_uu_id=employee.uu_id.__str__(),
+        reachable_event_codes=reachable_event_codes,
+        reachable_event_endpoints=reachable_event_endpoints,
+    )
+    try:  # Update Redis
+        update_token = TokenService.update_token_at_redis(
+            request=request, add_payload=company_token
+        )
+        return update_token
+    except Exception as e:
+        raise HTTPExceptionApi(
+            error_code="",
+            lang="en",
+            loc=get_line_number_for_error(),
+            sys_msg=f"{e}",
+        )
+
+
+@AuthMiddlewareModule.auth_required
+def handle_occupant_selection(request: Request, data: Any, token_dict: TokenDictType):
+    """Handle occupant type selection"""
+    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
+    )
+    reachable_event_endpoints = Event2Occupant.get_event_endpoints(
+        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,
+        reachable_event_endpoints=reachable_event_endpoints,
+    )
+
+    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}",
+        )
+
+
+@AuthMiddlewareModule.auth_required
+def authentication_select_company_or_occupant_type(request: Request, data: Any, token_dict: TokenDictType):
+    """Handle selection of company or occupant type"""
+    if token_dict.is_employee:
+        return cls._handle_employee_selection(data, token_dict, request)
+    elif token_dict.is_occupant:
+        return cls._handle_occupant_selection(data, token_dict, request)
+
+
+@AuthMiddlewareModule.auth_required
+def authentication_check_token_is_valid(request: "Request", data: Any):
+    """Check if token is valid for user"""
+    # try:
+    #     if RedisActions.get_object_via_access_key(request=request):
+    #         return ResponseHandler.success("Access Token is valid")
+    # except HTTPException:
+    #     return ResponseHandler.unauthorized("Access Token is NOT valid")
+    return
+
+
+@AuthMiddlewareModule.auth_required
+def authentication_refresh_user_info(request: "Request", token_dict: TokenDictType, data: Any):
+    """Refresh user info using access token"""
+    # try:
+    #     access_token = request.headers.get(Auth.ACCESS_TOKEN_TAG)
+    #     if not access_token:
+    #         return ResponseHandler.unauthorized()
+
+    #     found_user = Users.filter_one(Users.uu_id == token_dict.user_uu_id).data
+    #     if not found_user:
+    #         return ResponseHandler.not_found("User not found")
+    #     user_token = UsersTokens.filter_one(
+    #         UsersTokens.domain == found_user.domain_name,
+    #         UsersTokens.user_id == found_user.id,
+    #         UsersTokens.token_type == "RememberMe",
+    #     ).data
+    #     response_data = {
+    #         "access_token": access_token,
+    #         "refresh_token": getattr(user_token, "token", None),
+    #         "user": found_user.get_dict(),
+    #     }
+    #     return ResponseHandler.success(
+    #         "User info refreshed successfully",
+    #         data=response_data,
+    #     )
+    # except Exception as e:
+    #     return ResponseHandler.error(str(e))
+    return
+
+
+@AuthMiddlewareModule.auth_required
+def authentication_change_password(request: "Request", token_dict: TokenDictType, data: Any):
+    """Change password with access token"""
+    # try:
+    #     if not isinstance(token_dict, EmployeeTokenObject):
+    #         return ResponseHandler.unauthorized("Only employees can change password")
+
+    #     found_user = Users.filter_one(Users.uu_id == token_dict.user_uu_id).data
+    #     if not found_user:
+    #         return ResponseHandler.not_found("User not found")
+
+    #     if not found_user.check_password(data.old_password):
+    #         return ResponseHandler.unauthorized("Old password is incorrect")
+
+    #     found_user.set_password(data.new_password)
+    #     return ResponseHandler.success("Password changed successfully")
+    # except Exception as e:
+    #     return ResponseHandler.error(str(e))
+    return
+
+
+def authentication_create_password(request: "Request", data: Any):
+    """Create password with password reset token requested via email"""
+    # if not data.re_password == data.password:
+    #     raise HTTPException(status_code=status.HTTP_406_NOT_ACCEPTABLE, detail="Password must match")
+    # if found_user := Users.filter_one(Users.password_token == data.password_token).data:
+    #     found_user.create_password(found_user=found_user, password=data.password)
+    #     found_user.password_token = ""
+    #     found_user.save()
+    #     return ResponseHandler.success("Password is created successfully", data=found_user.get_dict())
+    # return ResponseHandler.not_found("Record not found")
+    return
+
+
+@AuthMiddlewareModule.auth_required
+def authentication_disconnect_user(request: "Request", token_dict: TokenDictType, data: Any):
+    """Disconnect all sessions of user in access token"""
+    # found_user = Users.filter_one(Users.uu_id == token_dict.user_uu_id).data
+    # if not found_user:
+    #     return ResponseHandler.not_found("User not found")
+    # if already_tokens := RedisActions.get_object_via_user_uu_id(user_id=str(found_user.uu_id)):
+    #     for key, token_user in already_tokens.items():
+    #         RedisActions.delete(key)
+    #         selected_user = Users.filter_one(Users.uu_id == token_user.get("uu_id")).data
+    #         selected_user.remove_refresher_token(domain=data.domain, disconnect=True)
+    #         return ResponseHandler.success("All sessions are disconnected", data=selected_user.get_dict())
+    # return ResponseHandler.not_found("Invalid data")
+    return
+
+
+def authentication_logout_user(request: "Request", data: Any, token_dict: TokenDictType):
+    """Logout only single session of user which domain is provided"""
+    # token_user = None
+    # if already_tokens := RedisActions.get_object_via_access_key(request=request):
+    #     for key in already_tokens:
+    #         token_user = RedisActions.get_json(key)
+    #         if token_user.get("domain") == data.domain:
+    #             RedisActions.delete(key)
+    #             selected_user = Users.filter_one(Users.uu_id == token_user.get("uu_id")).data
+    #             selected_user.remove_refresher_token(domain=data.domain)
+    #     return ResponseHandler.success("Session is logged out", data=token_user)
+    # return ResponseHandler.not_found("Logout is not successfully completed")
+    return
+
+
+@AuthMiddlewareModule.auth_required
+def authentication_refresher_token(request: "Request", token_dict: TokenDictType, data: Any):
+    """Refresh access token with refresher token"""
+    # token_refresher = UsersTokens.filter_by_one(
+    #     token=data.refresh_token,
+    #     domain=data.domain,
+    #     **UsersTokens.valid_record_dict,
+    # ).data
+    # if not token_refresher:
+    #     return ResponseHandler.not_found("Invalid data")
+    # if found_user := Users.filter_one(Users.id == token_refresher.user_id).data:
+    #     access_key = AuthActions.save_access_token_to_redis(
+    #         request=request, found_user=found_user, domain=data.domain
+    #     )
+    #     found_user.last_agent = request.headers.get("User-Agent", None)
+    #     found_user.last_platform = request.headers.get("Origin", None)
+    #     found_user.last_remote_addr = getattr(request, "remote_addr", None) or request.headers.get("X-Forwarded-For", None)
+    #     found_user.last_seen = str(system_arrow.now())
+    #     response_data = {
+    #         "access_token": access_key,
+    #         "refresh_token": data.refresh_token,
+    #     }
+    #     return ResponseHandler.success("User is logged in successfully via refresher token", data=response_data)
+    # return ResponseHandler.not_found("Invalid data")
+    return
+
+
+def authentication_forgot_password(request: "Request", data: Any):
+    """Send an email to user for a valid password reset token"""
+    # found_user: Users = Users.check_user_exits(access_key=data.access_key, domain=data.domain)
+    # forgot_key = AuthActions.save_access_token_to_redis(request=request, found_user=found_user, domain=data.domain)
+    # forgot_link = ApiStatic.forgot_link(forgot_key=forgot_key)
+    # send_email_completed = send_email(
+    #     subject=f"Dear {found_user.user_tag}, your forgot password link has been sent.",
+    #     receivers=[str(found_user.email)],
+    #     html=change_your_password_template(user_name=found_user.user_tag, forgot_link=forgot_link),
+    # )
+    # if not send_email_completed:
+    #     raise HTTPException(status_code=400, detail="Email can not be sent. Try again later")
+    # found_user.password_token = forgot_key
+    # found_user.password_token_is_valid = str(system_arrow.shift(days=1))
+    # found_user.save()
+    # return ResponseHandler.success("Password is change link is sent to your email or phone", data={})
+    return
+
+
+@AuthMiddlewareModule.auth_required
+def authentication_reset_password(request: "Request", data: Any):
+    """Reset password with forgot password token"""
+    # from sqlalchemy import or_
+    # found_user = Users.query.filter(
+    #     or_(
+    #         Users.email == str(data.access_key).lower(),
+    #         Users.phone_number == str(data.access_key).replace(" ", ""),
+    #     ),
+    # ).first()
+    # if not found_user:
+    #     raise HTTPException(
+    #         status_code=status.HTTP_400_BAD_REQUEST,
+    #         detail="Given access key or domain is not matching with the any user record.",
+    #     )
+    # reset_password_token = found_user.reset_password_token(found_user=found_user)
+    # send_email_completed = send_email(
+    #     subject=f"Dear {found_user.user_tag}, a password reset request has been received.",
+    #     receivers=[str(found_user.email)],
+    #     html=change_your_password_template(
+    #         user_name=found_user.user_tag,
+    #         forgot_link=ApiStatic.forgot_link(forgot_key=reset_password_token),
+    #     ),
+    # )
+    # if not send_email_completed:
+    #     raise found_user.raise_http_exception(status_code=400, message="Email can not be sent. Try again later")
+    # return ResponseHandler.success("Password change link is sent to your email or phone", data=found_user.get_dict())
+    return
+
+
+@AuthMiddlewareModule.auth_required
+def authentication_download_avatar(request: "Request", data: Any, token_dict: TokenDictType):
+    """Download avatar icon and profile info of user"""
+    # if found_user := Users.filter_one(Users.id == token_dict.user_id).data:
+    #     expired_starts = str(system_arrow.now() - system_arrow.get(str(found_user.expiry_ends)))
+    #     expired_int = (system_arrow.now() - system_arrow.get(str(found_user.expiry_ends))).days
+    #     user_info = {
+    #         "lang": token_dict.lang,
+    #         "full_name": found_user.person.full_name,
+    #         "avatar": found_user.avatar,
+    #         "remember_me": found_user.remember_me,
+    #         "expiry_ends": str(found_user.expiry_ends),
+    #         "expired_str": expired_starts,
+    #         "expired_int": int(expired_int),
+    #     }
+    #     return ResponseHandler.success("Avatar and profile is shared via user credentials", data=user_info)
+    # return ResponseHandler.not_found("Invalid data")
+    return

Events/AllEvents/authentication/auth/info.py

@@ -0,0 +1,13 @@
+from Events.Engine.abstract_class import PageInfo
+
+
+authentication_page_info = PageInfo(
+    name="Authentication",
+    title={"en": "Authentication"},
+    description={"en": "Authentication"},
+    icon="",
+    parent="",
+    url="",
+)
+
+

Events/AllEvents/authentication/auth/models.py

@@ -0,0 +1,34 @@
+from pydantic import BaseModel
+
+
+class LoginSuperUserRequestModel(BaseModel):
+    pass
+
+
+class LoginSuperUserResponseModel(BaseModel):
+    pass
+
+
+class SelectCompanyOrOccupantTypeSuperUserRequestModel(BaseModel):
+    pass
+
+
+class SelectCompanyOrOccupantTypeSuperUserResponseModel(BaseModel):
+    pass
+
+
+class EmployeeSelectionSuperUserRequestModel(BaseModel):
+    pass
+
+
+class EmployeeSelectionSuperUserResponseModel(BaseModel):
+    pass
+
+
+class OccupantSelectionSuperUserRequestModel(BaseModel):
+    pass
+
+
+class OccupantSelectionSuperUserResponseModel(BaseModel):
+    pass
+

Events/AllEvents/events/account/__init__.py

@@ -0,0 +1,9 @@
+"""
+Account records package initialization.
+"""
+
+from .endpoints import ACCOUNT_RECORDS_CONFIG
+
+__all__ = [
+    "ACCOUNT_RECORDS_CONFIG",
+]

Events/AllEvents/events/account/account_records.py

@@ -0,0 +1,351 @@
+"""
+Account records service implementation.
+"""
+
+from typing import Union
+from pydantic import Field
+
+from ApiEvents.abstract_class import MethodToEvent, endpoint_wrapper
+from ApiEvents.base_request_model import DictRequestModel
+from ApiValidations.Custom.token_objects import (
+    OccupantTokenObject,
+    EmployeeTokenObject,
+)
+from ApiLibrary import system_arrow
+from ApiValidations.Request.account_records import (
+    InsertAccountRecord,
+    UpdateAccountRecord,
+)
+from ApiValidations.Request.base_validations import ListOptions
+from Schemas import (
+    BuildLivingSpace,
+    AccountRecords,
+    BuildIbans,
+    BuildDecisionBookPayments,
+    ApiEnumDropdown,
+)
+from Services.PostgresDb.Models.alchemy_response import (
+    AlchemyJsonResponse,
+)
+from ApiValidations.Response import AccountRecordResponse
+from .models import (
+    InsertAccountRecordRequestModel,
+    UpdateAccountRecordRequestModel,
+    ListOptionsRequestModel,
+)
+
+
+class AccountListEventMethod(MethodToEvent):
+
+    event_type = "SELECT"
+    event_description = ""
+    event_category = ""
+
+    __event_keys__ = {
+        "7192c2aa-5352-4e36-98b3-dafb7d036a3d": "account_records_list",
+        "208e6273-17ef-44f0-814a-8098f816b63a": "account_records_list_flt_res",
+    }
+    __event_validation__ = {
+        "7192c2aa-5352-4e36-98b3-dafb7d036a3d": (
+            AccountRecordResponse,
+            [AccountRecords.__language_model__],
+        ),
+        "208e6273-17ef-44f0-814a-8098f816b63a": (
+            AccountRecordResponse,
+            [AccountRecords.__language_model__],
+        ),
+    }
+
+    @classmethod
+    def account_records_list(
+        cls,
+        list_options: ListOptionsRequestModel,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        db_session = AccountRecords.new_session()
+        if isinstance(token_dict, OccupantTokenObject):
+            AccountRecords.pre_query = AccountRecords.filter_all(
+                AccountRecords.company_id
+                == token_dict.selected_occupant.responsible_company_id,
+                db=db_session,
+            ).query
+        elif isinstance(token_dict, EmployeeTokenObject):
+            AccountRecords.pre_query = AccountRecords.filter_all(
+                AccountRecords.company_id == token_dict.selected_company.company_id,
+                db=db_session,
+            ).query
+        AccountRecords.filter_attr = list_options
+        records = AccountRecords.filter_all(db=db_session)
+        return AlchemyJsonResponse(
+            completed=True,
+            message="Account records listed successfully",
+            result=records,
+            cls_object=AccountRecords,
+            filter_attributes=list_options,
+            response_model=AccountRecordResponse,
+        )
+
+    @classmethod
+    def account_records_list_flt_res(
+        cls,
+        list_options: ListOptionsRequestModel,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        db_session = AccountRecords.new_session()
+        if not isinstance(token_dict, OccupantTokenObject):
+            raise AccountRecords.raise_http_exception(
+                status_code="HTTP_404_NOT_FOUND",
+                error_case="UNAUTHORIZED",
+                message="Only Occupant can see this data",
+                data={},
+            )
+
+        return_list = []
+        living_space: BuildLivingSpace = BuildLivingSpace.filter_by_one(
+            id=token_dict.selected_occupant.living_space_id
+        ).data
+        if not living_space:
+            raise AccountRecords.raise_http_exception(
+                status_code="HTTP_404_NOT_FOUND",
+                error_case="UNAUTHORIZED",
+                message="Living space not found",
+                data={},
+            )
+
+        if not list_options:
+            list_options = ListOptions()
+
+        main_filters = [
+            AccountRecords.living_space_id
+            == token_dict.selected_occupant.living_space_id,
+            BuildDecisionBookPayments.process_date
+            >= str(system_arrow.now().shift(months=-3).date()),
+            BuildDecisionBookPayments.process_date
+            < str(system_arrow.find_last_day_of_month(living_space.expiry_ends)),
+            BuildDecisionBookPayments.process_date
+            >= str(system_arrow.get(living_space.expiry_starts)),
+            BuildDecisionBookPayments.is_confirmed == True,
+            AccountRecords.active == True,
+        ]
+        order_type = "desc"
+        if list_options.order_type:
+            order_type = "asc" if list_options.order_type[0] == "a" else "desc"
+
+        order_by_list = BuildDecisionBookPayments.process_date.desc()
+        if list_options.order_field:
+            if list_options.order_field == "process_date":
+                order_by_list = (
+                    BuildDecisionBookPayments.process_date.asc()
+                    if order_type == "asc"
+                    else BuildDecisionBookPayments.process_date.desc()
+                )
+            if list_options.order_field == "bank_date":
+                order_by_list = (
+                    AccountRecords.bank_date.desc()
+                    if order_type == "asc"
+                    else AccountRecords.bank_date.asc()
+                )
+            if list_options.order_field == "currency_value":
+                order_by_list = (
+                    AccountRecords.currency_value.desc()
+                    if order_type == "asc"
+                    else AccountRecords.currency_value.asc()
+                )
+            if list_options.order_field == "process_comment":
+                order_by_list = (
+                    AccountRecords.process_comment.desc()
+                    if order_type == "asc"
+                    else AccountRecords.process_comment.asc()
+                )
+            if list_options.order_field == "payment_amount":
+                order_by_list = (
+                    BuildDecisionBookPayments.payment_amount.desc()
+                    if order_type == "asc"
+                    else BuildDecisionBookPayments.payment_amount.asc()
+                )
+
+        if list_options.query:
+            for key, value in list_options.query.items():
+                if key == "process_date":
+                    main_filters.append(BuildDecisionBookPayments.process_date == value)
+                if key == "bank_date":
+                    main_filters.append(AccountRecords.bank_date == value)
+                if key == "currency":
+                    main_filters.append(BuildDecisionBookPayments.currency == value)
+                if key == "currency_value":
+                    main_filters.append(AccountRecords.currency_value == value)
+                if key == "process_comment":
+                    main_filters.append(AccountRecords.process_comment == value)
+                if key == "payment_amount":
+                    main_filters.append(
+                        BuildDecisionBookPayments.payment_amount == value
+                    )
+
+        query = (
+            AccountRecords.session.query(
+                BuildDecisionBookPayments.process_date,
+                BuildDecisionBookPayments.payment_amount,
+                BuildDecisionBookPayments.currency,
+                AccountRecords.bank_date,
+                AccountRecords.currency_value,
+                AccountRecords.process_comment,
+                BuildDecisionBookPayments.uu_id,
+            )
+            .join(
+                AccountRecords,
+                AccountRecords.id == BuildDecisionBookPayments.account_records_id,
+            )
+            .filter(*main_filters)
+        ).order_by(order_by_list)
+
+        query.limit(list_options.size or 5).offset(
+            (list_options.page or 1 - 1) * list_options.size or 5
+        )
+        for list_of_values in query.all() or []:
+            return_list.append(
+                {
+                    "process_date": list_of_values[0],
+                    "payment_amount": list_of_values[1],
+                    "currency": list_of_values[2],
+                    "bank_date": list_of_values[3],
+                    "currency_value": list_of_values[4],
+                    "process_comment": list_of_values[5],
+                }
+            )
+        return AlchemyJsonResponse(
+            completed=True,
+            message="Account records listed successfully",
+            result=return_list,
+            cls_object=AccountRecords,
+            filter_attributes=list_options,
+            response_model=AccountRecordResponse,
+        )
+
+
+class AccountCreateEventMethod(MethodToEvent):
+
+    event_type = "CREATE"
+    event_description = ""
+    event_category = ""
+
+    __event_keys__ = {
+        "31f4f32f-0cd4-4995-8a6a-f9f56335848a": "account_records_create",
+    }
+    __event_validation__ = {
+        "31f4f32f-0cd4-4995-8a6a-f9f56335848a": (
+            InsertAccountRecord,
+            [AccountRecords.__language_model__],
+        ),
+    }
+
+    @classmethod
+    def account_records_create(
+        cls,
+        data: InsertAccountRecordRequestModel,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        data_dict = data.excluded_dump()
+        if isinstance(token_dict, OccupantTokenObject):
+            db_session = AccountRecords.new_session()
+            build_iban = BuildIbans.filter_one(
+                BuildIbans.iban == data.iban,
+                BuildIbans.build_id == token_dict.selected_occupant.build_id,
+                db=db_session,
+            ).data
+            if not build_iban:
+                raise BuildIbans.raise_http_exception(
+                    status_code="HTTP_404_NOT_FOUND",
+                    error_case="UNAUTHORIZED",
+                    message=f"{data.iban} is not found in company related to your organization",
+                    data={
+                        "iban": data.iban,
+                    },
+                )
+            account_record = AccountRecords.find_or_create(**data.excluded_dump())
+            return AlchemyJsonResponse(
+                completed=True,
+                message="Account record created successfully",
+                result=account_record,
+            )
+        elif isinstance(token_dict, EmployeeTokenObject):
+            # Build.pre_query = Build.select_action(
+            #     employee_id=token_dict.selected_employee.employee_id,
+            # )
+            # build_ids_list = Build.filter_all(
+            # )
+            # build_iban = BuildIbans.filter_one(
+            #     BuildIbans.iban == data.iban,
+            #     BuildIbans.build_id.in_([build.id for build in build_ids_list.data]),
+            # ).data
+            # if not build_iban:
+            #     BuildIbans.raise_http_exception(
+            #         status_code="HTTP_404_NOT_FOUND",
+            #         error_case="UNAUTHORIZED",
+            #         message=f"{data.iban} is not found in company related to your organization",
+            #         data={
+            #             "iban": data.iban,
+            #         },
+            #     )
+            bank_date = system_arrow.get(data.bank_date)
+            data_dict["bank_date_w"] = bank_date.weekday()
+            data_dict["bank_date_m"] = bank_date.month
+            data_dict["bank_date_d"] = bank_date.day
+            data_dict["bank_date_y"] = bank_date.year
+
+            if int(data.currency_value) < 0:
+                debit_type = ApiEnumDropdown.filter_by_one(
+                    system=True, enum_class="DebitTypes", key="DT-D"
+                ).data
+                data_dict["receive_debit"] = debit_type.id
+                data_dict["receive_debit_uu_id"] = str(debit_type.uu_id)
+            else:
+                debit_type = ApiEnumDropdown.filter_by_one(
+                    system=True, enum_class="DebitTypes", key="DT-R"
+                ).data
+                data_dict["receive_debit"] = debit_type.id
+                data_dict["receive_debit_uu_id"] = str(debit_type.uu_id)
+
+            account_record = AccountRecords.insert_one(data_dict).data
+            return AlchemyJsonResponse(
+                completed=True,
+                message="Account record created successfully",
+                result=account_record,
+            )
+
+
+class AccountUpdateEventMethod(MethodToEvent):
+
+    event_type = "UPDATE"
+    event_description = ""
+    event_category = ""
+
+    __event_keys__ = {
+        "ec98ef2c-bcd0-432d-a8f4-1822a56c33b2": "account_records_update",
+    }
+    __event_validation__ = {
+        "ec98ef2c-bcd0-432d-a8f4-1822a56c33b2": (
+            UpdateAccountRecord,
+            [AccountRecords.__language_model__],
+        ),
+    }
+
+    @classmethod
+    def account_records_update(
+        cls,
+        build_uu_id: str,
+        data: UpdateAccountRecordRequestModel,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        if isinstance(token_dict, OccupantTokenObject):
+            pass
+        elif isinstance(token_dict, EmployeeTokenObject):
+            pass
+        AccountRecords.build_parts_id = token_dict.selected_occupant.build_part_id
+        account_record = AccountRecords.update_one(build_uu_id, data).data
+        return AlchemyJsonResponse(
+            completed=True,
+            message="Account record updated successfully",
+            result=account_record,
+            cls_object=AccountRecords,
+            response_model=UpdateAccountRecord,
+        )

Events/AllEvents/events/account/endpoints.py

@@ -0,0 +1,131 @@
+"""
+Account records endpoint configurations.
+
+"""
+
+from ApiEvents.abstract_class import (
+    RouteFactoryConfig,
+    EndpointFactoryConfig,
+    endpoint_wrapper,
+)
+from ApiEvents.base_request_model import EndpointBaseRequestModel
+
+from Services.PostgresDb.Models.alchemy_response import DictJsonResponse
+from fastapi import Request, Path, Body
+
+
+@endpoint_wrapper("/account/records/list")
+async def address_list(request: "Request", data: EndpointBaseRequestModel):
+    """Handle address list endpoint."""
+    auth_dict = address_list.auth
+    code_dict = getattr(address_list, "func_code", {"function_code": None})
+    return {"auth_dict": auth_dict, "code_dict": code_dict, "data": data}
+
+
+@endpoint_wrapper("/account/records/create")
+async def address_create(request: "Request", data: EndpointBaseRequestModel):
+    """Handle address creation endpoint."""
+    return {
+        "data": data,
+        "request": str(request.headers),
+        "request_url": str(request.url),
+        "request_base_url": str(request.base_url),
+    }
+
+
+@endpoint_wrapper("/account/records/search")
+async def address_search(request: "Request", data: EndpointBaseRequestModel):
+    """Handle address search endpoint."""
+    auth_dict = address_search.auth
+    code_dict = getattr(address_search, "func_code", {"function_code": None})
+    return {"auth_dict": auth_dict, "code_dict": code_dict, "data": data}
+
+
+@endpoint_wrapper("/account/records/{address_uu_id}")
+async def address_update(
+    request: Request,
+    address_uu_id: str = Path(..., description="UUID of the address to update"),
+    request_data: EndpointBaseRequestModel = Body(..., description="Request body"),
+):
+    """
+    Handle address update endpoint.
+
+    Args:
+        request: FastAPI request object
+        address_uu_id: UUID of the address to update
+        request_data: Request body containing updated address data
+
+    Returns:
+        DictJsonResponse: Response containing updated address info
+    """
+    auth_dict = address_update.auth
+    return DictJsonResponse(
+        data={
+            "address_uu_id": address_uu_id,
+            "data": request_data.root,
+            "request": str(request.headers),
+            "request_url": str(request.url),
+            "request_base_url": str(request.base_url),
+        }
+    )
+
+
+prefix = "/account/records"
+
+# Account Records Router Configuration
+ACCOUNT_RECORDS_CONFIG = RouteFactoryConfig(
+    name="account_records",
+    prefix=prefix,
+    tags=["Account Records"],
+    include_in_schema=True,
+    endpoints=[
+        EndpointFactoryConfig(
+            url_prefix=prefix,
+            url_endpoint="/list",
+            url_of_endpoint=f"{prefix}/list",
+            endpoint="/list",
+            method="POST",
+            summary="List Active/Delete/Confirm Address",
+            description="List Active/Delete/Confirm Address",
+            is_auth_required=True,
+            is_event_required=True,
+            endpoint_function=address_list,
+        ),
+        EndpointFactoryConfig(
+            url_prefix=prefix,
+            url_endpoint="/create",
+            url_of_endpoint=f"{prefix}/create",
+            endpoint="/create",
+            method="POST",
+            summary="Create Address with given auth levels",
+            description="Create Address with given auth levels",
+            is_auth_required=False,
+            is_event_required=False,
+            endpoint_function=address_create,
+        ),
+        EndpointFactoryConfig(
+            url_prefix=prefix,
+            url_endpoint="/search",
+            url_of_endpoint=f"{prefix}/search",
+            endpoint="/search",
+            method="POST",
+            summary="Search Address with given auth levels",
+            description="Search Address with given auth levels",
+            is_auth_required=True,
+            is_event_required=True,
+            endpoint_function=address_search,
+        ),
+        EndpointFactoryConfig(
+            url_prefix=prefix,
+            url_endpoint="/{address_uu_id}",
+            url_of_endpoint="{prefix}/" + "{address_uu_id}",
+            endpoint="/{address_uu_id}",
+            method="PUT",
+            summary="Update Address with given auth levels",
+            description="Update Address with given auth levels",
+            is_auth_required=True,
+            is_event_required=True,
+            endpoint_function=address_update,
+        ),
+    ],
+).as_dict()

Events/AllEvents/events/account/models.py

@@ -0,0 +1,54 @@
+"""
+Account records request and response models.
+"""
+
+from typing import TYPE_CHECKING, Dict, Any
+from pydantic import BaseModel, Field, RootModel
+from ApiEvents.base_request_model import BaseRequestModel
+
+if TYPE_CHECKING:
+    from ApiValidations.Request import (
+        InsertAccountRecord,
+        UpdateAccountRecord,
+        ListOptions,
+    )
+
+
+class AddressUpdateRequest(RootModel[Dict[str, Any]]):
+    """Request model for address update."""
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "street": "123 Main St",
+                "city": "Example City",
+                "country": "Example Country",
+            }
+        }
+    }
+
+
+class AddressUpdateResponse(BaseModel):
+    """Response model for address update."""
+
+    address_uu_id: str = Field(..., description="UUID of the updated address")
+    data: Dict[str, Any] = Field(..., description="Updated address data")
+    function_code: str = Field(..., description="Function code for the endpoint")
+
+
+class InsertAccountRecordRequestModel(BaseRequestModel["InsertAccountRecord"]):
+    """Request model for inserting account records."""
+
+    pass
+
+
+class UpdateAccountRecordRequestModel(BaseRequestModel["UpdateAccountRecord"]):
+    """Request model for updating account records."""
+
+    pass
+
+
+class ListOptionsRequestModel(BaseRequestModel["ListOptions"]):
+    """Request model for list options."""
+
+    pass

Events/AllEvents/events/address/address.py

@@ -0,0 +1,351 @@
+"""
+ request models.
+"""
+
+from typing import TYPE_CHECKING, Dict, Any, List, Optional, TypedDict, Union
+from pydantic import BaseModel, Field, model_validator, RootModel, ConfigDict
+from ApiEvents.abstract_class import MethodToEvent
+from ApiEvents.base_request_model import BaseRequestModel, DictRequestModel
+from ApiValidations.Custom.token_objects import EmployeeTokenObject, OccupantTokenObject
+from ApiValidations.Request.address import SearchAddress, UpdateAddress
+from ApiValidations.Request.base_validations import ListOptions
+from ErrorHandlers.Exceptions.api_exc import HTTPExceptionApi
+from Schemas.identity.identity import (
+    AddressPostcode,
+    AddressStreet,
+    Addresses,
+    RelationshipEmployee2PostCode,
+)
+from ApiValidations.Request import (
+    InsertAddress,
+)
+from ApiValidations.Response import (
+    ListAddressResponse,
+)
+
+
+if TYPE_CHECKING:
+    from fastapi import Request
+
+
+class AddressListEventMethod(MethodToEvent):
+
+    event_type = "SELECT"
+    event_description = "List Address records"
+    event_category = "Address"
+
+    __event_keys__ = {
+        "9c251d7d-da70-4d63-a72c-e69c26270442": "address_list_super_user",
+        "52afe375-dd95-4f4b-aaa2-4ec61bc6de52": "address_list_employee",
+    }
+    __event_validation__ = {
+        "9c251d7d-da70-4d63-a72c-e69c26270442": (
+            ListAddressResponse,
+            [Addresses.__language_model__],
+        ),
+        "52afe375-dd95-4f4b-aaa2-4ec61bc6de52": (
+            ListAddressResponse,
+            [Addresses.__language_model__],
+        ),
+    }
+
+    @classmethod
+    def address_list_super_user(
+        cls,
+        list_options: ListOptions,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        db = RelationshipEmployee2PostCode.new_session()
+        post_code_list = RelationshipEmployee2PostCode.filter_all(
+            RelationshipEmployee2PostCode.company_id
+            == token_dict.selected_company.company_id,
+            db=db,
+        ).data
+        post_code_id_list = [post_code.member_id for post_code in post_code_list]
+        if not post_code_id_list:
+            raise HTTPExceptionApi(
+                status_code=404,
+                detail="User has no post code registered. User can not list addresses.",
+            )
+        get_street_ids = [
+            street_id[0]
+            for street_id in AddressPostcode.select_only(
+                AddressPostcode.id.in_(post_code_id_list),
+                select_args=[AddressPostcode.street_id],
+                order_by=AddressPostcode.street_id.desc(),
+                db=db,
+            ).data
+        ]
+        if not get_street_ids:
+            raise HTTPExceptionApi(
+                status_code=404,
+                detail="User has no street registered. User can not list addresses.",
+            )
+        Addresses.pre_query = Addresses.filter_all(
+            Addresses.street_id.in_(get_street_ids),
+            db=db,
+        ).query
+        Addresses.filter_attr = list_options
+        records = Addresses.filter_all(db=db).data
+        return {}
+        # return AlchemyJsonResponse(
+        #     completed=True, message="List Address records", result=records
+        # )
+
+    @classmethod
+    def address_list_employee(
+        cls,
+        list_options: ListOptions,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        # Addresses.filter_attr = list_options
+        Addresses.pre_query = Addresses.filter_all(
+            Addresses.street_id.in_(get_street_ids),
+        )
+        records = Addresses.filter_all().data
+        return
+        # return AlchemyJsonResponse(
+        #     completed=True, message="List Address records", result=records
+        # )
+
+
+class AddressCreateEventMethod(MethodToEvent):
+
+    event_type = "CREATE"
+    event_description = ""
+    event_category = ""
+
+    __event_keys__ = {
+        "ffdc445f-da10-4ce4-9531-d2bdb9a198ae": "create_address",
+    }
+    __event_validation__ = {
+        "ffdc445f-da10-4ce4-9531-d2bdb9a198ae": (
+            InsertAddress,
+            [Addresses.__language_model__],
+        ),
+    }
+
+    @classmethod
+    def create_address(
+        cls,
+        data: InsertAddress,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        post_code = AddressPostcode.filter_one(
+            AddressPostcode.uu_id == data.post_code_uu_id,
+        ).data
+        if not post_code:
+            raise HTTPExceptionApi(
+                status_code=404,
+                detail="Post code not found. User can not create address without post code.",
+            )
+
+        data_dict = data.excluded_dump()
+        data_dict["street_id"] = post_code.street_id
+        data_dict["street_uu_id"] = str(post_code.street_uu_id)
+        del data_dict["post_code_uu_id"]
+        address = Addresses.find_or_create(**data_dict)
+        address.save()
+        address.update(is_confirmed=True)
+        address.save()
+        return AlchemyJsonResponse(
+            completed=True,
+            message="Address created successfully",
+            result=address.get_dict(),
+        )
+
+
+class AddressSearchEventMethod(MethodToEvent):
+    """Event methods for searching addresses.
+
+    This class handles address search functionality including text search
+    and filtering.
+    """
+
+    event_type = "SEARCH"
+    event_description = "Search for addresses using text and filters"
+    event_category = "Address"
+
+    __event_keys__ = {
+        "e0ac1269-e9a7-4806-9962-219ac224b0d0": "search_address",
+    }
+    __event_validation__ = {
+        "e0ac1269-e9a7-4806-9962-219ac224b0d0": (
+            SearchAddress,
+            [Addresses.__language_model__],
+        ),
+    }
+
+    @classmethod
+    def _build_order_clause(
+        cls, filter_list: Dict[str, Any], schemas: List[str], filter_table: Any
+    ) -> Any:
+        """Build the ORDER BY clause for the query.
+
+        Args:
+            filter_list: Dictionary of filter options
+            schemas: List of available schema fields
+            filter_table: SQLAlchemy table to query
+
+        Returns:
+            SQLAlchemy order_by clause
+        """
+        # Default to ordering by UUID if field not in schema
+        if filter_list.get("order_field") not in schemas:
+            filter_list["order_field"] = "uu_id"
+        else:
+            # Extract table and field from order field
+            table_name, field_name = str(filter_list.get("order_field")).split(".")
+            filter_table = getattr(databases.sql_models, table_name)
+            filter_list["order_field"] = field_name
+
+        # Build order clause
+        field = getattr(filter_table, filter_list.get("order_field"))
+        return (
+            field.desc()
+            if str(filter_list.get("order_type"))[0] == "d"
+            else field.asc()
+        )
+
+    @classmethod
+    def _format_record(cls, record: Any, schemas: List[str]) -> Dict[str, str]:
+        """Format a database record into a dictionary.
+
+        Args:
+            record: Database record to format
+            schemas: List of schema fields
+
+        Returns:
+            Formatted record dictionary
+        """
+        result = {}
+        for index, schema in enumerate(schemas):
+            value = str(record[index])
+            # Special handling for UUID fields
+            if "uu_id" in value:
+                value = str(value)
+            result[schema] = value
+        return result
+
+    @classmethod
+    def search_address(
+        cls,
+        data: SearchAddress,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ) -> Any:
+        """Search for addresses using text search and filters.
+
+        Args:
+            data: Search parameters including text and filters
+            token_dict: Authentication token
+
+        Returns:
+            JSON response with search results
+
+        Raises:
+            HTTPExceptionApi: If search fails
+        """
+        try:
+            # Start performance measurement
+            start_time = perf_counter()
+
+            # Get initial query
+            search_result = AddressStreet.search_address_text(search_text=data.search)
+            if not search_result:
+                raise HTTPExceptionApi(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="No addresses found matching search criteria",
+                )
+
+            query = search_result.get("query")
+            schemas = search_result.get("schema")
+
+            # Apply filters
+            filter_list = data.list_options.dump()
+            filter_table = AddressStreet
+
+            # Build and apply order clause
+            order = cls._build_order_clause(filter_list, schemas, filter_table)
+
+            # Apply pagination
+            page_size = int(filter_list.get("size"))
+            offset = (int(filter_list.get("page")) - 1) * page_size
+
+            # Execute query
+            query = (
+                query.order_by(order)
+                .limit(page_size)
+                .offset(offset)
+                .populate_existing()
+            )
+            records = list(query.all())
+
+            # Format results
+            results = [cls._format_record(record, schemas) for record in records]
+
+            # Log performance
+            duration = perf_counter() - start_time
+            print(f"Address search completed in {duration:.3f}s")
+
+            return AlchemyJsonResponse(
+                completed=True, message="Address search results", result=results
+            )
+
+        except HTTPExceptionApi as e:
+            # Re-raise HTTP exceptions
+            raise e
+        except Exception as e:
+            # Log and wrap other errors
+            print(f"Address search error: {str(e)}")
+            raise HTTPExceptionApi(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to search addresses",
+            ) from e
+
+
+class AddressUpdateEventMethod(MethodToEvent):
+
+    event_type = "UPDATE"
+    event_description = ""
+    event_category = ""
+
+    __event_keys__ = {
+        "1f9c3a9c-e5bd-4dcd-9b9a-3742d7e03a27": "update_address",
+    }
+    __event_validation__ = {
+        "1f9c3a9c-e5bd-4dcd-9b9a-3742d7e03a27": (
+            UpdateAddress,
+            [Addresses.__language_model__],
+        ),
+    }
+
+    @classmethod
+    def update_address(
+        cls,
+        address_uu_id: str,
+        data: UpdateAddress,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        if isinstance(token_dict, EmployeeTokenObject):
+            address = Addresses.filter_one(
+                Addresses.uu_id == address_uu_id,
+            ).data
+            if not address:
+                raise HTTPExceptionApi(
+                    status_code=404,
+                    detail=f"Address not found. User can not update with given address uuid : {address_uu_id}",
+                )
+
+            data_dict = data.excluded_dump()
+            updated_address = address.update(**data_dict)
+            updated_address.save()
+            return AlchemyJsonResponse(
+                completed=True,
+                message="Address updated successfully",
+                result=updated_address.get_dict(),
+            )
+        elif isinstance(token_dict, OccupantTokenObject):
+            raise HTTPExceptionApi(
+                status_code=403,
+                detail="Occupant can not update address.",
+            )

Events/AllEvents/events/address/endpoints.py

@@ -0,0 +1,112 @@
+"""
+Account records endpoint configurations.
+
+"""
+
+from ApiEvents.abstract_class import (
+    RouteFactoryConfig,
+    EndpointFactoryConfig,
+    endpoint_wrapper,
+)
+from ApiEvents.base_request_model import EndpointBaseRequestModel
+
+from Services.PostgresDb.Models.alchemy_response import DictJsonResponse
+from fastapi import Request, Path, Body
+
+
+@endpoint_wrapper("/address/list")
+async def address_list(request: "Request", data: EndpointBaseRequestModel):
+    """Handle address list endpoint."""
+    auth_dict = address_list.auth
+    code_dict = getattr(address_list, "func_code", {"function_code": None})
+    return {"auth_dict": auth_dict, "code_dict": code_dict, "data": data}
+
+
+@endpoint_wrapper("/address/create")
+async def address_create(request: "Request", data: EndpointBaseRequestModel):
+    """Handle address creation endpoint."""
+    return {
+        "data": data,
+        "request": str(request.headers),
+        "request_url": str(request.url),
+        "request_base_url": str(request.base_url),
+    }
+
+
+@endpoint_wrapper("/address/update/{address_uu_id}")
+async def address_update(
+    request: Request,
+    address_uu_id: str = Path(..., description="UUID of the address to update"),
+    request_data: EndpointBaseRequestModel = Body(..., description="Request body"),
+):
+    """
+    Handle address update endpoint.
+
+    Args:
+        request: FastAPI request object
+        address_uu_id: UUID of the address to update
+        request_data: Request body containing updated address data
+
+    Returns:
+        DictJsonResponse: Response containing updated address info
+    """
+    auth_dict = address_update.auth
+    return DictJsonResponse(
+        data={
+            "address_uu_id": address_uu_id,
+            "data": request_data.root,
+            "request": str(request.headers),
+            "request_url": str(request.url),
+            "request_base_url": str(request.base_url),
+        }
+    )
+
+
+prefix = "/address"
+
+
+# Address Router Configuration
+ADDRESS_CONFIG = RouteFactoryConfig(
+    name="address",
+    prefix=prefix,
+    tags=["Address"],
+    include_in_schema=True,
+    endpoints=[
+        EndpointFactoryConfig(
+            url_prefix=prefix,
+            url_endpoint="/list",
+            url_of_endpoint=f"{prefix}/list",
+            endpoint="/list",
+            method="POST",
+            summary="List Active/Delete/Confirm Address",
+            description="List Active/Delete/Confirm Address",
+            is_auth_required=True,
+            is_event_required=True,
+            endpoint_function=address_list,
+        ),
+        EndpointFactoryConfig(
+            url_prefix=prefix,
+            url_endpoint="/create",
+            url_of_endpoint=f"{prefix}/create",
+            endpoint="/create",
+            method="POST",
+            summary="Create Address with given auth levels",
+            description="Create Address with given auth levels",
+            is_auth_required=False,
+            is_event_required=False,
+            endpoint_function=address_create,
+        ),
+        EndpointFactoryConfig(
+            url_prefix=prefix,
+            url_endpoint="/{address_uu_id}",
+            url_of_endpoint="{prefix}/" + "{address_uu_id}",
+            endpoint="/{address_uu_id}",
+            method="PUT",
+            summary="Update Address with given auth levels",
+            description="Update Address with given auth levels",
+            is_auth_required=True,
+            is_event_required=True,
+            endpoint_function=address_update,
+        ),
+    ],
+).as_dict()

Events/AllEvents/validations/available/endpoints.py

@@ -0,0 +1,116 @@
+from typing import TYPE_CHECKING, Dict, Any, Union
+
+from ApiEvents.base_request_model import DictRequestModel, EndpointBaseRequestModel
+from ApiEvents.abstract_class import (
+    RouteFactoryConfig,
+    EndpointFactoryConfig,
+    endpoint_wrapper,
+)
+from ApiValidations.Custom.token_objects import EmployeeTokenObject, OccupantTokenObject
+from ErrorHandlers.Exceptions.api_exc import HTTPExceptionApi
+from ApiLibrary.common.line_number import get_line_number_for_error
+
+
+if TYPE_CHECKING:
+    from fastapi import Request, HTTPException, status, Body
+
+
+# Type aliases for common types
+prefix = "/available"
+
+
+async def check_endpoints_available(request: "Request") -> Dict[str, Any]:
+    """
+    Check if endpoints are available.
+    """
+    auth_dict = check_endpoints_available.auth
+    selection_of_user = None
+    if auth_dict.is_occupant:
+        selection_of_user = auth_dict.selected_occupant
+    else:
+        selection_of_user = auth_dict.selected_company
+    if not selection_of_user:
+        raise HTTPExceptionApi(
+            error_code="",
+            lang=auth_dict.lang,
+            loc=get_line_number_for_error(),
+            sys_msg="User selection not found",
+        )
+    return {"reachable_event_endpoints": selection_of_user.reachable_event_endpoints}
+
+
+async def check_endpoint_available(
+    request: "Request",
+    data: EndpointBaseRequestModel,
+) -> Dict[str, Any]:
+    """
+    Check if endpoints are available.
+    """
+    auth_dict = check_endpoint_available.auth
+    print("data", data)
+    data_dict = data.data
+    endpoint_asked = data_dict.get("endpoint", None)
+
+    if not endpoint_asked:
+        raise HTTPExceptionApi(
+            error_code="",
+            lang=auth_dict.lang,
+            loc=get_line_number_for_error(),
+            sys_msg="Endpoint not found",
+        )
+
+    selection_of_user = None
+    if auth_dict.is_occupant:
+        selection_of_user = auth_dict.selected_occupant
+    else:
+        selection_of_user = auth_dict.selected_company
+    if not selection_of_user:
+        raise HTTPExceptionApi(
+            error_code="",
+            lang=auth_dict.lang,
+            loc=get_line_number_for_error(),
+            sys_msg="User selection not found",
+        )
+
+    if endpoint_asked not in selection_of_user.reachable_event_endpoints:
+        raise HTTPExceptionApi(
+            error_code="",
+            lang=auth_dict.lang,
+            loc=get_line_number_for_error(),
+            sys_msg="Endpoint not found",
+        )
+    return {"endpoint": endpoint_asked, "status": "OK"}
+
+
+AVAILABLE_CONFIG = RouteFactoryConfig(
+    name="available_endpoints",
+    prefix=prefix,
+    tags=["Available Endpoints"],
+    include_in_schema=True,
+    endpoints=[
+        EndpointFactoryConfig(
+            url_prefix=prefix,
+            url_endpoint="/endpoints",
+            url_of_endpoint=f"{prefix}/endpoints",
+            endpoint="/endpoints",
+            method="POST",
+            summary="Retrieve all endpoints available for user",
+            description="",
+            is_auth_required=True,  # Needs token_dict
+            is_event_required=False,
+            endpoint_function=check_endpoints_available,
+        ),
+        EndpointFactoryConfig(
+            url_prefix=prefix,
+            url_endpoint="/endpoint",
+            url_of_endpoint=f"{prefix}/endpoint",
+            endpoint="/endpoint",
+            method="POST",
+            summary="Retrieve an endpoint available for user",
+            description="",
+            is_auth_required=True,  # Needs token_dict
+            is_event_required=False,
+            endpoint_function=check_endpoint_available,
+        ),
+    ],
+).as_dict()

Events/AllEvents/validations/available/models.py

@@ -0,0 +1,325 @@
+"""
+ request models.
+"""
+
+from typing import TYPE_CHECKING, Dict, Any, Literal, Optional, TypedDict, Union
+from pydantic import BaseModel, Field, model_validator, RootModel, ConfigDict
+from ApiEvents.base_request_model import BaseRequestModel, DictRequestModel
+from ApiValidations.Custom.token_objects import EmployeeTokenObject, OccupantTokenObject
+from ApiValidations.Request.base_validations import ListOptions
+from ErrorHandlers.Exceptions.api_exc import HTTPExceptionApi
+from Schemas.identity.identity import (
+    AddressPostcode,
+    Addresses,
+    RelationshipEmployee2PostCode,
+)
+
+
+if TYPE_CHECKING:
+    from fastapi import Request
+
+
+class AddressListEventMethods(MethodToEvent):
+
+    event_type = "SELECT"
+    event_description = "List Address records"
+    event_category = "Address"
+
+    __event_keys__ = {
+        "9c251d7d-da70-4d63-a72c-e69c26270442": "address_list_super_user",
+        "52afe375-dd95-4f4b-aaa2-4ec61bc6de52": "address_list_employee",
+    }
+    __event_validation__ = {
+        "9c251d7d-da70-4d63-a72c-e69c26270442": ListAddressResponse,
+        "52afe375-dd95-4f4b-aaa2-4ec61bc6de52": ListAddressResponse,
+    }
+
+    @classmethod
+    def address_list_super_user(
+        cls,
+        list_options: ListOptions,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        db = RelationshipEmployee2PostCode.new_session()
+        post_code_list = RelationshipEmployee2PostCode.filter_all(
+            RelationshipEmployee2PostCode.company_id
+            == token_dict.selected_company.company_id,
+            db=db,
+        ).data
+        post_code_id_list = [post_code.member_id for post_code in post_code_list]
+        if not post_code_id_list:
+            raise HTTPExceptionApi(
+                status_code=404,
+                detail="User has no post code registered. User can not list addresses.",
+            )
+        get_street_ids = [
+            street_id[0]
+            for street_id in AddressPostcode.select_only(
+                AddressPostcode.id.in_(post_code_id_list),
+                select_args=[AddressPostcode.street_id],
+                order_by=AddressPostcode.street_id.desc(),
+            ).data
+        ]
+        if not get_street_ids:
+            raise HTTPExceptionApi(
+                status_code=404,
+                detail="User has no street registered. User can not list addresses.",
+            )
+        Addresses.pre_query = Addresses.filter_all(
+            Addresses.street_id.in_(get_street_ids),
+        ).query
+        Addresses.filter_attr = list_options
+        records = Addresses.filter_all().data
+        return
+        # return AlchemyJsonResponse(
+        #     completed=True, message="List Address records", result=records
+        # )
+
+    @classmethod
+    def address_list_employee(
+        cls,
+        list_options: ListOptions,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        Addresses.filter_attr = list_options
+        Addresses.pre_query = Addresses.filter_all(
+            Addresses.street_id.in_(get_street_ids),
+        )
+        records = Addresses.filter_all().data
+        return
+        # return AlchemyJsonResponse(
+        #     completed=True, message="List Address records", result=records
+        # )
+
+
+class AddressCreateEventMethods(MethodToEvent):
+
+    event_type = "CREATE"
+    event_description = ""
+    event_category = ""
+
+    __event_keys__ = {
+        "ffdc445f-da10-4ce4-9531-d2bdb9a198ae": "create_address",
+    }
+    __event_validation__ = {
+        "ffdc445f-da10-4ce4-9531-d2bdb9a198ae": InsertAddress,
+    }
+
+    @classmethod
+    def create_address(
+        cls,
+        data: InsertAddress,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        post_code = AddressPostcode.filter_one(
+            AddressPostcode.uu_id == data.post_code_uu_id,
+        ).data
+        if not post_code:
+            raise HTTPExceptionApi(
+                status_code=404,
+                detail="Post code not found. User can not create address without post code.",
+            )
+
+        data_dict = data.excluded_dump()
+        data_dict["street_id"] = post_code.street_id
+        data_dict["street_uu_id"] = str(post_code.street_uu_id)
+        del data_dict["post_code_uu_id"]
+        address = Addresses.find_or_create(**data_dict)
+        address.save()
+        address.update(is_confirmed=True)
+        address.save()
+        return AlchemyJsonResponse(
+            completed=True,
+            message="Address created successfully",
+            result=address.get_dict(),
+        )
+
+
+class AddressSearchEventMethods(MethodToEvent):
+    """Event methods for searching addresses.
+
+    This class handles address search functionality including text search
+    and filtering.
+    """
+
+    event_type = "SEARCH"
+    event_description = "Search for addresses using text and filters"
+    event_category = "Address"
+
+    __event_keys__ = {
+        "e0ac1269-e9a7-4806-9962-219ac224b0d0": "search_address",
+    }
+    __event_validation__ = {
+        "e0ac1269-e9a7-4806-9962-219ac224b0d0": SearchAddress,
+    }
+
+    @classmethod
+    def _build_order_clause(
+        cls, filter_list: Dict[str, Any], schemas: List[str], filter_table: Any
+    ) -> Any:
+        """Build the ORDER BY clause for the query.
+
+        Args:
+            filter_list: Dictionary of filter options
+            schemas: List of available schema fields
+            filter_table: SQLAlchemy table to query
+
+        Returns:
+            SQLAlchemy order_by clause
+        """
+        # Default to ordering by UUID if field not in schema
+        if filter_list.get("order_field") not in schemas:
+            filter_list["order_field"] = "uu_id"
+        else:
+            # Extract table and field from order field
+            table_name, field_name = str(filter_list.get("order_field")).split(".")
+            filter_table = getattr(databases.sql_models, table_name)
+            filter_list["order_field"] = field_name
+
+        # Build order clause
+        field = getattr(filter_table, filter_list.get("order_field"))
+        return (
+            field.desc()
+            if str(filter_list.get("order_type"))[0] == "d"
+            else field.asc()
+        )
+
+    @classmethod
+    def _format_record(cls, record: Any, schemas: List[str]) -> Dict[str, str]:
+        """Format a database record into a dictionary.
+
+        Args:
+            record: Database record to format
+            schemas: List of schema fields
+
+        Returns:
+            Formatted record dictionary
+        """
+        result = {}
+        for index, schema in enumerate(schemas):
+            value = str(record[index])
+            # Special handling for UUID fields
+            if "uu_id" in value:
+                value = str(value)
+            result[schema] = value
+        return result
+
+    @classmethod
+    def search_address(
+        cls,
+        data: SearchAddress,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ) -> JSONResponse:
+        """Search for addresses using text search and filters.
+
+        Args:
+            data: Search parameters including text and filters
+            token_dict: Authentication token
+
+        Returns:
+            JSON response with search results
+
+        Raises:
+            HTTPExceptionApi: If search fails
+        """
+        try:
+            # Start performance measurement
+            start_time = perf_counter()
+
+            # Get initial query
+            search_result = AddressStreet.search_address_text(search_text=data.search)
+            if not search_result:
+                raise HTTPExceptionApi(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="No addresses found matching search criteria",
+                )
+
+            query = search_result.get("query")
+            schemas = search_result.get("schema")
+
+            # Apply filters
+            filter_list = data.list_options.dump()
+            filter_table = AddressStreet
+
+            # Build and apply order clause
+            order = cls._build_order_clause(filter_list, schemas, filter_table)
+
+            # Apply pagination
+            page_size = int(filter_list.get("size"))
+            offset = (int(filter_list.get("page")) - 1) * page_size
+
+            # Execute query
+            query = (
+                query.order_by(order)
+                .limit(page_size)
+                .offset(offset)
+                .populate_existing()
+            )
+            records = list(query.all())
+
+            # Format results
+            results = [cls._format_record(record, schemas) for record in records]
+
+            # Log performance
+            duration = perf_counter() - start_time
+            print(f"Address search completed in {duration:.3f}s")
+
+            return AlchemyJsonResponse(
+                completed=True, message="Address search results", result=results
+            )
+
+        except HTTPExceptionApi as e:
+            # Re-raise HTTP exceptions
+            raise e
+        except Exception as e:
+            # Log and wrap other errors
+            print(f"Address search error: {str(e)}")
+            raise HTTPExceptionApi(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to search addresses",
+            ) from e
+
+
+class AddressUpdateEventMethods(MethodToEvent):
+
+    event_type = "UPDATE"
+    event_description = ""
+    event_category = ""
+
+    __event_keys__ = {
+        "1f9c3a9c-e5bd-4dcd-9b9a-3742d7e03a27": "update_address",
+    }
+    __event_validation__ = {
+        "1f9c3a9c-e5bd-4dcd-9b9a-3742d7e03a27": UpdateAddress,
+    }
+
+    @classmethod
+    def update_address(
+        cls,
+        address_uu_id: str,
+        data: UpdateAddress,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        if isinstance(token_dict, EmployeeTokenObject):
+            address = Addresses.filter_one(
+                Addresses.uu_id == address_uu_id,
+            ).data
+            if not address:
+                raise HTTPExceptionApi(
+                    status_code=404,
+                    detail=f"Address not found. User can not update with given address uuid : {address_uu_id}",
+                )
+
+            data_dict = data.excluded_dump()
+            updated_address = address.update(**data_dict)
+            updated_address.save()
+            return AlchemyJsonResponse(
+                completed=True,
+                message="Address updated successfully",
+                result=updated_address.get_dict(),
+            )
+        elif isinstance(token_dict, OccupantTokenObject):
+            raise HTTPExceptionApi(
+                status_code=403,
+                detail="Occupant can not update address.",
+            )

Events/AllEvents/validations/validation/endpoints.py

@@ -0,0 +1,128 @@
+from typing import Dict, Any
+
+from .models import ValidationsPydantic
+from ErrorHandlers.Exceptions.api_exc import HTTPExceptionApi
+
+from .validation import (
+    ValidationsBoth,
+    ValidationsHeaders,
+    ValidationsValidations,
+)
+from ApiEvents.abstract_class import RouteFactoryConfig, EndpointFactoryConfig
+from ApiEvents.base_request_model import EndpointBaseRequestModel
+from ApiLibrary.common.line_number import get_line_number_for_error
+
+from Services.PostgresDb.Models.alchemy_response import DictJsonResponse
+from fastapi import Request, Path, Body
+
+from middleware.token_event_middleware import TokenEventMiddleware
+
+
+prefix = "/validation"
+
+
+@TokenEventMiddleware.validation_required
+async def validations_validations_select(
+    request: Request, data: EndpointBaseRequestModel
+) -> Dict[str, Any]:
+    """
+    Select validations.
+    """
+    wrapped_context = getattr(validations_validations_select, "__wrapped__", None)
+    auth_context = getattr(wrapped_context, "auth", None)
+    validation_code = getattr(
+        validations_validations_select, "validation_code", {"validation_code": None}
+    )
+    if not validation_code:
+        raise HTTPExceptionApi(
+            error_code="",
+            lang="en",
+            loc=get_line_number_for_error(),
+            sys_msg="Validation code not found",
+        )
+    validations_pydantic = ValidationsPydantic(
+        class_model=validation_code.get("class", None),
+        reachable_event_code=validation_code.get("reachable_event_code", None),
+        lang=getattr(auth_context, "lang", None),
+    )
+    validations_both = ValidationsBoth.retrieve_both_validations_and_headers(
+        validations_pydantic
+    )
+    return {"status": "OK", "validation_code": validation_code, **validations_both}
+
+
+@TokenEventMiddleware.validation_required
+async def validations_headers_select(
+    request: Request, data: EndpointBaseRequestModel
+) -> Dict[str, Any]:
+    """
+    Select headers.
+    """
+    ValidationsHeaders.retrieve_headers()
+    return {
+        "status": "OK",
+    }
+
+
+@TokenEventMiddleware.validation_required
+async def validations_validations_and_headers_select(
+    request: Request, data: EndpointBaseRequestModel
+) -> Dict[str, Any]:
+    """
+    Select validations and headers.
+    """
+    ValidationsBoth.retrieve_both_validations_and_headers()
+    return {
+        "status": "OK",
+    }
+
+
+VALIDATION_CONFIG_MAIN = RouteFactoryConfig(
+    name="validations",
+    prefix=prefix,
+    tags=["Validation"],
+    include_in_schema=True,
+    endpoints=[
+        EndpointFactoryConfig(
+            url_prefix=prefix,
+            url_endpoint="/select",
+            url_of_endpoint=f"{prefix}/validations/select",
+            endpoint="/select",
+            method="POST",
+            summary="Select company or occupant type",
+            description="Select company or occupant type",
+            is_auth_required=True,  # Needs token_dict
+            is_event_required=False,
+            endpoint_function=validations_validations_select,
+        ),
+        EndpointFactoryConfig(
+            url_prefix=prefix,
+            url_endpoint="/headers/select",
+            url_of_endpoint=f"{prefix}/headers/select",
+            endpoint="/headers/select",
+            method="POST",
+            summary="Select company or occupant type",
+            description="Select company or occupant type",
+            is_auth_required=True,  # Needs token_dict
+            is_event_required=False,
+            endpoint_function=validations_headers_select,
+        ),
+        EndpointFactoryConfig(
+            url_prefix=prefix,
+            url_endpoint="/both/select",
+            url_of_endpoint=f"{prefix}/validationsAndHeaders/select",
+            endpoint="/both/select",
+            method="POST",
+            summary="Select company or occupant type",
+            description="Select company or occupant type",
+            is_auth_required=True,  # Needs token_dict
+            is_event_required=False,
+            endpoint_function=validations_validations_and_headers_select,
+        ),
+    ],
+)
+VALIDATION_CONFIG = VALIDATION_CONFIG_MAIN.as_dict()
+
+VALIDATION_ENDPOINTS = [
+    endpoint.url_of_endpoint for endpoint in VALIDATION_CONFIG_MAIN.endpoints
+]

Events/AllEvents/validations/validation/models.py

@@ -0,0 +1,30 @@
+"""
+Validation records request and response models.
+"""
+
+from typing import TYPE_CHECKING, Dict, Any
+from pydantic import BaseModel, Field, RootModel
+from ApiEvents.base_request_model import BaseRequestModel
+
+if TYPE_CHECKING:
+    from ApiValidations.Request import (
+        ListOptions,
+    )
+
+
+class ValidationsPydantic(BaseModel):
+    class_model: str
+    reachable_event_code: str
+    lang: str
+
+
+class InsertValidationRecordRequestModel(BaseRequestModel):
+    pass
+
+
+class UpdateValidationRecordRequestModel(BaseRequestModel):
+    pass
+
+
+class ListOptionsValidationRecordRequestModel(BaseRequestModel):
+    pass

Events/AllEvents/validations/validation/validation.py

@@ -0,0 +1,138 @@
+"""
+Validation request models.
+"""
+
+from typing import TYPE_CHECKING, Dict, Any
+
+from ApiEvents.abstract_class import MethodToEvent
+from ApiLibrary.common.line_number import get_line_number_for_error
+from ApiValidations.Custom.validation_response import ValidationModel, ValidationParser
+
+from ErrorHandlers.Exceptions.api_exc import HTTPExceptionApi
+from .models import ValidationsPydantic
+
+
+class AllModelsImport:
+
+    @classmethod
+    def import_all_models(cls):
+        from ApiEvents.events.account.account_records import (
+            AccountListEventMethod,
+            AccountUpdateEventMethod,
+            AccountCreateEventMethod,
+        )
+        from ApiEvents.events.address.address import (
+            AddressListEventMethod,
+            AddressUpdateEventMethod,
+            AddressCreateEventMethod,
+            AddressSearchEventMethod,
+        )
+        return dict(
+            AccountListEventMethod=AccountListEventMethod,
+            AccountUpdateEventMethod=AccountUpdateEventMethod,
+            AccountCreateEventMethod=AccountCreateEventMethod,
+            AddressListEventMethod=AddressListEventMethod,
+            AddressUpdateEventMethod=AddressUpdateEventMethod,
+            AddressCreateEventMethod=AddressCreateEventMethod,
+            AddressSearchEventMethod=AddressSearchEventMethod,
+        )
+
+
+class ValidationsBoth(MethodToEvent):
+
+    @classmethod
+    def retrieve_both_validations_and_headers(cls, event: ValidationsPydantic) -> Dict[str, Any]:
+        EVENT_MODELS = AllModelsImport.import_all_models()
+        return_single_model = EVENT_MODELS.get(event.class_model, None)
+        # event_class_validation = getattr(return_single_model, "__event_validation__", None)
+        if not return_single_model:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="Validation code not found",
+            )
+        response_model = return_single_model.retrieve_event_response_model(event.reachable_event_code)
+        language_model_all = return_single_model.retrieve_language_parameters(
+            function_code=event.reachable_event_code, language=event.lang
+        )
+        language_model = language_model_all.get("language_model", None)
+        language_models = language_model_all.get("language_models", None)
+
+        validation = ValidationModel(response_model, language_model, language_models)
+        """
+            Headers: Headers which is merged with response model && language models of event 
+            Validation: Validation of event which is merged with response model && language models of event
+        """
+        return {
+            "headers": validation.headers,
+            "validation": validation.validation,
+            # "language_models": language_model_all,
+        }
+
+
+class ValidationsValidations(MethodToEvent):
+
+    @classmethod
+    def retrieve_validations(cls, event: ValidationsPydantic) -> Dict[str, Any]:
+        EVENT_MODELS = AllModelsImport.import_all_models()
+        return_single_model = EVENT_MODELS.get(event.class_model, None)
+        # event_class_validation = getattr(return_single_model, "__event_validation__", None)
+        if not return_single_model:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="Validation code not found",
+            )
+        response_model = return_single_model.retrieve_event_response_model(event.reachable_event_code)
+        language_model_all = return_single_model.retrieve_language_parameters(
+            function_code=event.reachable_event_code, language=event.lang
+        )
+        language_model = language_model_all.get("language_model", None)
+        language_models = language_model_all.get("language_models", None)
+
+        validation = ValidationModel(response_model, language_model, language_models)
+        """
+            Headers: Headers which is merged with response model && language models of event 
+            Validation: Validation of event which is merged with response model && language models of event
+        """
+        return {
+            "validation": validation.validation,
+            # "headers": validation.headers,
+            # "language_models": language_model_all,
+        }
+
+
+class ValidationsHeaders(MethodToEvent):
+
+    @classmethod
+    def retrieve_headers(cls, event: ValidationsPydantic
+) -> Dict[str, Any]:
+        EVENT_MODELS = AllModelsImport.import_all_models()
+        return_single_model = EVENT_MODELS.get(event.class_model, None)
+        # event_class_validation = getattr(return_single_model, "__event_validation__", None)
+        if not return_single_model:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="Validation code not found",
+            )
+        response_model = return_single_model.retrieve_event_response_model(event.reachable_event_code)
+        language_model_all = return_single_model.retrieve_language_parameters(
+            function_code=event.reachable_event_code, language=event.lang
+        )
+        language_model = language_model_all.get("language_model", None)
+        language_models = language_model_all.get("language_models", None)
+
+        validation = ValidationModel(response_model, language_model, language_models)
+        """
+            Headers: Headers which is merged with response model && language models of event 
+            Validation: Validation of event which is merged with response model && language models of event
+        """
+        return {
+            "headers": validation.headers,
+            # "validation": validation.validation,
+            # "language_models": language_model_all,
+        }