added mapping facades

server/facades/workspace/mapping/create_mapping_in_workspace_facade.py

@@ -0,0 +1,98 @@
+from uuid import uuid4
+
+from kink import inject
+
+from server.facades import (
+    BaseFacade,
+    FacadeResponse,
+)
+from server.models.mapping import MappingGraph
+from server.models.source import SourceType
+from server.service_protocols.mapping_service_protocol import (
+    MappingServiceProtocol,
+)
+from server.services.core.workspace_metadata_service import (
+    WorkspaceMetadataServiceProtocol,
+)
+from server.services.local.local_source_service import (
+    SourceServiceProtocol,
+)
+from server.services.local.local_workspace_service import (
+    WorkspaceServiceProtocol,
+)
+
+
+@inject
+class CreateMappingInWorkspaceFacade(BaseFacade):
+    def __init__(
+        self,
+        workspace_metadata_service: WorkspaceMetadataServiceProtocol,
+        workspace_service: WorkspaceServiceProtocol,
+        mapping_service: MappingServiceProtocol,
+        source_service: SourceServiceProtocol,
+    ):
+        super().__init__()
+        self.workspace_metadata_service: WorkspaceMetadataServiceProtocol = workspace_metadata_service
+        self.workspace_service: WorkspaceServiceProtocol = (
+            workspace_service
+        )
+        self.mapping_service: MappingServiceProtocol = (
+            mapping_service
+        )
+        self.source_service: SourceServiceProtocol = (
+            source_service
+        )
+
+    @BaseFacade.error_wrapper
+    def execute(
+        self,
+        workspace_id: str,
+        name: str,
+        description: str,
+        source_content: bytes,
+        source_type: SourceType,
+        extra: dict,
+    ) -> FacadeResponse:
+        self.logger.info(
+            f"Creating mapping in workspace {workspace_id} with name {name}"
+        )
+        self.logger.info(
+            f"Retrieving workspace {workspace_id}"
+        )
+        workspace_metadata = self.workspace_metadata_service.get_workspace_metadata(
+            workspace_id,
+        )
+        workspace = self.workspace_service.get_workspace(
+            workspace_metadata.location,
+        )
+        self.logger.info("Creating source")
+        source = self.source_service.create_source(
+            type=source_type,
+            content=source_content,
+            extra=extra,
+        )
+        self.logger.info("Creating mapping")
+        mapping_graph_uuid = uuid4().hex
+        mapping_graph = MappingGraph(
+            uuid=mapping_graph_uuid,
+            name=name,
+            description=description,
+            source_id=source,
+            nodes=[],
+            edges=[],
+        )
+        self.mapping_service.create_mapping(mapping_graph)
+        self.logger.info("Mapping created")
+        workspace.copy_with(
+            mappings=workspace.mappings
+            + [mapping_graph_uuid],
+        )
+        self.workspace_service.update_workspace(
+            workspace,
+        )
+        self.logger.info("Workspace updated")
+        return FacadeResponse(
+            status=202,
+            message="Mapping created",
+            data=mapping_graph,
+        )

server/facades/workspace/mapping/delete_mapping_from_workspace_facade.py

