adapts repository

Author: pcrespov

packages/models-library/src/models_library/licensed_items.py

@@ -23,18 +23,19 @@ class LicensedResourceType(StrAutoEnum):
 
 class LicensedItemDB(BaseModel):
     licensed_item_id: LicensedItemID
-    name: str
-
     license_key: str | None
+
+    licensed_resource_name: str
     licensed_resource_type: LicensedResourceType
     licensed_resource_data: dict[str, Any] | None
 
-    pricing_plan_id: PricingPlanId
-    product_name: ProductName
+    pricing_plan_id: PricingPlanId | None
+    product_name: ProductName | None
 
-    created: datetime  # Timestamp upon creation
-    modified: datetime  # Timestamp on last modification
-    trashed: datetime | None  # Marked as trashed
+    # states
+    created: datetime
+    modified: datetime
+    trashed: datetime | None
 
     model_config = ConfigDict(from_attributes=True)
 

services/web/server/src/simcore_service_webserver/licenses/_licensed_items_repository.py

@@ -5,7 +5,7 @@
 """
 
 import logging
-from typing import cast
+from typing import Literal, cast
 
 from aiohttp import web
 from models_library.licensed_items import (
@@ -20,6 +20,7 @@
 from pydantic import NonNegativeInt
 from simcore_postgres_database.models.licensed_items import licensed_items
 from simcore_postgres_database.utils_repos import (
+    get_columns_from_db_model,
     pass_or_acquire_connection,
     transaction_context,
 )
@@ -33,18 +34,7 @@
 _logger = logging.getLogger(__name__)
 
 
-_SELECTION_ARGS = (
-    licensed_items.c.licensed_item_id,
-    licensed_items.c.name,
-    licensed_items.c.license_key,
-    licensed_items.c.licensed_resource_type,
-    licensed_items.c.pricing_plan_id,
-    licensed_items.c.product_name,
-    licensed_items.c.created,
-    licensed_items.c.modified,
-)
-
-assert set(LicensedItemDB.model_fields) == {c.name for c in _SELECTION_ARGS}  # nosec
+_SELECTION_ARGS = get_columns_from_db_model(licensed_items, LicensedItemDB)
 
 
 async def create(
@@ -57,7 +47,7 @@ async def create(
     pricing_plan_id: PricingPlanId,
 ) -> LicensedItemDB:
     async with transaction_context(get_asyncpg_engine(app), connection) as conn:
-        result = await conn.stream(
+        result = await conn.execute(
             licensed_items.insert()
             .values(
                 name=name,
@@ -69,7 +59,7 @@ async def create(
             )
             .returning(*_SELECTION_ARGS)
         )
-        row = await result.first()
+        row = result.one()
         return LicensedItemDB.model_validate(row)
 
 
@@ -81,13 +71,20 @@ async def list_(
     offset: NonNegativeInt,
     limit: NonNegativeInt,
     order_by: OrderBy,
+    filter_trashed: Literal["exclude", "only", "include"] = "exclude",
 ) -> tuple[int, list[LicensedItemDB]]:
     base_query = (
         select(*_SELECTION_ARGS)
         .select_from(licensed_items)
         .where(licensed_items.c.product_name == product_name)
     )
 
+    # Apply trashed filter
+    if filter_trashed == "exclude":
+        base_query = base_query.where(licensed_items.c.trashed.is_(None))
+    elif filter_trashed == "only":
+        base_query = base_query.where(licensed_items.c.trashed.is_not(None))
+
     # Select total count from base_query
     subquery = base_query.subquery()
     count_query = select(func.count()).select_from(subquery)
@@ -147,11 +144,16 @@ async def update(
     # NOTE: at least 'touch' if updated_values is empty
     _updates = {
         **updates.model_dump(exclude_unset=True),
-        "modified": func.now(),
+        licensed_items.c.modified.name: func.now(),
     }
 
+    # trashing
+    assert "trash" in dict(LicensedItemUpdateDB.model_fields)  # nosec
+    if trash := _updates.pop("trash", None):
+        _updates[licensed_items.c.trashed.name] = func.now() if trash else None
+
     async with transaction_context(get_asyncpg_engine(app), connection) as conn:
-        result = await conn.stream(
+        result = await conn.execute(
             licensed_items.update()
             .values(**_updates)
             .where(
@@ -160,7 +162,7 @@ async def update(
             )
             .returning(*_SELECTION_ARGS)
         )
-        row = await result.first()
+        row = result.one_or_none()
         if row is None:
             raise LicensedItemNotFoundError(licensed_item_id=licensed_item_id)
         return LicensedItemDB.model_validate(row)

services/web/server/tests/unit/with_dbs/04/licenses/test_licensed_items_repository.py

@@ -3,8 +3,8 @@
 # pylint: disable=unused-variable
 # pylint: disable=too-many-arguments
 # pylint: disable=too-many-statements
-from http import HTTPStatus
 
+import arrow
 import pytest
 from aiohttp.test_utils import TestClient
 from models_library.licensed_items import (
@@ -14,20 +14,22 @@
 )
 from models_library.rest_ordering import OrderBy
 from pytest_simcore.helpers.webserver_login import UserInfoDict
-from servicelib.aiohttp import status
 from simcore_service_webserver.db.models import UserRole
 from simcore_service_webserver.licenses import _licensed_items_repository
 from simcore_service_webserver.licenses.errors import LicensedItemNotFoundError
 from simcore_service_webserver.projects.models import ProjectDict
 
 
-@pytest.mark.parametrize("user_role,expected", [(UserRole.USER, status.HTTP_200_OK)])
+@pytest.fixture
+def user_role() -> UserRole:
+    return UserRole.USER
+
+
 async def test_licensed_items_db_crud(
     client: TestClient,
     logged_user: UserInfoDict,
     user_project: ProjectDict,
     osparc_product_name: str,
-    expected: HTTPStatus,
     pricing_plan_id: int,
 ):
     assert client.app
@@ -92,3 +94,87 @@ async def test_licensed_items_db_crud(
             licensed_item_id=_licensed_item_id,
             product_name=osparc_product_name,
         )
+
+
+async def test_licensed_items_db_trash(
+    client: TestClient,
+    logged_user: UserInfoDict,
+    user_project: ProjectDict,
+    osparc_product_name: str,
+    pricing_plan_id: int,
+):
+    assert client.app
+
+    # Create two licensed items
+    licensed_item_ids = []
+    for name in ["Model A", "Model B"]:
+        licensed_item_db = await _licensed_items_repository.create(
+            client.app,
+            product_name=osparc_product_name,
+            name=name,
+            licensed_resource_type=LicensedResourceType.VIP_MODEL,
+            pricing_plan_id=pricing_plan_id,
+        )
+        licensed_item_ids.append(licensed_item_db.licensed_item_id)
+
+    licensed_item_id1, licensed_item_id2 = licensed_item_ids
+
+    # Trash one licensed item
+    trashing_at = arrow.now().datetime
+    trashed_item = await _licensed_items_repository.update(
+        client.app,
+        licensed_item_id=licensed_item_id1,
+        product_name=osparc_product_name,
+        updates=LicensedItemUpdateDB(trash=True),
+    )
+
+    assert trashed_item.licensed_item_id == licensed_item_id1
+    assert trashed_item.trashed
+    assert trashing_at < trashed_item.trashed
+    assert trashed_item.trashed < arrow.now().datetime
+
+    # List with filter_trashed include
+    total_count, items = await _licensed_items_repository.list_(
+        client.app,
+        product_name=osparc_product_name,
+        offset=0,
+        limit=10,
+        order_by=OrderBy(field="modified"),
+        filter_trashed="include",
+    )
+    assert total_count == 2
+    assert {i.licensed_item_id for i in items} == set(licensed_item_ids)
+
+    # List with filter_trashed exclude
+    total_count, items = await _licensed_items_repository.list_(
+        client.app,
+        product_name=osparc_product_name,
+        offset=0,
+        limit=10,
+        order_by=OrderBy(field="modified"),
+        filter_trashed="exclude",
+    )
+    assert total_count == 1
+    assert items[0].licensed_item_id == licensed_item_id2
+    assert items[0].trashed is None
+
+    # List with filter_trashed all
+    total_count, items = await _licensed_items_repository.list_(
+        client.app,
+        product_name=osparc_product_name,
+        offset=0,
+        limit=10,
+        order_by=OrderBy(field="modified"),
+        filter_trashed="only",
+    )
+    assert total_count == 1
+    assert items[0].licensed_item_id == trashed_item.licensed_item_id
+    assert items[0].trashed
+
+    # Get the trashed licensed item
+    got = await _licensed_items_repository.get(
+        client.app,
+        licensed_item_id=trashed_item.licensed_item_id,
+        product_name=osparc_product_name,
+    )
+    assert got == trashed_item