search by email, gid or uname

Author: pcrespov

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

@@ -272,9 +272,12 @@ async def search_merged_pre_and_registered_users(
     engine: AsyncEngine,
     connection: AsyncConnection | None = None,
     *,
-    email_like: str,
+    email_like: str | None = None,
+    user_name_like: str | None = None,
+    primary_group_id: int | None = None,
     product_name: ProductName | None = None,
 ) -> list[Row]:
+    """Searches and merges users from both users and pre-registration tables"""
     users_alias = sa.alias(users, name="users_alias")
 
     invited_by = (
@@ -285,18 +288,6 @@ async def search_merged_pre_and_registered_users(
         .label("invited_by")
     )
 
-    reviewer_alias = sa.alias(users, name="reviewer_alias")
-    account_request_reviewed_by_username = (
-        sa.select(
-            reviewer_alias.c.name,
-        )
-        .where(
-            users_pre_registration_details.c.account_request_reviewed_by
-            == reviewer_alias.c.id
-        )
-        .label("account_request_reviewed_by_username")
-    )
-
     async with pass_or_acquire_connection(engine, connection) as conn:
         columns = (
             users_pre_registration_details.c.id,
@@ -317,39 +308,69 @@ async def search_merged_pre_and_registered_users(
             users_pre_registration_details.c.user_id,
             users_pre_registration_details.c.extras,
             users_pre_registration_details.c.account_request_status,
-            account_request_reviewed_by_username,
+            users_pre_registration_details.c.account_request_reviewed_by,
             users_pre_registration_details.c.account_request_reviewed_at,
             users.c.status,
             invited_by,
             users_pre_registration_details.c.created,
         )
 
+        # Build where conditions for left outer join (pre-registered users)
+        left_where_conditions = []
+        if email_like is not None:
+            left_where_conditions.append(
+                users_pre_registration_details.c.pre_email.like(email_like)
+            )
+
+        # Build join condition
         join_condition = users.c.id == users_pre_registration_details.c.user_id
         if product_name:
             join_condition = join_condition & (
                 users_pre_registration_details.c.product_name == product_name
             )
 
-        left_outer_join = (
-            sa.select(*columns)
-            .select_from(
-                users_pre_registration_details.outerjoin(users, join_condition)
-            )
-            .where(users_pre_registration_details.c.pre_email.like(email_like))
+        # Build where conditions for right outer join (registered users)
+        right_where_conditions = []
+        if email_like is not None:
+            right_where_conditions.append(users.c.email.like(email_like))
+        if user_name_like is not None:
+            right_where_conditions.append(users.c.name.like(user_name_like))
+        if primary_group_id is not None:
+            # Join with user_to_groups to filter by primary group
+            right_where_conditions.append(users.c.primary_gid == primary_group_id)
+
+        # Left outer join query (pre-registered users)
+        left_outer_join = sa.select(*columns).select_from(
+            users_pre_registration_details.outerjoin(users, join_condition)
         )
-        right_outer_join = (
-            sa.select(*columns)
-            .select_from(
-                users.outerjoin(
-                    users_pre_registration_details,
-                    join_condition,
-                )
+        if left_where_conditions:
+            left_outer_join = left_outer_join.where(sa.and_(*left_where_conditions))
+
+        # Right outer join query (registered users)
+        right_outer_join = sa.select(*columns).select_from(
+            users.outerjoin(
+                users_pre_registration_details,
+                join_condition,
             )
-            .where(users.c.email.like(email_like))
         )
+        if right_where_conditions:
+            right_outer_join = right_outer_join.where(sa.and_(*right_where_conditions))
 
-        result = await conn.stream(sa.union(left_outer_join, right_outer_join))
-        return [row async for row in result]
+        # Only execute queries if we have meaningful search criteria
+        queries = []
+        if left_where_conditions:
+            queries.append(left_outer_join)
+        if right_where_conditions:
+            queries.append(right_outer_join)
+
+        if not queries:
+            # No search criteria provided, return empty result
+            return []
+
+        final_query = queries[0] if len(queries) == 1 else sa.union(*queries)
+
+        result = await conn.execute(final_query)
+        return result.fetchall()
 
 
 async def list_merged_pre_and_registered_users(
@@ -400,18 +421,6 @@ async def list_merged_pre_and_registered_users(
 
     # Query for pre-registered users that are not yet in the users table
     # We need to left join with users to identify if the pre-registered user is already in the system
-
-    reviewer_alias = sa.alias(users, name="reviewer_alias")
-    account_request_reviewed_by_username = (
-        sa.select(
-            reviewer_alias.c.name,
-        )
-        .where(
-            users_pre_registration_details.c.account_request_reviewed_by
-            == reviewer_alias.c.id
-        )
-        .label("account_request_reviewed_by_username")
-    )
     pre_reg_query = (
         sa.select(
             users_pre_registration_details.c.id,
@@ -429,7 +438,7 @@ async def list_merged_pre_and_registered_users(
             users_pre_registration_details.c.extras,
             users_pre_registration_details.c.created,
             users_pre_registration_details.c.account_request_status,
-            account_request_reviewed_by_username,
+            users_pre_registration_details.c.account_request_reviewed_by,
             users_pre_registration_details.c.account_request_reviewed_at,
             users.c.id.label("user_id"),
             users.c.name.label("user_name"),
@@ -453,7 +462,7 @@ async def list_merged_pre_and_registered_users(
             users.c.email,
             users.c.first_name,
             users.c.last_name,
-            users.c.phone,  # verified phone!
+            users.c.phone,
             sa.literal(None).label("institution"),
             sa.literal(None).label("address"),
             sa.literal(None).label("city"),

services/web/server/tests/unit/with_dbs/03/users/test_users_accounts_repository.py

@@ -12,6 +12,7 @@
 from aiohttp import web
 from common_library.users_enums import AccountRequestStatus
 from models_library.products import ProductName
+from models_library.users import UserID
 from simcore_postgres_database.models.users_details import (
     users_pre_registration_details,
 )
@@ -477,9 +478,9 @@ async def test_create_pre_registration_with_existing_user_linking(
 class MixedUserTestData:
     """Test data for user pre-registration tests with mixed states."""
 
-    created_by_user_id: str
+    created_by_user_id: UserID
     product_owner_email: str
-    product_owner_id: str
+    product_owner_id: UserID
     pre_reg_email: str
     pre_reg_id: int
     owner_pre_reg_id: int
@@ -829,3 +830,132 @@ async def test_list_merged_users_pagination(
     assert not set(page1_emails).intersection(
         set(page2_emails)
     ), "Pages should have different users"
+
+
+@pytest.mark.parametrize(
+    "email_pattern,expected_count",
+    [
+        ("%pre.registered%", 1),  # Valid: matches pre-registered user
+        ("%nonexistent%", 0),  # Invalid: no matches
+    ],
+)
+async def test_search_merged_users_by_email(
+    app: web.Application,
+    product_name: ProductName,
+    mixed_user_data: MixedUserTestData,
+    email_pattern: str,
+    expected_count: int,
+):
+    """Test searching merged users by email pattern."""
+    asyncpg_engine = get_asyncpg_engine(app)
+
+    # Act
+    rows = await _accounts_repository.search_merged_pre_and_registered_users(
+        asyncpg_engine,
+        email_like=email_pattern,
+        product_name=product_name,
+    )
+
+    # Assert
+    assert len(rows) == expected_count
+
+    if expected_count > 0:
+        row = rows[0]
+        assert row.pre_email == mixed_user_data.pre_reg_email
+        assert row.pre_first_name == "Pre-Registered"
+        assert row.pre_last_name == "Only"
+        assert row.institution == "Pre-Reg Institution"
+
+
+@pytest.mark.parametrize(
+    "use_valid_username,expected_count",
+    [
+        (True, 1),  # Valid: use actual product owner username
+        (False, 0),  # Invalid: use non-existent username
+    ],
+)
+async def test_search_merged_users_by_username(
+    app: web.Application,
+    product_name: ProductName,
+    product_owner_user: dict[str, Any],
+    use_valid_username: bool,
+    expected_count: int,
+):
+    """Test searching merged users by username pattern."""
+    asyncpg_engine = get_asyncpg_engine(app)
+
+    # Arrange
+    username_pattern = (
+        f"{product_owner_user['name']}"
+        if use_valid_username
+        else "%nonexistent_username%"
+    )
+
+    # Act
+    rows = await _accounts_repository.search_merged_pre_and_registered_users(
+        asyncpg_engine,
+        user_name_like=username_pattern,
+        product_name=product_name,
+    )
+
+    # Assert
+    assert len(rows) >= expected_count
+
+    if expected_count > 0:
+        # Find the product owner in rows
+        found_user = next(
+            (row for row in rows if row.email == product_owner_user["email"]),
+            None,
+        )
+        assert found_user is not None
+        assert found_user.first_name == product_owner_user["first_name"]
+        assert found_user.last_name == product_owner_user["last_name"]
+
+
+@pytest.mark.parametrize(
+    "use_valid_group_id,expected_count",
+    [
+        (True, 1),  # Valid: use actual product owner primary group ID
+        (False, 0),  # Invalid: use non-existent group ID
+    ],
+)
+async def test_search_merged_users_by_primary_group_id(
+    app: web.Application,
+    product_name: ProductName,
+    product_owner_user: dict[str, Any],
+    use_valid_group_id: bool,
+    expected_count: int,
+):
+    """Test searching merged users by primary group ID."""
+    asyncpg_engine = get_asyncpg_engine(app)
+
+    # Arrange
+    primary_group_id = (
+        product_owner_user["primary_gid"]
+        if use_valid_group_id
+        else 99999  # Non-existent group ID
+    )
+
+    # Act
+    results = await _accounts_repository.search_merged_pre_and_registered_users(
+        asyncpg_engine,
+        primary_group_id=primary_group_id,
+        product_name=product_name,
+    )
+
+    # Assert
+    assert len(results) >= expected_count
+
+    if expected_count > 0:
+        # Find the product owner in results
+        found_user = next(
+            (
+                result
+                for result in results
+                if result.email == product_owner_user["email"]
+            ),
+            None,
+        )
+        assert found_user is not None
+        assert found_user.first_name == product_owner_user["first_name"]
+        assert found_user.last_name == product_owner_user["last_name"]