@@ -0,0 +1,111 @@
+from kink import inject
+
+from server.exceptions import ErrCodes
+from server.facades import (
+    BaseFacade,
+    FacadeResponse,
+    ServerException,
+)
+from server.service_protocols.mapping_service_protocol import (
+    MappingServiceProtocol,
+)
+from server.services.core.workspace_metadata_service import (
+    WorkspaceMetadataServiceProtocol,
+)
+from server.services.local.local_source_service import (
+    SourceServiceProtocol,
+)
+from server.services.local.local_workspace_service import (
+    WorkspaceServiceProtocol,
+)
+
+
+@inject
+class DeleteMappingFromWorkspaceFacade(BaseFacade):
+    def __init__(
+        self,
+        workspace_metadata_service: WorkspaceMetadataServiceProtocol,
+        workspace_service: WorkspaceServiceProtocol,
+        mapping_service: MappingServiceProtocol,
+        source_service: SourceServiceProtocol,
+    ):
+        super().__init__()
+        self.workspace_metadata_service: WorkspaceMetadataServiceProtocol = workspace_metadata_service
+        self.workspace_service: WorkspaceServiceProtocol = (
+            workspace_service
+        )
+        self.mapping_service: MappingServiceProtocol = (
+            mapping_service
+        )
+        self.source_service: SourceServiceProtocol = (
+            source_service
+        )
+
+    @BaseFacade.error_wrapper
+    def execute(
+        self,
+        workspace_id: str,
+        mapping_id: str,
+    ) -> FacadeResponse:
+        self.logger.info(
+            f"Dropping mapping {mapping_id} from workspace {workspace_id}"
+        )
+        self.logger.info(
+            f"Retrieving workspace {workspace_id}"
+        )
+        workspace_metadata = self.workspace_metadata_service.get_workspace_metadata(
+            workspace_id,
+        )
+        workspace = self.workspace_service.get_workspace(
+            workspace_metadata.location,
+        )
+
+        if mapping_id not in workspace.mappings:
+            self.logger.error(
+                f"Mapping {mapping_id} not found in workspace {workspace_id}"
+            )
+            raise ServerException(
+                f"Mapping {mapping_id} not found in workspace {workspace_id}",
+                code=ErrCodes.MAPPING_NOT_FOUND,
+            )
+
+        self.logger.info(f"Retrieving mapping {mapping_id}")
+
+        mapping = self.mapping_service.get_mapping(
+            mapping_id,
+        )
+
+        self.logger.info(
+            f"Deleting source {mapping.source_id}"
+        )
+
+        self.source_service.delete_source(
+            mapping.source_id,
+        )
+
+        self.logger.info(f"Deleting mapping {mapping_id}")
+
+        self.mapping_service.delete_mapping(
+            mapping_id,
+        )
+
+        self.logger.info(
+            f"Removing mapping {mapping_id} from workspace {workspace_id}"
+        )
+
+        new_model = workspace.copy_with(
+            mappings=[
+                m
+                for m in workspace.mappings
+                if m != mapping_id
+            ],
+        )
+
+        self.workspace_service.update_workspace(
+            new_model,
+        )
+
+        return FacadeResponse(
+            status=200,
+            message=f"Mapping {mapping_id} dropped from workspace {workspace_id}",
+        )

server/facades/workspace/mapping/get_mappings_in_workspace_facade.py

@@ -0,0 +1,70 @@
+from kink import inject
+
+from server.facades import (
+    BaseFacade,
+    FacadeResponse,
+)
+from server.service_protocols.mapping_service_protocol import (
+    MappingServiceProtocol,
+)
+from server.services.core.workspace_metadata_service import (
+    WorkspaceMetadataServiceProtocol,
+)
+from server.services.local.local_source_service import (
+    SourceServiceProtocol,
+)
+from server.services.local.local_workspace_service import (
+    WorkspaceServiceProtocol,
+)
+
+
+@inject
+class GetMappingsInWorkspaceFacade(BaseFacade):
+    def __init__(
+        self,
+        workspace_metadata_service: WorkspaceMetadataServiceProtocol,
+        workspace_service: WorkspaceServiceProtocol,
+        mapping_service: MappingServiceProtocol,
+        source_service: SourceServiceProtocol,
+    ):
+        super().__init__()
+        self.workspace_metadata_service: WorkspaceMetadataServiceProtocol = workspace_metadata_service
+        self.workspace_service: WorkspaceServiceProtocol = (
+            workspace_service
+        )
+        self.mapping_service: MappingServiceProtocol = (
+            mapping_service
+        )
+        self.source_service: SourceServiceProtocol = (
+            source_service
+        )
+
+    @BaseFacade.error_wrapper
+    def execute(
+        self,
+        workspace_id: str,
+    ) -> FacadeResponse:
+        self.logger.info(
+            f"Retrieving mappings in workspace {workspace_id}"
+        )
+        self.logger.info(
+            f"Retrieving workspace {workspace_id}"
+        )
+        workspace_metadata = self.workspace_metadata_service.get_workspace_metadata(
+            workspace_id,
+        )
+        workspace = self.workspace_service.get_workspace(
+            workspace_metadata.location,
+        )
+        self.logger.info("Retrieving mappings")
+
+        mappings = [
+            self.mapping_service.get_mapping(mapping_id)
+            for mapping_id in workspace.mappings
+        ]
+
+        return FacadeResponse(
+            status=200,
+            message=f"Retrieved mappings in workspace {workspace_id}",
+            data=mappings,
+        )

