updated Identity and managment service

Trash/TemplateService/initializer/create_route.py

@@ -0,0 +1,42 @@
+from typing import List
+from fastapi import APIRouter, FastAPI
+
+
+class RouteRegisterController:
+
+    def __init__(self, app: FastAPI, router_list: List[APIRouter]):
+        self.router_list = router_list
+        self.app = app
+
+    @staticmethod
+    def add_router_with_event_to_database(router: APIRouter):
+        from Schemas import EndpointRestriction
+
+        with EndpointRestriction.new_session() as db_session:
+            for route in router.routes:
+                route_path = str(getattr(route, "path"))
+                route_summary = str(getattr(route, "name"))
+                operation_id = getattr(route, "operation_id", None)
+                if not operation_id:
+                    continue
+
+                for route_method in [
+                    method.lower() for method in getattr(route, "methods")
+                ]:
+                    restriction = EndpointRestriction.find_or_create(
+                        endpoint_method=route_method,
+                        endpoint_name=route_path,
+                        endpoint_desc=route_summary.replace("_", " "),
+                        endpoint_function=route_summary,
+                        operation_uu_id=operation_id,  # UUID of the endpoint
+                        is_confirmed=True,
+                        db=db_session,
+                    )
+                    if restriction.meta_data.created:
+                        restriction.save(db=db_session)
+
+    def register_routes(self):
+        for router in self.router_list:
+            self.app.include_router(router)
+            self.add_router_with_event_to_database(router)
+        return self.app

Trash/TemplateService/initializer/event_clusters.py

@@ -0,0 +1,119 @@
+from typing import Optional, Type
+from pydantic import BaseModel
+
+
+class EventCluster:
+    """
+    EventCluster
+    """
+
+    def __init__(self, endpoint_uu_id: str):
+        self.endpoint_uu_id = endpoint_uu_id
+        self.events = []
+
+    def add_event(self, list_of_events: list["Event"]):
+        """
+        Add an event to the cluster
+        """
+        for event in list_of_events:
+            self.events.append(event)
+        self.events = list(set(self.events))
+
+    def get_event(self, event_key: str):
+        """
+        Get an event by its key
+        """
+
+        for event in self.events:
+            if event.key == event_key:
+                return event
+        return None
+
+    def set_events_to_database(self):
+        from Schemas import Events, EndpointRestriction
+
+        with Events.new_session() as db_session:
+            if to_save_endpoint := EndpointRestriction.filter_one(
+                EndpointRestriction.operation_uu_id == self.endpoint_uu_id,
+                db=db_session,
+            ).data:
+                for event in self.events:
+                    event_to_save_database = Events.find_or_create(
+                        function_code=event.key,
+                        function_class=event.name,
+                        description=event.description,
+                        endpoint_code=self.endpoint_uu_id,
+                        endpoint_id=to_save_endpoint.id,
+                        endpoint_uu_id=str(to_save_endpoint.uu_id),
+                        is_confirmed=True,
+                        active=True,
+                        db=db_session,
+                    )
+                    if event_to_save_database.meta_data.created:
+                        event_to_save_database.save(db=db_session)
+                        print(
+                            f"UUID: {event_to_save_database.uu_id} event is saved to {to_save_endpoint.uu_id}"
+                        )
+
+    def match_event(self, event_key: str) -> "Event":
+        """
+        Match an event by its key
+        """
+        # print('set(event_keys)', set(event_keys))
+        # print('event.keys', set([event.key for event in self.events]))
+        # intersection_of_key: set[str] = set(event_key) & set([event.key for event in self.events])
+        # if not len(intersection_of_key) == 1:
+        #     raise ValueError(
+        #         f"Event key not found or multiple matches found: {intersection_of_key}"
+        #     )
+        return self.get_event(event_key=event_key)
+
+
+class Event:
+
+    def __init__(
+        self,
+        name: str,
+        key: str,
+        request_validator: Optional[Type[BaseModel]] = None,
+        response_validator: Optional[Type[BaseModel]] = None,
+        description: str = "",
+    ):
+        self.name = name
+        self.key = key
+        self.request_validator = request_validator
+        self.response_validator = response_validator
+        self.description = description
+
+    def event_callable(self):
+        """
+        Example callable method
+        """
+        print(self.name)
+        return {}
+
+
+class SetEventCluster:
+    """
+    SetEventCluster
+    """
+
+    list_of_event_clusters: list[EventCluster] = []
+
+    def add_event_cluster(self, event_cluster: EventCluster):
+        """
+        Add an event cluster to the set
+        """
+        endpoint_uu_id_list = [
+            event_cluster_uuid.endpoint_uu_id
+            for event_cluster_uuid in self.list_of_event_clusters
+        ]
+        if event_cluster.endpoint_uu_id not in endpoint_uu_id_list:
+            self.list_of_event_clusters.append(event_cluster)
+
+    @property
+    def retrieve_all_event_clusters(self) -> list[EventCluster]:
+        """
+        Retrieve all event clusters
+        """
+        return self.list_of_event_clusters