refactor ruther

Author: pcrespov

packages/postgres-database/src/simcore_postgres_database/utils_users.py

@@ -9,12 +9,10 @@
 from typing import Any, Final
 
 import sqlalchemy as sa
-from common_library.async_tools import maybe_await
 from sqlalchemy import Column
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio.engine import AsyncConnection, AsyncEngine
 
-from ._protocols import DBConnection
 from .models.users import UserRole, UserStatus, users
 from .models.users_details import users_pre_registration_details
 from .utils_repos import pass_or_acquire_connection, transaction_context
@@ -183,64 +181,76 @@ def get_billing_details_query(user_id: int):
             .where(users.c.id == user_id)
         )
 
-    @staticmethod
-    async def get_billing_details(conn: DBConnection, user_id: int) -> Any | None:
-        result = await conn.execute(
-            UsersRepo.get_billing_details_query(user_id=user_id)
-        )
-        return await maybe_await(result.fetchone())
+    async def get_billing_details(
+        self, connection: AsyncConnection | None = None, *, user_id: int
+    ) -> Any | None:
+        async with pass_or_acquire_connection(self._engine, connection) as conn:
+            result = await conn.execute(self.get_billing_details_query(user_id=user_id))
+            return result.one_or_none()
 
-    @staticmethod
-    async def get_role(conn: DBConnection, user_id: int) -> UserRole:
-        value: UserRole | None = await conn.scalar(
-            sa.select(users.c.role).where(users.c.id == user_id)
-        )
-        if value:
-            assert isinstance(value, UserRole)  # nosec
-            return UserRole(value)
+    async def get_role(
+        self, connection: AsyncConnection | None = None, *, user_id: int
+    ) -> UserRole:
+        async with pass_or_acquire_connection(self._engine, connection) as conn:
 
-        raise UserNotFoundInRepoError
+            value: UserRole | None = await conn.scalar(
+                sa.select(users.c.role).where(users.c.id == user_id)
+            )
+            if value:
+                assert isinstance(value, UserRole)  # nosec
+                return UserRole(value)
 
-    @staticmethod
-    async def get_email(conn: DBConnection, user_id: int) -> str:
-        value: str | None = await conn.scalar(
-            sa.select(users.c.email).where(users.c.id == user_id)
-        )
-        if value:
-            assert isinstance(value, str)  # nosec
-            return value
+            raise UserNotFoundInRepoError
 
-        raise UserNotFoundInRepoError
+    async def get_email(
+        self, connection: AsyncConnection | None = None, *, user_id: int
+    ) -> str:
+        async with pass_or_acquire_connection(self._engine, connection) as conn:
 
