drafts

Author: pcrespov

packages/models-library/src/models_library/api_schemas_webserver/users.py

@@ -222,8 +222,8 @@ class UserGet(OutputSchema):
     email: EmailStr | None = None
 
     @classmethod
-    def from_model(cls, args):
-        ...
+    def from_model(cls, data):
+        return cls.model_validate(data, from_attributes=True)
 
 
 class UsersForAdminSearchQueryParams(RequestParameters):

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

@@ -52,6 +52,82 @@ def _parse_as_user(user_id: Any) -> UserID:
         raise UserNotFoundError(uid=user_id, user_id=user_id) from err
 
 
+def _public_user_cols(caller_id: UserID):
+    return (
+        # Fits PublicUser model
+        users.c.id.label("user_id"),
+        users.c.name.label("user_name"),
+        # privacy settings
+        sa.case(
+            (
+                users.c.privacy_hide_email.is_(True) & (users.c.id != caller_id),
+                None,
+            ),
+            else_=users.c.email,
+        ).label("email"),
+        sa.case(
+            (
+                users.c.privacy_hide_fullname.is_(True) & (users.c.id != caller_id),
+                None,
+            ),
+            else_=users.c.first_name,
+        ).label("first_name"),
+        sa.case(
+            (
+                users.c.privacy_hide_fullname.is_(True) & (users.c.id != caller_id),
+                None,
+            ),
+            else_=users.c.last_name,
+        ).label("last_name"),
+        users.c.primary_gid.label("group_id"),
+    )
+
+
+async def get_public_user(
+    engine: AsyncEngine,
+    connection: AsyncConnection | None = None,
+    *,
+    caller_id: UserID,
+    user_id: UserID,
+):
+    query = sa.select(*_public_user_cols(caller_id=caller_id)).where(
+        users.c.id == user_id
+    )
+
+    async with pass_or_acquire_connection(engine, connection) as conn:
+        result = await conn.execute(query)
+        user = result.first()
+        if not user:
+            raise UserNotFoundError(uid=user_id)
+        return user
+
+
+async def search_public_user(
+    engine: AsyncEngine,
+    connection: AsyncConnection | None = None,
+    *,
+    caller_id: UserID,
+    search_pattern: str,
+    limit: int,
+) -> list:
+
+    pattern_ = f"%{search_pattern}%"
+    is_public_email = users.c.privacy_hide_email.is_(False) | (users.c.id != caller_id)
+
+    query = (
+        sa.select(*_public_user_cols(caller_id=caller_id))
+        .where(
+            users.c.name.ilike(pattern_)
+            | (is_public_email & users.c.users.c.email.ilike(pattern_))
+        )
+        .limit(limit)
+    )
+
+    async with pass_or_acquire_connection(engine, connection) as conn:
+        result = await conn.stream(query)
+        return [got async for got in result]
+
+
 async def get_user_or_raise(
     engine: AsyncEngine,
     connection: AsyncConnection | None = None,

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

@@ -87,17 +87,23 @@ async def pre_register_user(
 #
 
 
-async def get_public_user(
-    app: web.Application, *, caller_id: UserID, user_id: UserID
-) -> dict[str, Any]:
-    ...
+async def get_public_user(app: web.Application, *, caller_id: UserID, user_id: UserID):
+    return await _users_repository.get_public_user(
+        get_asyncpg_engine(app),
+        caller_id=caller_id,
+        user_id=user_id,
+    )
 
 
 async def search_public_users(
     app: web.Application, *, caller_id: UserID, match_: str, limit: int
-) -> list[dict[str, Any]]:
-
-    ...
+) -> list:
+    return await _users_repository.search_public_user(
+        get_asyncpg_engine(app),
+        caller_id=caller_id,
+        search_pattern=match_,
+        limit=limit,
+    )
 
 
 async def get_user(app: web.Application, user_id: UserID) -> dict[str, Any]: