exposes interface

Author: pcrespov

services/web/server/src/simcore_service_webserver/exporter/_formatter/_sds.py

@@ -11,7 +11,7 @@
 from ...projects._projects_service import get_project_for_user
 from ...projects.exceptions import BaseProjectError
 from ...projects.models import ProjectDict
-from ...scicrunch.repository import ResearchResourceRepository
+from ...scicrunch.scicrunch_service import ScicrunchResourcesService
 from ..exceptions import SDSException
 from .template_json import write_template_json
 from .xlsx.code_description import (
@@ -70,10 +70,10 @@ async def _add_rrid_entries(
 ) -> None:
     rrid_entires: deque[RRIDEntry] = deque()
 
-    repo = ResearchResourceRepository(app)
+    service = ScicrunchResourcesService(app)
     classifiers = project_data["classifiers"]
     for classifier in classifiers:
-        scicrunch_resource = await repo.get(rrid=classifier)
+        scicrunch_resource = await service.get_resource_atdb(rrid=classifier)
         if scicrunch_resource is None:
             continue
 

services/web/server/src/simcore_service_webserver/groups/_classifiers_rest.py

@@ -9,7 +9,7 @@
 from .._meta import API_VTAG
 from ..login.decorators import login_required
 from ..scicrunch.models import ResearchResource, ResourceHit
-from ..scicrunch.repository import ResearchResourceRepository
+from ..scicrunch.scicrunch_service import ScicrunchResourcesService
 from ..scicrunch.service_client import SciCrunch
 from ..security.decorators import permission_required
 from ..utils_aiohttp import envelope_json_response
@@ -53,8 +53,8 @@ async def get_scicrunch_resource(request: web.Request):
     rrid = SciCrunch.validate_identifier(rrid)
 
     # check if in database first
-    repo = ResearchResourceRepository(request.app)
-    resource: ResearchResource | None = await repo.get_resource(rrid)
+    service = ScicrunchResourcesService(request.app)
+    resource: ResearchResource | None = await service.get_resource(rrid)
     if not resource:
         # otherwise, request to scicrunch service
         scicrunch = SciCrunch.get_instance(request.app)
@@ -74,15 +74,15 @@ async def add_scicrunch_resource(request: web.Request):
     rrid = request.match_info["rrid"]
 
     # check if exists
-    repo = ResearchResourceRepository(request.app)
-    resource: ResearchResource | None = await repo.get_resource(rrid)
+    service = ScicrunchResourcesService(request.app)
+    resource: ResearchResource | None = await service.get_resource(rrid)
     if not resource:
         # then request scicrunch service
         scicrunch = SciCrunch.get_instance(request.app)
         resource = await scicrunch.get_resource_fields(rrid)
 
         # insert new or if exists, then update
-        await repo.upsert(resource)
+        await service.upsert_resource(resource)
 
     return envelope_json_response(resource.model_dump())
 

services/web/server/src/simcore_service_webserver/groups/_classifiers_service.py

@@ -24,7 +24,7 @@
 )
 
 from ..scicrunch.errors import ScicrunchError
-from ..scicrunch.repository import ResearchResourceRepository
+from ..scicrunch.scicrunch_service import ScicrunchResourcesService
 from ..scicrunch.service_client import SciCrunch
 from ._classifiers_repository import GroupClassifierRepository
 
@@ -126,10 +126,10 @@ async def build_rrids_tree_view(
         )
 
     scicrunch = SciCrunch.get_instance(app)
-    repo = ResearchResourceRepository(app)
+    service = ScicrunchResourcesService(app)
 
     flat_tree_view: dict[TreePath, ClassifierItem] = {}