-    @staticmethod
-    async def get_active_user_email(conn: DBConnection, user_id: int) -> str:
-        value: str | None = await conn.scalar(
-            sa.select(users.c.email).where(
-                (users.c.status == UserStatus.ACTIVE) & (users.c.id == user_id)
+            value: str | None = await conn.scalar(
+                sa.select(users.c.email).where(users.c.id == user_id)
             )
-        )
-        if value is not None:
-            assert isinstance(value, str)  # nosec
-            return value
+            if value:
+                assert isinstance(value, str)  # nosec
+                return value
 
-        raise UserNotFoundInRepoError
+            raise UserNotFoundInRepoError
 
-    @staticmethod
-    async def is_email_used(conn: DBConnection, email: str) -> bool:
-        email = email.lower()
+    async def get_active_user_email(
+        self, connection: AsyncConnection | None = None, *, user_id: int
+    ) -> str:
+        async with pass_or_acquire_connection(self._engine, connection) as conn:
+            value: str | None = await conn.scalar(
+                sa.select(users.c.email).where(
+                    (users.c.status == UserStatus.ACTIVE) & (users.c.id == user_id)
+                )
+            )
+            if value is not None:
+                assert isinstance(value, str)  # nosec
+                return value
 
-        registered = await conn.scalar(
-            sa.select(users.c.id).where(users.c.email == email)
-        )
-        if registered:
-            return True
+            raise UserNotFoundInRepoError
+
+    async def is_email_used(
+        self, connection: AsyncConnection | None = None, *, email: str
+    ) -> bool:
+
+        async with pass_or_acquire_connection(self._engine, connection) as conn:
+
+            email = email.lower()
 
-        pre_registered = await conn.scalar(
-            sa.select(users_pre_registration_details.c.user_id).where(
-                users_pre_registration_details.c.pre_email == email
+            registered = await conn.scalar(
+                sa.select(users.c.id).where(users.c.email == email)
             )
-        )
-        return bool(pre_registered)
+            if registered:
+                return True
+
+            pre_registered = await conn.scalar(
+                sa.select(users_pre_registration_details.c.user_id).where(
+                    users_pre_registration_details.c.pre_email == email
+                )
+            )
+            return bool(pre_registered)
 
 
 #

packages/postgres-database/tests/test_users.py

@@ -159,10 +159,12 @@ async def test_new_user(
     assert other_user.name != new_user.name
 
     async with pass_or_acquire_connection(asyncpg_engine) as connection:
-        assert await UsersRepo.get_email(connection, other_user.id) == other_user.email
-        assert await UsersRepo.get_role(connection, other_user.id) == other_user.role
         assert (
-            await UsersRepo.get_active_user_email(connection, other_user.id)
+            await repo.get_email(connection, user_id=other_user.id) == other_user.email
+        )
+        assert await repo.get_role(connection, user_id=other_user.id) == other_user.role
+        assert (
+            await repo.get_active_user_email(connection, user_id=other_user.id)
             == other_user.email
         )
 

packages/postgres-database/tests/test_users_details.py

@@ -309,11 +309,8 @@ async def test_get_billing_details_from_pre_registration(
         )
 
     # Get billing details
-    async with pass_or_acquire_connection(asyncpg_engine) as connection:
-        invoice_data = await UsersRepo.get_billing_details(
-            connection, user_id=new_user.id
-        )
-        assert invoice_data is not None
+    invoice_data = await repo.get_billing_details(user_id=new_user.id)
+    assert invoice_data is not None
 
     # Test UserAddress model conversion
     user_address = UserAddress.create_from_db(invoice_data)

services/web/server/src/simcore_service_webserver/login/_controller/rest/change.py

@@ -5,7 +5,6 @@
 from servicelib.aiohttp.requests_validation import parse_request_body_as
 from servicelib.logging_errors import create_troubleshootting_log_kwargs
 from servicelib.request_keys import RQT_USERID_KEY
-from simcore_postgres_database.utils_repos import pass_or_acquire_connection
 from simcore_postgres_database.utils_users import UsersRepo
 
 from ...._meta import API_VTAG
@@ -228,9 +227,9 @@ async def initiate_change_email(request: web.Request):
     if user["email"] == request_body.email:
         return flash_response("Email changed")
 
-    async with pass_or_acquire_connection(get_asyncpg_engine(request.app)) as conn:
-        if await UsersRepo.is_email_used(conn, email=request_body.email):
-            raise web.HTTPUnprocessableEntity(text="This email cannot be used")
+    repo = UsersRepo(get_asyncpg_engine(request.app))
+    if await repo.is_email_used(email=request_body.email):
+        raise web.HTTPUnprocessableEntity(text="This email cannot be used")
 
     # Reset if previously requested
     confirmation = await db.get_confirmation({"user": user, "action": CHANGE_EMAIL})

services/web/server/src/simcore_service_webserver/users/_users_repository.py

@@ -372,13 +372,10 @@ async def get_user_billing_details(
     Raises:
         BillingDetailsNotFoundError
     """
-    async with pass_or_acquire_connection(engine, connection) as conn:
-        query = UsersRepo.get_billing_details_query(user_id=user_id)
-        result = await conn.execute(query)
-        row = result.first()
-        if not row:
-            raise BillingDetailsNotFoundError(user_id=user_id)
-        return UserBillingDetails.model_validate(row)
+    row = await UsersRepo(engine).get_billing_details(connection, user_id=user_id)
+    if not row:
+        raise BillingDetailsNotFoundError(user_id=user_id)
+    return UserBillingDetails.model_validate(row)
 
 
 async def delete_user_by_id(