adding trashing

Author: pcrespov

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

@@ -3,7 +3,6 @@
 from typing import Any, TypeAlias
 from uuid import UUID
 
-from common_library.exclude import UnSet
 from pydantic import BaseModel, ConfigDict
 
 from .products import ProductName
@@ -43,4 +42,4 @@ class LicensedItemDB(BaseModel):
 class LicensedItemUpdateDB(BaseModel):
     name: str | None = None
     pricing_plan_id: PricingPlanId | None = None
-    trashed: datetime | None | UnSet = UnSet.VALUE
+    trash: bool | None = None

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 (
@@ -47,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,
@@ -59,7 +59,7 @@ async def create(
             )
             .returning(*_SELECTION_ARGS)
         )
-        row = await result.first()
+        row = result.one()
         return LicensedItemDB.model_validate(row)
 
 
@@ -71,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)
@@ -137,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(
@@ -150,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,7 +3,6 @@
 # pylint: disable=unused-variable
 # pylint: disable=too-many-arguments
 # pylint: disable=too-many-statements
-from http import HTTPStatus
 
 import pytest
 from aiohttp.test_utils import TestClient
@@ -14,20 +13,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 +93,88 @@ 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_db1 = await _licensed_items_repository.create(
+        client.app,
+        product_name=osparc_product_name,
+        name="Model A",
+        licensed_resource_type=LicensedResourceType.VIP_MODEL,
+        pricing_plan_id=pricing_plan_id,
+    )
+    licensed_item_id1 = licensed_item_db1.licensed_item_id
+
+    licensed_item_db2 = await _licensed_items_repository.create(
+        client.app,
+        product_name=osparc_product_name,
+        name="Model B",
+        licensed_resource_type=LicensedResourceType.VIP_MODEL,
+        pricing_plan_id=pricing_plan_id,
+    )
+    licensed_item_id2 = licensed_item_db2.licensed_item_id
+
+    # Trash one licensed item
+    await _licensed_items_repository.update(
+        client.app,
+        licensed_item_id=licensed_item_id1,
+        product_name=osparc_product_name,
+        updates=LicensedItemUpdateDB(trash=True),
+    )
+
+    # List with filter_trashed include
+    output_include: tuple[
+        int, list[LicensedItemDB]
+    ] = 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 len(output_include[1]) == 2
+
+    # List with filter_trashed exclude
+    output_exclude: tuple[
+        int, list[LicensedItemDB]
+    ] = 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 len(output_exclude[1]) == 1
+    assert output_exclude[1][0].licensed_item_id == licensed_item_id2
+
+    # List with filter_trashed all
+    output_all: tuple[
+        int, list[LicensedItemDB]
+    ] = await _licensed_items_repository.list_(
+        client.app,
+        product_name=osparc_product_name,
+        offset=0,
+        limit=10,
+        order_by=OrderBy(field="modified"),
+        filter_trashed="all",
+    )
+    assert len(output_all[1]) == 2
+
+    # Get the trashed licensed item
+    trashed_item = await _licensed_items_repository.get(
+        client.app,
+        licensed_item_id=licensed_item_id1,
+        product_name=osparc_product_name,
+    )
+    assert trashed_item.trashed is True