-    for resource in await repo.list_resources():
+    for resource in await service.list_resources():
         try:
             validated_item = ClassifierItem(
                 classifier=resource.rrid,

services/web/server/src/simcore_service_webserver/scicrunch/_repository.py

@@ -0,0 +1,65 @@
+"""
+Repository for scicrunch_resources table operations using asyncpg
+"""
+
+import logging
+from typing import Any
+
+import sqlalchemy as sa
+from simcore_postgres_database.models.scicrunch_resources import scicrunch_resources
+from simcore_postgres_database.utils_repos import (
+    pass_or_acquire_connection,
+    transaction_context,
+)
+from sqlalchemy.dialects.postgresql import insert as sa_pg_insert
+from sqlalchemy.engine import Row
+from sqlalchemy.ext.asyncio import AsyncConnection
+
+from ..db.base_repository import BaseRepository
+
+_logger = logging.getLogger(__name__)
+
+
+class ScicrunchResourcesRepository(BaseRepository):
+    """Repository for managing scicrunch_resources operations."""
+
+    async def list_all_resources(
+        self, connection: AsyncConnection | None = None
+    ) -> list[Row]:
+        """List all research resources with basic fields."""
+        async with pass_or_acquire_connection(self.engine, connection) as conn:
+            stmt = sa.select(
+                scicrunch_resources.c.rrid,
+                scicrunch_resources.c.name,
+                scicrunch_resources.c.description,
+            )
+            result = await conn.execute(stmt)
+            return result.fetchall()
+
+    async def get_resource_by_rrid(
+        self, rrid: str, connection: AsyncConnection | None = None
+    ) -> Row | None:
+        """Get a research resource by RRID."""
+        async with pass_or_acquire_connection(self.engine, connection) as conn:
+            stmt = sa.select(scicrunch_resources).where(
+                scicrunch_resources.c.rrid == rrid
+            )
+            result = await conn.execute(stmt)
+            return result.one_or_none()
+
+    async def upsert_resource(
+        self, resource_data: dict[str, Any], connection: AsyncConnection | None = None
+    ) -> Row:
+        """Insert or update a research resource."""
+        async with transaction_context(self.engine, connection) as conn:
+            stmt = (
+                sa_pg_insert(scicrunch_resources)
+                .values(resource_data)
+                .on_conflict_do_update(
+                    index_elements=[scicrunch_resources.c.rrid],
+                    set_=resource_data,
+                )
+                .returning(*scicrunch_resources.c)
+            )
+            result = await conn.execute(stmt)
+            return result.one()

services/web/server/src/simcore_service_webserver/scicrunch/_service.py

@@ -0,0 +1,90 @@
+"""
+Service layer for scicrunch research resources operations
+"""
+
+import logging
+
+from aiohttp import web
+from common_library.logging.logging_errors import create_troubleshooting_log_kwargs
+from pydantic import ValidationError
+
+from ._repository import ScicrunchResourcesRepository
+from .models import ResearchResource, ResearchResourceAtdB
+
+_logger = logging.getLogger(__name__)
+
+
+class ScicrunchResourcesService:
+    """Service layer handling business logic for scicrunch resources."""
+
+    def __init__(self, app: web.Application):
+        self.app = app
+        self._repo = ScicrunchResourcesRepository.create_from_app(app)
+
+    async def list_resources(self) -> list[ResearchResource]:
+        """List all research resources as domain models."""
+        rows = await self._repo.list_all_resources()
+        if not rows:
+            return []
+
+        resources = []
+        for row in rows:
+            try:
+                resource = ResearchResource.model_validate(dict(row))
+                resources.append(resource)
+            except ValidationError as err:
+                _logger.warning(
+                    **create_troubleshooting_log_kwargs(
+                        f"Invalid data for resource {row.rrid}",
+                        error=err,
+                        error_context={"row_data": dict(row)},
+                    )
+                )
+                continue
+
+        return resources
+
+    async def get_resource_atdb(self, rrid: str) -> ResearchResourceAtdB | None:
+        """Get resource with all database fields."""
+        row = await self._repo.get_resource_by_rrid(rrid)
+        if not row:
+            return None
+
+        try:
+            return ResearchResourceAtdB.model_validate(dict(row))
+        except ValidationError as err:
+            _logger.exception(
+                **create_troubleshooting_log_kwargs(
+                    f"Invalid data for resource {rrid}",
+                    error=err,
+                    error_context={"rrid": rrid, "row_data": dict(row)},
+                )
+            )
+            return None
+
+    async def get_resource(self, rrid: str) -> ResearchResource | None:
+        """Get resource as domain model."""
+        resource_atdb = await self.get_resource_atdb(rrid)
+        if not resource_atdb:
+            return None
+
+        try:
+            return ResearchResource.model_validate(resource_atdb.model_dump())
+        except ValidationError as err:
+            _logger.exception(
+                **create_troubleshooting_log_kwargs(
+                    f"Failed to convert resource {rrid} to domain model",
+                    error=err,
+                    error_context={
+                        "rrid": rrid,
+                        "resource_data": resource_atdb.model_dump(),
+                    },
+                )
+            )
+            return None
+
+    async def upsert_resource(self, resource: ResearchResource) -> ResearchResource:
+        """Create or update a research resource."""
+        values = resource.model_dump(exclude_unset=True)
+        row = await self._repo.upsert_resource(values)
+        return ResearchResource.model_validate(dict(row))

services/web/server/src/simcore_service_webserver/scicrunch/repository.py

@@ -0,0 +1,4 @@
+from ._service import ScicrunchResourcesService
+
+__all__: tuple[str, ...] = ("ScicrunchResourcesService",)
+# nopycln: file