server/facades/workspace/mapping/update_mapping_facade.py

@@ -0,0 +1,38 @@
+from kink import inject
+
+from server.facades import (
+    BaseFacade,
+    FacadeResponse,
+)
+from server.models.mapping import MappingGraph
+from server.service_protocols.mapping_service_protocol import (
+    MappingServiceProtocol,
+)
+
+
+@inject
+class UpdateMappingFacade(BaseFacade):
+    def __init__(
+        self,
+        mapping_service: MappingServiceProtocol,
+    ):
+        super().__init__()
+        self.mapping_service: MappingServiceProtocol = (
+            mapping_service
+        )
+
+    @BaseFacade.error_wrapper
+    def execute(
+        self,
+        mapping_id: str,
+        mapping_graph: MappingGraph,
+    ) -> FacadeResponse:
+        self.logger.info(f"Updating mapping {mapping_id}")
+        self.mapping_service.update_mapping(
+            mapping_id,
+            mapping_graph,
+        )
+        return FacadeResponse(
+            status=200,
+            message=f"Mapping {mapping_id} updated",
+        )

server/models/mapping.py

@@ -193,11 +193,15 @@ class MappingGraph:
 
     Attributes:
         uuid (str): The UUID of the graph
+        name (str): The name of the graph
+        description (str): The description of the graph
         nodes (list[MappingNode]): The nodes in the graph
         edges (list[MappingEdge]): The edges in the graph
     """
 
     uuid: str
+    name: str
+    description: str
     source_id: str
     nodes: list[
         MappingNode | MappingLiteral | MappingURIRef
@@ -207,6 +211,8 @@ class MappingGraph:
     def to_dict(self):
         return {
             "uuid": self.uuid,
+            "name": self.name,
+            "description": self.description,
             "source_id": self.source_id,
             "nodes": [
                 node.to_dict() for node in self.nodes
@@ -220,6 +226,10 @@ def to_dict(self):
     def from_dict(cls, data):
         if "uuid" not in data:
             raise ValueError("uuid is required")
+        if "name" not in data:
+            raise ValueError("name is required")
+        if "description" not in data:
+            raise ValueError("description is required")
         if "source_id" not in data:
             raise ValueError("source_id is required")
         if "nodes" not in data:
@@ -228,6 +238,8 @@ def from_dict(cls, data):
             raise ValueError("edges is required")
         return cls(
             uuid=data["uuid"],
+            name=data["name"],
+            description=data["description"],
             source_id=data["source_id"],
             nodes=[
                 MappingNode.from_dict(node)

server/routers/workspaces/models.py

@@ -4,6 +4,7 @@
     HttpUrl,
 )
 
+from server.models.source import SourceType
 from server.services.core.sqlite_db_service.tables.workspace_metadata import (
     WorkspaceType,
 )
@@ -31,3 +32,11 @@ class CreateOntologyInput(BaseModel):
     description: str
     base_uri: HttpUrl
     content: Base64UrlStr
+
+
+class CreateMappingInput(BaseModel):
+    name: str
+    description: str
+    content: Base64UrlStr
+    source_type: SourceType
+    extra: dict = {}