mongo updated

ApiServices/EventService/routers/__init__.py

@@ -1 +1,101 @@
-__all__ = []
+from .account.router import account_records_router
+from .people.router import people_router
+from .users.router import user_route
+
+from .company.company.router import company_route
+from .company.department.router import department_route
+from .company.duty.router import duty_route
+from .company.duties.router import duties_route
+
+from .building.build.router import build_route
+from .building.buildparts.router import build_parts_route
+from .building.buildarea.router import build_area_route
+from .building.buildsites.router import build_sites_route
+from .building.buildtypes.router import build_types_route
+from .building.livingspaces.router import build_living_space
+
+from .decision_book.decision_book.router import build_decision_book_route
+
+from .decision_book.decision_book_person.router import (
+    build_decision_book_people_route,
+)
+from .decision_book.decision_book_items.router import (
+    build_decision_book_items_route,
+)
+from .project_decision_book.project_decision_book.router import (
+    build_project_decision_book_route,
+)
+from .project_decision_book.project_decision_book_person.router import (
+    build_project_decision_book_person_route,
+)
+from .api.router import internal_route
+from .events.events.router import event_route
+from .company.staff.router import staff_route
+from .company.employee.router import employee_route
+
+from .events.events.bind_events_router import bind_events_route
+
+from .events.modules.router import modules_route
+from .events.modules.bind_events_router import bind_modules_route
+
+from .events.services.bind_services_router import bind_services_route
+from .events.services.router import services_route
+
+from .rules.router import endpoint_restriction_route
+from .address.address.router import address_router
+from .address.post_code.router import post_code_router
+from .application.enums_and_drops.router import enums_route
+from .application.occupants.router import occupant_types_route
+from .decision_book.decision_book_invitations.router import (
+    build_decision_book_invitations,
+)
+from .decision_book.project_decision_book.router import (
+    build_decision_book_project_route,
+)
+from .decision_book.project_decision_book_items.router import (
+    build_decision_book_project_items_route,
+)
+from .decision_book.project_decision_book_person.router import (
+    build_decision_book_project_people_route,
+)
+from .validations.router import validations_route
+
+__all__ = [
+    "account_records_router",
+    "enums_route",
+    "occupant_types_route",
+    "internal_route",
+    "address_router",
+    "post_code_router",
+    "duty_route",
+    "duties_route",
+    "people_router",
+    "user_route",
+    "company_route",
+    "department_route",
+    "build_route",
+    "build_parts_route",
+    "build_sites_route",
+    "build_area_route",
+    "build_living_space",
+    "build_decision_book_route",
+    "build_decision_book_people_route",
+    "build_decision_book_items_route",
+    "build_project_decision_book_route",
+    "staff_route",
+    "employee_route",
+    "build_types_route",
+    "bind_events_route",
+    "event_route",
+    "modules_route",
+    "bind_services_route",
+    "bind_modules_route",
+    "services_route",
+    "build_project_decision_book_person_route",
+    "endpoint_restriction_route",
+    "build_decision_book_invitations",
+    "build_decision_book_project_route",
+    "build_decision_book_project_items_route",
+    "build_decision_book_project_people_route",
+    "validations_route",
+]

ApiServices/EventService/routers/account/router.py

@@ -0,0 +1,57 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertAccountRecord,
+    UpdateAccountRecord,
+    SearchAddress,
+    ListOptions,
+    PatchRecord,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+account_records_router = APIRouter(prefix="/account/records", tags=["Account Records"])
+account_records_router.include_router(account_records_router, include_in_schema=True)
+
+
+@account_records_router.post(path="/list", summary="List Active/Delete/Confirm Address")
+def address_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@account_records_router.post(
+    path="/create", summary="Create Address with given auth levels"
+)
+def address_create(request: Request, data: InsertAccountRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@account_records_router.post(
+    path="/search", summary="Search Address with given auth levels"
+)
+def address_search(request: Request, data: SearchAddress):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@account_records_router.post(
+    path="/update/{address_uu_id}", summary="Update Address with given auth levels"
+)
+def address_update(request: Request, address_uu_id: str, data: UpdateAccountRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, address_uu_id=address_uu_id, token_dict=token_dict
+    )
+
+
+@account_records_router.patch(
+    path="/patch/{address_uu_id}", summary="Update Address Active/Delete/Confirm"
+)
+def address_patch(request: Request, address_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, address_uu_id=address_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/address/address/router.py

@@ -0,0 +1,54 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertAddress,
+    UpdateAddress,
+    SearchAddress,
+    ListOptions,
+    PatchRecord,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+
+address_router = APIRouter(prefix="/address", tags=["Address"])
+address_router.include_router(address_router, include_in_schema=True)
+
+
+@address_router.post(path="/list", summary="List Active/Delete/Confirm Address")
+def address_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@address_router.post(path="/create", summary="Create Address with given auth levels")
+def address_create(request: Request, data: InsertAddress):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@address_router.post(path="/search", summary="Search Address with given auth levels")
+def address_search(request: Request, data: SearchAddress):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@address_router.post(
+    path="/update/{address_uu_id}", summary="Update Address with given auth levels"
+)
+def address_update(request: Request, address_uu_id: str, data: UpdateAddress):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, address_uu_id=address_uu_id, token_dict=token_dict
+    )
+
+
+@address_router.patch(
+    path="/patch/{address_uu_id}", summary="Update Address Active/Delete/Confirm"
+)
+def address_patch(request: Request, address_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, address_uu_id=address_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/address/post_code/router.py

@@ -0,0 +1,46 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertPostCode,
+    UpdatePostCode,
+    ListOptions,
+    PatchRecord,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+post_code_router = APIRouter(prefix="/postcode", tags=["Post Code"])
+post_code_router.include_router(post_code_router, include_in_schema=True)
+
+
+@post_code_router.post(path="/list", summary="List Active/Delete/Confirm PostCode")
+def post_code_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@post_code_router.post(path="/create", summary="Create PostCode with given auth levels")
+def post_code_create(request: Request, data: InsertPostCode):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@post_code_router.post(
+    path="/update/{post_code_uu_id}", summary="Update PostCode with given auth levels"
+)
+def post_code_update(request: Request, post_code_uu_id: str, data: UpdatePostCode):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, post_code_uu_id=post_code_uu_id, token_dict=token_dict
+    )
+
+
+@post_code_router.patch(
+    path="/patch/{post_code_uu_id}", summary="Update PostCode Active/Delete/Confirm"
+)
+def post_code_patch(request: Request, post_code_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, post_code_uu_id=post_code_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/api/router.py

@@ -0,0 +1,74 @@
+import json
+import typing
+import zlib
+from base64 import b64decode
+
+from fastapi import status
+from fastapi.routing import APIRouter
+from fastapi.responses import JSONResponse
+from fastapi.requests import Request
+
+from pydantic import BaseModel
+
+
+internal_route = APIRouter(prefix="/internal", tags=["Internal"])
+internal_route.include_router(internal_route, include_in_schema=False)
+
+
+# class ApiReceive(BaseModel):
+#     data: str
+#
+#
+# class BankReceive(BaseModel):
+#     import_file_name: str
+#     iban: str
+#     bank_date: str
+#     channel_branch: str
+#     currency: typing.Optional[str] = "TL"
+#     currency_value: float
+#     bank_balance: float
+#     additional_balance: float
+#     process_name: str
+#     process_type: str
+#     process_comment: str
+#     bank_reference_code: str
+# #
+#
+# @internal_route.post(
+#     path="/isbank/retreive",
+#     summary="Receive isbank xls service from mail reader service",
+# )
+# def is_bank_retrieve_account_records(request: Request, bank_data: ApiReceive):
+#     from databases import AccountRecords
+#
+#     data_dict = bank_data.model_dump()
+#     data_bulk = json.loads(zlib.decompress(b64decode(data_dict["data"])))
+#     print("data_bulk", data_bulk)
+#     new_record_list = []
+#     for data_keys in data_bulk:  # data_bulk is a dict
+#         for data_dict in data_bulk[data_keys]:  # data_bulk[data_keys] is a list
+#             data_dict["bank_balance"] = data_dict.pop("balance")
+#             data_dict["import_file_name"] = str(data_keys)
+#             print("data_dict before pyd", data_dict)
+#             data_dict = BankReceive(**data_dict).model_dump()
+#             print("data_dict after pyd", data_dict)
+#             if new_account_record := AccountRecords.find_or_create(**data_dict):
+#                 print("new_account_record.is_found", new_account_record.is_found)
+#                 if not new_account_record.is_found:
+#                     new_record_list.append(new_account_record.get_dict())
+#     if new_record_list:
+#         return JSONResponse(
+#             content={
+#                 "completed": True,
+#                 "message": "Create Bank Record",
+#                 "data": new_record_list,
+#             },
+#             status_code=status.HTTP_200_OK,
+#         )
+#     return JSONResponse(
+#         content={
+#             "completed": False,
+#             "message": "Record already exist or can not be created",
+#         },
+#         status_code=status.HTTP_406_NOT_ACCEPTABLE,
+#     )

ApiServices/EventService/routers/application/enums_and_drops/router.py

@@ -0,0 +1,98 @@
+from fastapi import status
+from fastapi.routing import APIRouter
+from fastapi.exceptions import HTTPException
+from fastapi.responses import JSONResponse
+
+from databases import ApiEnumDropdown
+from api_validations.validations_request import (
+    SingleEnumClassKey,
+    SingleEnumUUID,
+    SingleEnumOnlyClass,
+)
+
+
+enums_route = APIRouter(prefix="/enums", tags=["Enums and Dropdowns of API"])
+enums_route.include_router(enums_route, include_in_schema=False)
+
+
+@enums_route.post(path="/get/key", summary="Get single enum via key")
+def get_single_enum_via_key_and_class(data: SingleEnumClassKey):
+    enum = ApiEnumDropdown.query.filter(
+        ApiEnumDropdown.enum_class.ilike(data.class_name),
+        ApiEnumDropdown.key.ilike(data.key_name),
+    ).populate_existing()
+    if record := enum.first():
+        return JSONResponse(
+            content={
+                "completed": True,
+                "message": "Get single enum via key",
+                "data": record.get_enum_dict() if enum else None,
+            },
+            status_code=status.HTTP_200_OK,
+        )
+    raise HTTPException(
+        status_code=status.HTTP_404_NOT_FOUND,
+        detail="Enum not found",
+    )
+
+
+@enums_route.post(path="/get/uu_id", summary="Get single enum via uu_id")
+def get_single_enum_via_uuid(data: SingleEnumUUID):
+    enum = ApiEnumDropdown.query.filter(
+        ApiEnumDropdown.uu_id == data.uu_id
+    ).populate_existing()
+    if records := enum.first():
+        return JSONResponse(
+            content={
+                "completed": True,
+                "message": "Get single enum via uu_id",
+                "data": records.get_enum_dict(),
+            },
+            status_code=status.HTTP_200_OK,
+        )
+    raise HTTPException(
+        status_code=status.HTTP_404_NOT_FOUND,
+        detail="Enum not found",
+    )
+
+
+@enums_route.post(path="/list/class", summary="Get all enums via class")
+def list_all_enums_with_class(data: SingleEnumOnlyClass):
+    enums = ApiEnumDropdown.query.filter(
+        ApiEnumDropdown.enum_class.ilike(data.class_name or "")
+    ).populate_existing()
+    if records := enums.all():
+        records_list = [record.get_enum_dict() for record in records]
+        return JSONResponse(
+            content={
+                "completed": True,
+                "message": "Get all enums via class",
+                "count": len(records_list),
+                "data": records_list,
+            },
+            status_code=status.HTTP_200_OK,
+        )
+    raise HTTPException(
+        status_code=status.HTTP_404_NOT_FOUND,
+        detail="Enums not found",
+    )
+
+
+@enums_route.post(path="/list/all", summary="Get all enums")
+def list_all_enums():
+    enums = ApiEnumDropdown.query.filter().populate_existing()
+    if records := enums.all():
+        records_list = [record.get_enum_dict() for record in records]
+        return JSONResponse(
+            content={
+                "completed": True,
+                "count": len(records_list),
+                "message": "Get all enums",
+                "data": records_list,
+            },
+            status_code=status.HTTP_200_OK,
+        )
+    raise HTTPException(
+        status_code=status.HTTP_404_NOT_FOUND,
+        detail="Enums can not be listed",
+    )

ApiServices/EventService/routers/application/occupants/router.py

@@ -0,0 +1,58 @@
+from fastapi import status
+from fastapi.routing import APIRouter
+from fastapi.exceptions import HTTPException
+from fastapi.responses import JSONResponse
+
+from databases import OccupantTypes
+from api_validations.validations_request import (
+    SingleOccupantTypeClassKey,
+    SingleOccupantTypeUUID,
+)
+
+
+occupant_types_route = APIRouter(prefix="/occupant_types", tags=["Occupant Types"])
+occupant_types_route.include_router(occupant_types_route, include_in_schema=False)
+
+
+@occupant_types_route.post(
+    path="/get/code", summary="Get single occupant type via code"
+)
+def get_single_occupant_type_via_code(data: SingleOccupantTypeClassKey):
+    occupant_type = OccupantTypes.query.filter(
+        OccupantTypes.occupant_code.ilike(data.type_code)
+    ).populate_existing()
+    if record := occupant_type.first():
+        return JSONResponse(
+            content={
+                "completed": True,
+                "message": "Get single occupant type via code",
+                "data": record.get_dict() if record else None,
+            },
+            status_code=status.HTTP_200_OK,
+        )
+    raise HTTPException(
+        status_code=status.HTTP_404_NOT_FOUND,
+        detail="Occupant type not found",
+    )
+
+
+@occupant_types_route.post(
+    path="/get/uu_id", summary="Get single occupant type via uu_id"
+)
+def get_single_occupant_type_via_uuid(data: SingleOccupantTypeUUID):
+    occupant_type = OccupantTypes.query.filter(
+        OccupantTypes.uu_id == data.uu_id
+    ).populate_existing()
+    if records := occupant_type.first():
+        return JSONResponse(
+            content={
+                "completed": True,
+                "message": "Get single occupant type via uu_id",
+                "data": records.get_dict(),
+            },
+            status_code=status.HTTP_200_OK,
+        )
+    raise HTTPException(
+        status_code=status.HTTP_404_NOT_FOUND,
+        detail="Occupant type not found",
+    )

ApiServices/EventService/routers/building/buildarea/router.py

@@ -0,0 +1,49 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertBuildArea,
+    UpdateBuildArea,
+    PatchRecord,
+    ListOptions,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+
+build_area_route = APIRouter(prefix="/building/area", tags=["Building Area"])
+build_area_route.include_router(build_area_route, include_in_schema=True)
+
+
+@build_area_route.post(path="/list", summary="List Active/Delete/Confirm Build Parts")
+def build_area_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@build_area_route.post(
+    path="/create", summary="Create BuildParts with given auth levels"
+)
+def build_area_create(request: Request, data: InsertBuildArea):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_area_route.post(
+    path="/update/{build_uu_id}", summary="Update BuildParts with given auth levels"
+)
+def build_area_update(request: Request, build_uu_id: str, data: UpdateBuildArea):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, build_uu_id=build_uu_id, token_dict=token_dict
+    )
+
+
+@build_area_route.patch(
+    path="/patch/{build_uu_id}", summary="Update Active/Delete/Confirm"
+)
+def build_area_patch(request: Request, build_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, build_uu_id=build_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/building/buildparts/router.py

@@ -0,0 +1,50 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertBuildParts,
+    UpdateBuildParts,
+    PatchRecord,
+    ListOptions,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_parts_route = APIRouter(prefix="/building/parts", tags=["Building Parts"])
+build_parts_route.include_router(build_parts_route, include_in_schema=True)
+
+
+@build_parts_route.post(path="/list", summary="List Active/Delete/Confirm Build Parts")
+def building_build_part_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@build_parts_route.post(
+    path="/create", summary="Create Build Parts with given auth levels"
+)
+def building_build_part_create(request: Request, data: InsertBuildParts):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_parts_route.post(
+    path="/update/{build_uu_id}", summary="Update Build Parts with given auth levels"
+)
+def building_build_part_update(
+    request: Request, build_uu_id: str, data: UpdateBuildParts
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, build_uu_id=build_uu_id, token_dict=token_dict
+    )
+
+
+@build_parts_route.patch(
+    path="/patch/{build_uu_id}", summary="Update Active/Delete/Confirm"
+)
+def building_build_part_patch(request: Request, build_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, build_uu_id=build_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/building/buildsites/router.py

@@ -0,0 +1,48 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    PatchRecord,
+    ListOptions,
+    InsertBuildSites,
+    UpdateBuildSites,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_sites_route = APIRouter(prefix="/building/sites", tags=["Building Sites"])
+build_sites_route.include_router(build_sites_route, include_in_schema=True)
+
+
+@build_sites_route.post(path="/list", summary="List Active/Delete/Confirm Build Parts")
+def building_sites_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@build_sites_route.post(
+    path="/create", summary="Create Build Sites with given auth levels"
+)
+def building_sites_create(request: Request, data: InsertBuildSites):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_sites_route.post(
+    path="/update/{build_uu_id}", summary="Update Build Sites with given auth levels"
+)
+def building_sites_update(request: Request, build_uu_id: str, data: UpdateBuildSites):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, build_uu_id=build_uu_id, token_dict=token_dict
+    )
+
+
+@build_sites_route.patch(
+    path="/patch/{build_uu_id}", summary="Update Active/Delete/Confirm"
+)
+def building_sites_patch(request: Request, build_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, build_uu_id=build_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/building/buildtypes/router.py

@@ -0,0 +1,48 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertBuildTypes,
+    UpdateBuildTypes,
+    PatchRecord,
+    ListOptions,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_types_route = APIRouter(prefix="/building/types", tags=["Types"])
+build_types_route.include_router(build_types_route, include_in_schema=True)
+
+
+@build_types_route.post(path="/list", summary="List Active/Delete/Confirm Build Parts")
+def building_types_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@build_types_route.post(
+    path="/create", summary="Create BuildParts with given auth levels"
+)
+def building_types_create(request: Request, data: InsertBuildTypes):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_types_route.post(
+    path="/update/{build_uu_id}", summary="Update BuildParts with given auth levels"
+)
+def building_types_update(request: Request, build_uu_id: str, data: UpdateBuildTypes):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, build_uu_id=build_uu_id, token_dict=token_dict
+    )
+
+
+@build_types_route.patch(
+    path="/patch/{build_uu_id}", summary="Update Active/Delete/Confirm"
+)
+def building_types_patch(request: Request, build_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, build_uu_id=build_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/building/livingspaces/router.py

@@ -0,0 +1,53 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertBuildLivingSpace,
+    UpdateBuildLivingSpace,
+    PatchRecord,
+    ListOptions,
+)
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_living_space = APIRouter(prefix="/building/living_space", tags=["Living Space"])
+build_living_space.include_router(build_living_space, include_in_schema=True)
+
+
+@build_living_space.post(
+    path="/list", summary="List Active/Delete/Confirm Build Living Space"
+)
+def building_living_space_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@build_living_space.post(
+    path="/create", summary="Create Build Living Space with given auth levels"
+)
+def building_living_space_create(request: Request, data: InsertBuildLivingSpace):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_living_space.post(
+    path="/update/{build_uu_id}",
+    summary="Update Build Living Space with given auth levels",
+)
+def building_living_space_update(
+    request: Request, build_uu_id: str, data: UpdateBuildLivingSpace
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, build_uu_id=build_uu_id, token_dict=token_dict
+    )
+
+
+@build_living_space.patch(
+    path="/patch/{build_uu_id}",
+    summary="Update Build Living Space with given auth levels",
+)
+def building_living_space_patch(request: Request, build_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, build_uu_id=build_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/company/company/router.py

@@ -0,0 +1,46 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertCompany,
+    UpdateCompany,
+    PatchRecord,
+    ListOptions,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+company_route = APIRouter(prefix="/company", tags=["Company"])
+company_route.include_router(company_route, include_in_schema=True)
+
+
+@company_route.post(path="/list", summary="List Active/Delete/Confirm Companies")
+def company_company_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@company_route.post(path="/create", summary="Create Company with given auth levels")
+def company_company_create(request: Request, data: InsertCompany):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@company_route.post(
+    path="/update/{company_uu_id}", summary="Update Company with given auth levels"
+)
+def company_company_update(request: Request, company_uu_id: str, data: UpdateCompany):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, company_uu_id=company_uu_id, token_dict=token_dict
+    )
+
+
+@company_route.patch(
+    path="/patch/{company_uu_id}", summary="Update Active/Delete/Confirm"
+)
+def company_company_patch(request: Request, company_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, company_uu_id=company_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/company/department/router.py

@@ -0,0 +1,47 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    DepartmentsPydantic,
+    PatchRecord,
+    ListOptions,
+)
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+
+department_route = APIRouter(prefix="/department", tags=["Departments"])
+department_route.include_router(department_route, include_in_schema=True)
+
+
+@department_route.post(path="/list", summary="List Active/Delete/Confirm Departments")
+def company_department_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@department_route.post(path="/create", summary="Create Company with given auth levels")
+def company_department_create(request: Request, data: DepartmentsPydantic):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@department_route.post(
+    path="/update/{company_uu_id}", summary="Update Company with given auth levels"
+)
+def company_department_update(
+    request: Request, company_uu_id: str, data: DepartmentsPydantic
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        company_uu_id=company_uu_id, data=data, token_dict=token_dict
+    )
+
+
+@department_route.patch(
+    path="/patch/{company_uu_id}", summary="Patch Company with given auth levels"
+)
+def company_department_patch(request: Request, company_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        company_uu_id=company_uu_id, data=data, token_dict=token_dict
+    )

ApiServices/EventService/routers/company/duties/router.py

@@ -0,0 +1,54 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertDuties,
+    UpdateDuties,
+    SelectDuties,
+    PatchRecord,
+    ListOptions,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+
+duties_route = APIRouter(prefix="/duties", tags=["Duties"])
+duties_route.include_router(duties_route, include_in_schema=True)
+
+
+@duties_route.post(path="/list", summary="List Active/Delete/Confirm Duties")
+def company_duties_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@duties_route.post(path="/get_by_duty_uuid", summary="Get Single Duty by Duty UUID")
+def company_duties_get_by_duty_uuid(request: Request, data: SelectDuties):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@duties_route.post(path="/create", summary="Create Duties with given auth levels")
+def company_duties_create(request: Request, data: InsertDuties):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@duties_route.post(
+    path="/update/{duties_uu_id}", summary="Update Duties with given auth levels"
+)
+def company_duties_update(request: Request, duties_uu_id: str, data: UpdateDuties):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, duties_uu_id=duties_uu_id, token_dict=token_dict
+    )
+
+
+@duties_route.patch(
+    path="/patch/{duties_uu_id}", summary="Patch Duties with given auth levels"
+)
+def company_duties_patch(request: Request, duties_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, duties_uu_id=duties_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/company/duty/router.py

@@ -0,0 +1,44 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertCompanyDuty,
+    PatchRecord,
+    ListOptions,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+
+duty_route = APIRouter(prefix="/duty", tags=["Duty"])
+duty_route.include_router(duty_route, include_in_schema=True)
+
+
+@duty_route.post(path="/list", summary="List Active/Delete/Confirm Duty")
+def company_duty_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@duty_route.post(path="/create", summary="Create Company with given auth levels")
+def company_duty_create(request: Request, data: InsertCompanyDuty):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@duty_route.post(
+    path="/update/{company_uu_id}", summary="Update Company with given auth levels"
+)
+def company_duty_update(request: Request, company_uu_id: str, data):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, company_uu_id=company_uu_id, token_dict=token_dict
+    )
+
+
+@duty_route.patch(path="/patch/{company_uu_id}", summary="Update Active/Delete/Confirm")
+def company_duty_patch(request: Request, company_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, company_uu_id=company_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/company/employee/router.py

@@ -0,0 +1,59 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertEmployees,
+    UnBindEmployees2People,
+    BindEmployees2People,
+    PatchRecord,
+    ListOptions,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+employee_route = APIRouter(prefix="/employee", tags=["Employee"])
+employee_route.include_router(employee_route, include_in_schema=True)
+
+
+@employee_route.post(path="/list", summary="List Active/Delete/Confirm Staff")
+def company_employee_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@employee_route.post(path="/create", summary="Create Employee with given auth levels")
+def company_employee_create(request: Request, data: InsertEmployees):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@employee_route.post(
+    path="/update/{employee_uu_id}", summary="Update Employee with given auth levels"
+)
+def company_employee_update(request: Request, employee_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, employee_uu_id=employee_uu_id, token_dict=token_dict
+    )
+
+
+@employee_route.patch(
+    path="/patch/{employee_uu_id}", summary="Update Active/Delete/Confirm"
+)
+def company_employee_patch(request: Request, employee_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, employee_uu_id=employee_uu_id, token_dict=token_dict
+    )
+
+
+@employee_route.post(path="/employ", summary="Employ Employee with given auth levels")
+def company_employee_employ(request: Request, data: BindEmployees2People):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@employee_route.post(path="/fire", summary="UnEmploy Employee with given auth levels")
+def company_employee_fire(request: Request, data: UnBindEmployees2People):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)

ApiServices/EventService/routers/company/staff/router.py

@@ -0,0 +1,50 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertStaff,
+    SelectStaff,
+    PatchRecord,
+    ListOptions,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+staff_route = APIRouter(prefix="/staff", tags=["Staff"])
+staff_route.include_router(staff_route, include_in_schema=True)
+
+
+@staff_route.post(path="/list", summary="List Active/Delete/Confirm Staff")
+def company_staff_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@staff_route.post(path="/get_by_duties_uu_id", summary="Get Staff by UUID")
+def company_staff_get_by_uu_id(request: Request, data: SelectStaff):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@staff_route.post(path="/create", summary="Create Staff with given auth levels")
+def company_staff_create(request: Request, data: InsertStaff):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@staff_route.post(
+    path="/update/{staff_uu_id}", summary="Update Staff with given auth levels"
+)
+def company_staff_update(request: Request, staff_uu_id: str, data):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, staff_uu_id=staff_uu_id, token_dict=token_dict
+    )
+
+
+@staff_route.patch(path="/patch/{staff_uu_id}", summary="Update Active/Delete/Confirm")
+def company_staff_patch(request: Request, staff_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, staff_uu_id=staff_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/decision_book/decision_book/router.py

@@ -0,0 +1,88 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertDecisionBook,
+    UpdateDecisionBook,
+    DecisionBookDecisionBookInvitations,
+    PatchRecord,
+    ListOptions,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_decision_book_route = APIRouter(
+    prefix="/build/decision_book", tags=["Decision Book"]
+)
+build_decision_book_route.include_router(
+    build_decision_book_route, include_in_schema=True
+)
+
+
+@build_decision_book_route.post(
+    path="/list", summary="List Active/Delete/Confirm Build Decision Book"
+)
+def build_decision_book_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@build_decision_book_route.post(
+    path="/create", summary="Create Build Decision Book with given auth levels"
+)
+def build_decision_book_create(request: Request, data: InsertDecisionBook):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_route.post(
+    path="/approval", summary="Approve Build Decision Book with given auth levels"
+)
+def build_decision_book_approval(request: Request, data):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_route.post(
+    path="/update/{book_uu_id}",
+    summary="Update Build Decision Book with given auth levels",
+)
+def build_decision_book_update(
+    request: Request, book_uu_id: str, data: UpdateDecisionBook
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_route.patch(
+    path="/patch/{book_uu_id}", summary="Update Active/Delete/Confirm"
+)
+def build_decision_book_patch(request: Request, book_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_route.post(
+    path="/invite/list", summary="List Build Decision Book Invitations"
+)
+def build_decision_book_invite(request: Request, data: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=data, token_dict=token_dict)
+
+
+@build_decision_book_route.post(
+    path="/invite/create", summary="Create Build Decision Book Invitations"
+)
+def build_decision_book_invite_create(
+    request: Request, data: DecisionBookDecisionBookInvitations
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_route.post(
+    path="/invite/update", summary="Update Build Decision Book Invitations"
+)
+def build_decision_book_invite_update(request: Request, data):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)

ApiServices/EventService/routers/decision_book/decision_book_invitations/router.py

@@ -0,0 +1,37 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    DecisionBookDecisionBookInvitationsAttend,
+    DecisionBookDecisionBookInvitationsAssign,
+    PatchRecord,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_decision_book_invitations = APIRouter(
+    prefix="/build/decision_book/invitations", tags=["Decision Book Invitations"]
+)
+build_decision_book_invitations.include_router(
+    build_decision_book_invitations, include_in_schema=True
+)
+
+
+@build_decision_book_invitations.post(
+    path="/attend", summary="Decision Book Invitations Attend"
+)
+def build_decision_book_invitations_attend(
+    request: Request, data: DecisionBookDecisionBookInvitationsAttend
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_invitations.post(
+    path="/assign", summary="Decision Book Invitations Assign"
+)
+def build_decision_book_invitations_assign(
+    request: Request, data: DecisionBookDecisionBookInvitationsAssign
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)

ApiServices/EventService/routers/decision_book/decision_book_items/router.py

@@ -0,0 +1,61 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertBuildDecisionBookItems,
+    UpdateBuildDecisionBookItems,
+    ListDecisionBook,
+    PatchRecord,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_decision_book_items_route = APIRouter(
+    prefix="/build/decision_book/items", tags=["Decision Book Items"]
+)
+build_decision_book_items_route.include_router(
+    build_decision_book_items_route, include_in_schema=True
+)
+
+
+@build_decision_book_items_route.post(
+    path="/list", summary="List Active/Delete/Confirm Build Decision Book Items"
+)
+def build_decision_book_items_list(request: Request, data: ListDecisionBook):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_items_route.post(
+    path="/create", summary="Create Build Items Decision Book with given auth levels"
+)
+def build_decision_book_items_create(
+    request: Request, data: InsertBuildDecisionBookItems
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_items_route.post(
+    path="/update/{book_uu_id}",
+    summary="Update Build Decision Book Items with given auth levels",
+)
+def build_decision_book_items_update(
+    request: Request, book_uu_id: str, data: UpdateBuildDecisionBookItems
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, book_uu_id=book_uu_id, token_dict=token_dict
+    )
+
+
+@build_decision_book_items_route.patch(
+    path="/patch/{book_uu_id}", summary="Update Active/Delete/Confirm"
+)
+def build_decision_book_items_patch(
+    request: Request, book_uu_id: str, data: PatchRecord
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, book_uu_id=book_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/decision_book/decision_book_person/router.py

@@ -0,0 +1,54 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertDecisionBook,
+    UpdateDecisionBook,
+    DecisionBookDecisionBookInvitationsAttend,
+    ListOptions,
+)
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_decision_book_people_route = APIRouter(
+    prefix="/build/decision_book/people", tags=["Decision Book People"]
+)
+build_decision_book_people_route.include_router(
+    build_decision_book_people_route, include_in_schema=True
+)
+
+
+@build_decision_book_people_route.post(
+    path="/list", summary="List Active/Delete/Confirm Build Decision Book People"
+)
+def build_decision_book_people_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@build_decision_book_people_route.post(
+    path="/add",
+    summary="Add people to Build Decision People Book with given auth levels",
+)
+def build_decision_book_people_add(request: Request, data: InsertDecisionBook):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_people_route.post(
+    path="/remove",
+    summary="Remove people from Build Decision Book People with given auth levels",
+)
+def build_decision_book_people_remove(request: Request, data: UpdateDecisionBook):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_people_route.post(
+    path="/attend",
+    summary="Attend to Build Decision Book Invitations with given auth levels",
+)
+def build_decision_book_invite_attend(
+    request: Request, data: DecisionBookDecisionBookInvitationsAttend
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)

ApiServices/EventService/routers/decision_book/project_decision_book/router.py

@@ -0,0 +1,60 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertBuildDecisionBookProjects,
+    UpdateBuildDecisionBookProjects,
+    ApprovalsBuildDecisionBookProjects,
+    ListOptions,
+)
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_decision_book_project_route = APIRouter(
+    prefix="/build/decision_book/project", tags=["Decision Book Project"]
+)
+build_decision_book_project_route.include_router(
+    build_decision_book_project_route, include_in_schema=True
+)
+
+
+@build_decision_book_project_route.post(
+    path="/list", summary="List Active/Delete/Confirm Build Decision Book People"
+)
+def build_decision_book_project_people_list(
+    request: Request, list_options: ListOptions
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@build_decision_book_project_route.post(
+    path="/create",
+    summary="Create Build Decision Book Project People with given auth levels",
+)
+def build_decision_book_project_people_create(
+    request: Request, data: InsertBuildDecisionBookProjects
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_project_route.post(
+    path="/update/{build_decision_book_project_id}",
+    summary="Add people to Build Decision People Book with given auth levels",
+)
+def build_decision_book_project_people_update(
+    request: Request, data: UpdateBuildDecisionBookProjects
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_project_route.post(
+    path="/approval",
+    summary="Approval people from Build Decision Book Project People with given auth levels",
+)
+def build_decision_book_project_invite_approval(
+    request: Request, data: ApprovalsBuildDecisionBookProjects
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)

ApiServices/EventService/routers/decision_book/project_decision_book_items/router.py

@@ -0,0 +1,71 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertBuildDecisionBookProjectItems,
+    UpdateBuildDecisionBookProjectItems,
+    ListOptions,
+)
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_decision_book_project_items_route = APIRouter(
+    prefix="/build/decision_book/project/items",
+    tags=["Decision Project Book Project Items"],
+)
+build_decision_book_project_items_route.include_router(
+    build_decision_book_project_items_route, include_in_schema=True
+)
+
+
+@build_decision_book_project_items_route.post(
+    path="/list",
+    summary="List Active/Delete/Confirm Decision Project Book Project Items",
+)
+def build_decision_book_project_people_items_list(
+    request: Request, list_options: ListOptions
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@build_decision_book_project_items_route.post(
+    path="/create",
+    summary="Create Build Decision Book Project People with given auth levels",
+)
+def build_decision_book_project_people_items_create(
+    request: Request, data: InsertBuildDecisionBookProjectItems
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_project_items_route.post(
+    path="/update/{build_decision_book_project_item_uu_id}",
+    summary="Add people to Decision Project Book Project Items with given auth levels",
+)
+def build_decision_book_project_people_items_update(
+    request: Request,
+    build_decision_book_project_item_uu_id: str,
+    data: UpdateBuildDecisionBookProjectItems,
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data,
+        build_decision_book_project_item_uu_id=build_decision_book_project_item_uu_id,
+        token_dict=token_dict,
+    )
+
+
+@build_decision_book_project_items_route.post(
+    path="/patch/{build_decision_book_project_item_uu_id}",
+    summary="Patch people from Decision Project Book Project Items with given auth levels",
+)
+def build_decision_book_project_people_items_patch(
+    request: Request, build_decision_book_project_item_uu_id: str, data
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data,
+        build_decision_book_project_item_uu_id=build_decision_book_project_item_uu_id,
+        token_dict=token_dict,
+    )

ApiServices/EventService/routers/decision_book/project_decision_book_person/router.py

@@ -0,0 +1,71 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertBuildDecisionBookProjectPerson,
+    UpdateBuildDecisionBookProjectPerson,
+    ListOptions,
+)
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_decision_book_project_people_route = APIRouter(
+    prefix="/build/decision_book/project/people", tags=["Decision Book Project People"]
+)
+build_decision_book_project_people_route.include_router(
+    build_decision_book_project_people_route, include_in_schema=True
+)
+
+
+@build_decision_book_project_people_route.post(
+    path="/list", summary="List Active/Delete/Confirm Build Decision Book People"
+)
+def build_decision_book_project_people_list(
+    request: Request, list_options: ListOptions
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@build_decision_book_project_people_route.post(
+    path="/create",
+    summary="Create Build Decision Book Project People with given auth levels",
+)
+def build_decision_book_project_people_create(
+    request: Request, data: InsertBuildDecisionBookProjectPerson
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_decision_book_project_people_route.post(
+    path="/update/{build_decision_book_project_person_uu_id}",
+    summary="Add people to Build Decision People Book with given auth levels",
+)
+def build_decision_book_project_people_update(
+    request: Request,
+    build_decision_book_project_person_uu_id: str,
+    data: UpdateBuildDecisionBookProjectPerson,
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data,
+        build_decision_book_project_person_uu_id=build_decision_book_project_person_uu_id,
+        token_dict=token_dict,
+    )
+
+
+@build_decision_book_project_people_route.post(
+    path="/patch/{build_decision_book_project_person_uu_id}",
+    summary="Patch people from Build Decision Book Project People with given auth levels",
+)
+def build_decision_book_project_people_patch(
+    request: Request,
+    build_decision_book_project_person_uu_id: str,
+    data: UpdateBuildDecisionBookProjectPerson,
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data,
+        build_decision_book_project_person_uu_id=build_decision_book_project_person_uu_id,
+        token_dict=token_dict,
+    )

ApiServices/EventService/routers/events/events/bind_events_router.py

@@ -0,0 +1,35 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+from api_validations.validations_request import (
+    RegisterEvents2Employee,
+    RegisterEvents2Occupant,
+    PatchRecord,
+)
+
+
+bind_events_route = APIRouter(prefix="/bind/events", tags=["Binds"])
+bind_events_route.include_router(bind_events_route, include_in_schema=True)
+
+
+@bind_events_route.post(path="/occupant", summary="Register Event to Occupant")
+def bind_events_occupant(request: Request, data: RegisterEvents2Occupant):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@bind_events_route.post(path="/employee", summary="Register Event to Employee")
+def bind_events_employee(request: Request, data: RegisterEvents2Employee):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@bind_events_route.patch(
+    path="/patch/{event_uu_id}", summary="Patch Bind Events with given auth levels"
+)
+def bind_events_patch(request: Request, event_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, event_uu_id=event_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/events/events/router.py

@@ -0,0 +1,18 @@
+from fastapi import Request
+from fastapi.routing import APIRouter
+
+from api_validations.validations_request import (
+    # CreateEvents,
+    ListOptions,
+)
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+
+event_route = APIRouter(prefix="/event", tags=["Events"])
+event_route.include_router(event_route, include_in_schema=True)
+
+
+@event_route.post(path="/list", summary="List Events")
+def events_list(request: Request, data: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)

ApiServices/EventService/routers/events/modules/bind_events_router.py

@@ -0,0 +1,35 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+from api_validations.validations_request import (
+    RegisterModules2Occupant,
+    RegisterModules2Employee,
+    PatchRecord,
+)
+
+
+bind_modules_route = APIRouter(prefix="/bind/modules", tags=["Binds"])
+bind_modules_route.include_router(bind_modules_route, include_in_schema=True)
+
+
+@bind_modules_route.post(path="/occupant", summary="Register Event to Occupant")
+def bind_events_occupant(request: Request, data: RegisterModules2Occupant):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@bind_modules_route.post(path="/employee", summary="Register Event to Employee")
+def bind_events_employee(request: Request, data: RegisterModules2Employee):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@bind_modules_route.patch(
+    path="/patch/{event_uu_id}", summary="Patch Bind Events with given auth levels"
+)
+def bind_events_patch(request: Request, event_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, event_uu_id=event_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/events/modules/router.py

@@ -0,0 +1,47 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    DepartmentsPydantic,
+    PatchRecord,
+    ListOptions,
+)
+
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+
+modules_route = APIRouter(prefix="/modules", tags=["Modules"])
+modules_route.include_router(modules_route, include_in_schema=True)
+
+
+@modules_route.post(path="/list", summary="List Active/Delete/Confirm Modules")
+def modules_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@modules_route.post(path="/create", summary="Create Modules with given auth levels")
+def modules_create(request: Request, data: DepartmentsPydantic):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@modules_route.post(
+    path="/update/{module_uu_id}", summary="Update Modules with given auth levels"
+)
+def modules_update(request: Request, module_uu_id: str, data: DepartmentsPydantic):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, module_uu_id=module_uu_id, token_dict=token_dict
+    )
+
+
+@modules_route.patch(
+    path="/patch/{module_uu_id}", summary="Patch Modules with given auth levels"
+)
+def modules_patch(request: Request, module_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, module_uu_id=module_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/events/services/bind_services_router.py

@@ -0,0 +1,24 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    RegisterServices2Employee,
+    RegisterServices2Occupant,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+bind_services_route = APIRouter(prefix="/bind/services", tags=["Binds"])
+bind_services_route.include_router(bind_services_route, include_in_schema=True)
+
+
+@bind_services_route.post(path="/occupant", summary="Bind Services to Occupant")
+def bind_services_occupant(request: Request, data: RegisterServices2Occupant):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@bind_services_route.post(path="/employee", summary="Bind Services to Employee")
+def bind_services_employee(request: Request, data: RegisterServices2Employee):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)

ApiServices/EventService/routers/events/services/router.py

@@ -0,0 +1,44 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    PatchRecord,
+    ListOptions,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+services_route = APIRouter(prefix="/services", tags=["Services"])
+services_route.include_router(services_route, include_in_schema=True)
+
+
+@services_route.post(path="/list", summary="List Active/Delete/Confirm Modules")
+def services_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@services_route.post(path="/create", summary="Create Modules with given auth levels")
+def services_create(request: Request, data):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@services_route.post(
+    path="/update/{service_uu_id}", summary="Update Modules with given auth levels"
+)
+def services_update(request: Request, service_uu_id: str, data):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, service_uu_id=service_uu_id, token_dict=token_dict
+    )
+
+
+@services_route.patch(
+    path="/patch/{service_uu_id}", summary="Patch Modules with given auth levels"
+)
+def services_patch(request: Request, service_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, service_uu_id=service_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/people/router.py

@@ -0,0 +1,44 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertPerson,
+    UpdateUsers,
+    PatchRecord,
+    ListOptions,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+people_router = APIRouter(prefix="/people", tags=["People"])
+people_router.include_router(people_router, include_in_schema=True)
+
+
+@people_router.post(path="/list", summary="List Active/Delete/Confirm People")
+def people_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@people_router.post(path="/create", summary="Create People with given auth levels")
+def people_create(request: Request, data: InsertPerson):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@people_router.post(
+    path="/update/{user_uu_id}", summary="Update People with given auth levels"
+)
+def people_update(request: Request, user_uu_id: str, data: UpdateUsers):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, user_uu_id=user_uu_id, token_dict=token_dict
+    )
+
+
+@people_router.patch(path="/patch/{user_uu_id}", summary="Update Active/Delete/Confirm")
+def people_patch(request: Request, user_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, user_uu_id=user_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/project_decision_book/project_decision_book/router.py

@@ -0,0 +1,58 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertBuildDecisionBookProjects,
+    UpdateBuildDecisionBookProjects,
+    PatchRecord,
+    ListOptions,
+)
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_project_decision_book_route = APIRouter(
+    prefix="/build/project/decision_book", tags=["Project Decision Book"]
+)
+build_project_decision_book_route.include_router(
+    build_project_decision_book_route, include_in_schema=True
+)
+
+
+@build_project_decision_book_route.post(
+    path="/list", summary="List Active/Delete/Confirm Project Build Decision Book"
+)
+def project_decision_book_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@build_project_decision_book_route.post(
+    path="/create", summary="Create Build Project Decision Book with given auth levels"
+)
+def project_decision_book_create(
+    request: Request, data: InsertBuildDecisionBookProjects
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_project_decision_book_route.post(
+    path="/update/{book_uu_id}",
+    summary="Update Project Build Decision Book with given auth levels",
+)
+def project_decision_book_update(
+    request: Request, book_uu_id: str, data: UpdateBuildDecisionBookProjects
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, book_uu_id=book_uu_id, token_dict=token_dict
+    )
+
+
+@build_project_decision_book_route.patch(
+    path="/patch/{book_uu_id}", summary="Update Active/Delete/Confirm"
+)
+def project_decision_book_patch(request: Request, book_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, book_uu_id=book_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/project_decision_book/project_decision_book_person/router.py

@@ -0,0 +1,58 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertDecisionBook,
+    UpdateDecisionBook,
+    PatchRecord,
+    ListOptions,
+)
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+build_project_decision_book_person_route = APIRouter(
+    prefix="/build/decision_book/person", tags=["Decision Book Person"]
+)
+build_project_decision_book_person_route.include_router(
+    build_project_decision_book_person_route, include_in_schema=True
+)
+
+
+@build_project_decision_book_person_route.post(
+    path="/list", summary="List Active/Delete/Confirm Build Decision Book"
+)
+def project_decision_book_person_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@build_project_decision_book_person_route.post(
+    path="/create", summary="Create Build Decision Book with given auth levels"
+)
+def project_decision_book_person_create(request: Request, data: InsertDecisionBook):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@build_project_decision_book_person_route.post(
+    path="/update/{book_uu_id}",
+    summary="Update Build Decision Book with given auth levels",
+)
+def project_decision_book_person_update(
+    request: Request, book_uu_id: str, data: UpdateDecisionBook
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, book_uu_id=book_uu_id, token_dict=token_dict
+    )
+
+
+@build_project_decision_book_person_route.patch(
+    path="/patch/{book_uu_id}", summary="Update Active/Delete/Confirm"
+)
+def project_decision_book_person_patch(
+    request: Request, book_uu_id: str, data: PatchRecord
+):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, book_uu_id=book_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/rules/router.py

@@ -0,0 +1,130 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_objects import OccupantTokenObject, EmployeeTokenObject
+from api_validations.validations_request import (
+    UpdateEndpointAccessList,
+    InsertEndpointAccess,
+    CheckEndpointAccess,
+)
+
+from databases import (
+    EndpointRestriction,
+    Event2Occupant,
+    Event2Employee,
+    Events,
+)
+from databases.sql_models.event.event import Services, Service2Events
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+
+endpoint_restriction_route = APIRouter(prefix="/access", tags=["Endpoint Access"])
+endpoint_restriction_route.include_router(
+    endpoint_restriction_route, include_in_schema=True
+)
+
+
+@endpoint_restriction_route.post(
+    path="/endpoint/restriction/create",
+    summary="Add extra restriction to endpoints list",
+)
+def endpoint_restriction_create(request: Request, data: InsertEndpointAccess):
+    token_dict = parse_token_object_to_dict(request=request)
+    return
+
+
+@endpoint_restriction_route.post(
+    path="/endpoint/update", summary="Update extra restriction to endpoints list"
+)
+def endpoint_restriction_update(request: Request, data: UpdateEndpointAccessList):
+    token_dict = parse_token_object_to_dict(request=request)
+    return
+
+
+@endpoint_restriction_route.post(
+    path="/endpoints/available", summary="List extra restriction to endpoints list"
+)
+def endpoint_restriction_list(request: Request):
+    token_dict, records = parse_token_object_to_dict(request=request), []
+    if isinstance(token_dict, OccupantTokenObject):
+        occupant_events = Event2Occupant.get_event_id_by_build_living_space_id(
+            build_living_space_id=token_dict.selected_occupant.living_space_id
+        )
+        events_list = Events.filter_all(Events.id.in_(occupant_events)).data
+        records = EndpointRestriction.filter_all(
+            EndpointRestriction.id.in_([event.endpoint_id for event in events_list])
+        ).data
+    elif isinstance(token_dict, EmployeeTokenObject):
+        employee_events = Event2Employee.get_event_id_by_employee_id(
+            employee_id=token_dict.selected_company.employee_id
+        )
+        events_list = Events.filter_all(Events.id.in_(employee_events)).data
+        records = EndpointRestriction.filter_all(
+            EndpointRestriction.id.in_([event.endpoint_id for event in events_list])
+        ).data
+    return dict(
+        completed=True,
+        message="Available endpoints are listed successfully",
+        result=[str(record.endpoint_name) for record in records],
+    )
+
+
+@endpoint_restriction_route.post(
+    path="/endpoint/available", summary="Check extra restriction to endpoint available"
+)
+def endpoint_restriction_available(request: Request, data: CheckEndpointAccess):
+    token_dict, records = parse_token_object_to_dict(request=request), []
+    endpoint = EndpointRestriction.filter_one(
+        EndpointRestriction.endpoint_name.ilike(f"%{data.endpoint}%"),
+        system=True,
+    ).data
+    if not endpoint:
+        EndpointRestriction.raise_http_exception(
+            status_code="HTTP_404_NOT_FOUND",
+            error_case="UNAUTHORIZED",
+            message="Only Occupant can see this data",
+            data={},
+        )
+    event = Events.filter_one(Events.endpoint_id == endpoint.id).data
+    service = Service2Events.filter_one(Service2Events.event_id == event.id).data
+    if isinstance(token_dict, OccupantTokenObject):
+        event_occupant = Event2Occupant.filter_one(
+            Event2Occupant.event_service_id == service.service_id,
+            Event2Occupant.build_living_space_id
+            == token_dict.selected_occupant.living_space_id,
+        ).data
+        if not event_occupant:
+            EndpointRestriction.raise_http_exception(
+                status_code="HTTP_404_NOT_FOUND",
+                error_case="UNAUTHORIZED",
+                message="This endpoint is not available for this occupant",
+                data={},
+            )
+        return dict(
+            completed=True,
+            message="Endpoint is available for this occupant",
+        )
+    elif isinstance(token_dict, EmployeeTokenObject):
+        event_employee = Event2Employee.filter_one(
+            Event2Employee.event_service_id == service.service_id,
+            Event2Employee.employee_id == token_dict.selected_company.employee_id,
+        ).data
+        if not event_employee:
+            EndpointRestriction.raise_http_exception(
+                status_code="HTTP_404_NOT_FOUND",
+                error_case="UNAUTHORIZED",
+                message="This endpoint is not available for this employee",
+                data={},
+            )
+        return dict(
+            completed=True,
+            message="Endpoint is available for this occupant",
+        )
+
+
+@endpoint_restriction_route.patch(
+    path="/endpoint/bind/patch", summary="Patch extra restriction to endpoints list"
+)
+def endpoint_restriction_patch(request: Request):
+    token_dict = parse_token_object_to_dict(request=request)
+    return

ApiServices/EventService/routers/users/router.py

@@ -0,0 +1,45 @@
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+
+from api_validations.validations_request import (
+    InsertUsers,
+    UpdateUsers,
+    PatchRecord,
+    ListOptions,
+)
+
+from ApiServices.api_handlers.auth_actions.token import parse_token_object_to_dict
+
+
+user_route = APIRouter(prefix="/user", tags=["User"])
+user_route.include_router(user_route, include_in_schema=True)
+
+
+@user_route.post(path="/list", summary="List Active/Delete/Confirm Users")
+def user_list(request: Request, list_options: ListOptions):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
+
+
+@user_route.post(path="/create", summary="Create User with given auth levels")
+def user_create(request: Request, data: InsertUsers):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(data=data, token_dict=token_dict)
+
+
+@user_route.post(
+    path="/update/{user_uu_id}", summary="Update User with given auth levels"
+)
+def user_update(request: Request, user_uu_id: str, data: UpdateUsers):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, user_uu_id=user_uu_id, token_dict=token_dict
+    )
+
+
+@user_route.patch(path="/patch/{user_uu_id}", summary="Update Active/Delete/Confirm")
+def user_patch(request: Request, user_uu_id: str, data: PatchRecord):
+    token_dict = parse_token_object_to_dict(request=request)
+    return token_dict.available_event(
+        data=data, user_uu_id=user_uu_id, token_dict=token_dict
+    )

ApiServices/EventService/routers/validations/router.py

@@ -0,0 +1,123 @@
+from fastapi import status
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+from fastapi.exceptions import HTTPException
+from api_validations.validations_request import (
+    EndpointValidation,
+)
+from pydantic import BaseModel
+
+
+validations_route = APIRouter(prefix="/validations", tags=["Validations"])
+validations_route.include_router(validations_route, include_in_schema=True)
+
+
+class EndpointValidationResponse(BaseModel):
+    language: str
+    headers: dict
+    validation: dict
+
+
+class ValidationParser:
+
+    def __init__(self, active_validation):
+        self.annotations = (
+            active_validation.__annotations__.items() if active_validation else None
+        )
+        self.schema = {}
+        self.parse()
+
+    def parse(self):
+        for key, value in self.annotations or {}:
+            field_type, required = "string", False
+            if str(value) == "<class 'str'>" or str(value) == "typing.Optional[str]":
+                field_type = "string"
+                required = not str(value) == "typing.Optional[str]"
+            elif str(value) == "<class 'int'>" or str(value) == "typing.Optional[int]":
+                field_type = "integer"
+                required = not str(value) == "typing.Optional[int]"
+            elif (
+                str(value) == "<class 'bool'>" or str(value) == "typing.Optional[bool]"
+            ):
+                field_type = "boolean"
+                required = not str(value) == "typing.Optional[bool]"
+            elif (
+                str(value) == "<class 'float'>"
+                or str(value) == "typing.Optional[float]"
+            ):
+                field_type = "float"
+                required = not str(value) == "typing.Optional[bool]"
+            elif (
+                str(value) == "<class 'datetime.datetime'>"
+                or str(value) == "typing.Optional[datetime.datetime]"
+            ):
+                field_type = "datetime"
+                required = not str(value) == "typing.Optional[datetime.datetime]"
+            self.schema[key] = {"type": field_type, "required": required}
+
+
+def retrieve_validation_from_class(selected_event, events):
+    event_function_class = getattr(selected_event, "function_class", None)
+    event_function_code = getattr(selected_event, "function_code", None)
+    function_class = getattr(events, event_function_class, None)
+    return function_class.__event_validation__.get(event_function_code, None)
+
+
+@validations_route.post(path="/endpoint", summary="Retrieve validation of endpoint")
+def user_list(request: Request, validation: EndpointValidation):
+    import api_events.events as events
+    from api_services.redis.functions import get_object_via_access_key
+    from databases import (
+        EndpointRestriction,
+        Events,
+    )
+
+    valid_token = get_object_via_access_key(request=request)
+    if not valid_token:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"No valid token found in the request.",
+        )
+    endpoint_active = EndpointRestriction.filter_one(
+        EndpointRestriction.endpoint_name.ilike(f"%{str(validation.endpoint)}%"),
+        system=True,
+    ).data
+    if not endpoint_active:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"This endpoint {str(validation.endpoint)} is not active for this user, please contact your responsible company for further information.",
+        )
+    if valid_token.user_type == 1 and not valid_token.selected_company:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Selected company is not found in the token object.",
+        )
+    elif valid_token.user_type == 2 and not valid_token.selected_occupant:
+        raise HTTPException(
+            status_code=status.HTTP_418_IM_A_TEAPOT,
+            detail="Selected occupant is not found in the token object.",
+        )
+    selected_event = Events.filter_one(
+        Events.endpoint_id == endpoint_active.id,
+        Events.id.in_(valid_token.selected_company.reachable_event_list_id),
+    ).data
+    if not selected_event:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="This endpoint requires event validation. Please contact your responsible company to use this event.",
+        )
+    active_validation = retrieve_validation_from_class(selected_event, events)
+    if not active_validation:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="No validation found for this endpoint.",
+        )
+    headers = getattr(
+        active_validation, str(valid_token.lang).lower(), active_validation.tr
+    )
+    validation_parse = ValidationParser(active_validation=active_validation)
+    return EndpointValidationResponse(
+        language=valid_token.lang,
+        headers=headers,
+        validation=validation_parse.schema,
+    )