✨ users: Enhance user pre-registration with optional linking to existing users

Author: pcrespov

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

@@ -678,19 +678,54 @@ async def create_user_pre_registration(
     connection: AsyncConnection | None = None,
     *,
     email: str,
-    created_by: UserID,
+    created_by: UserID | None = None,
     product_name: ProductName,
+    link_to_existing_user: bool = True,
     **other_values,
 ) -> int:
+    """Creates a user pre-registration entry.
+
+    Args:
+        engine: Database engine
+        connection: Optional existing connection
+        email: Email address for the pre-registration
+        created_by: ID of the user creating the pre-registration (None for anonymous)
+        product_name: Product name the user is requesting access to
+        link_to_existing_user: Whether to link the pre-registration to an existing user with the same email
+        **other_values: Additional values to insert in the pre-registration entry
+
+    Returns:
+        ID of the created pre-registration
+    """
     async with transaction_context(engine, connection) as conn:
+        # If link_to_existing_user is True, try to find a matching user
+        user_id = None
+        if link_to_existing_user:
+            result = await conn.execute(
+                sa.select(users.c.id).where(users.c.email == email)
+            )
+            user = result.one_or_none()
+            if user:
+                user_id = user.id
+
+        # Insert the pre-registration record
+        values = {
+            "pre_email": email,
+            "product_name": product_name,
+            **other_values,
+        }
+
+        # Only add created_by if not None
+        if created_by is not None:
+            values["created_by"] = created_by
+
+        # Add user_id if found
+        if user_id is not None:
+            values["user_id"] = user_id
+
         result = await conn.execute(
             sa.insert(users_pre_registration_details)
-            .values(
-                created_by=created_by,
-                pre_email=email,
-                product_name=product_name,
-                **other_values,
-            )
+            .values(**values)
             .returning(users_pre_registration_details.c.id)
         )
         pre_registration_id: int = result.scalar_one()

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

@@ -1,3 +1,4 @@
+import logging
 from contextlib import suppress
 
 from aiohttp import web

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

@@ -5,6 +5,7 @@
 
 from typing import Any
 
+import pytest
 import sqlalchemy as sa
 from aiohttp import web
 from common_library.users_enums import AccountRequestStatus
@@ -285,3 +286,68 @@ async def test_list_user_pre_registrations(
                 )
             )
         await conn.commit()
+
+
+@pytest.mark.parametrize(
+    "link_to_existing_user,expected_linked", [(True, True), (False, False)]
+)
+async def test_create_pre_registration_with_existing_user_linking(
+    app: web.Application,
+    product_name: ProductName,
+    product_owner_user: dict[str, Any],
+    link_to_existing_user: bool,
+    expected_linked: bool,
+):
+    """Test that creating a pre-registration for an existing user correctly handles auto-linking."""
+    # Arrange
+    asyncpg_engine = get_asyncpg_engine(app)
+    existing_user_id = product_owner_user["id"]
+    existing_user_email = product_owner_user["email"]
+
+    # Act - Create pre-registration with the same email as product_owner_user
+    pre_registration_id = await _users_repository.create_user_pre_registration(
+        asyncpg_engine,
+        email=existing_user_email,  # Same email as existing user
+        created_by=existing_user_id,
+        product_name=product_name,
+        link_to_existing_user=link_to_existing_user,  # Parameter to test
+        pre_first_name="Link-Test",
+        pre_last_name="User",
+        institution=f"{'Auto-linked' if link_to_existing_user else 'No-link'} Institution",
+    )
+
+    # Assert - Verify through list_user_pre_registrations
+    registrations, count = await _users_repository.list_user_pre_registrations(
+        asyncpg_engine,
+        filter_by_pre_email=existing_user_email,
+        filter_by_product_name=product_name,
+    )
+
+    # Verify count and that we found our registration
+    assert count == 1
+    assert len(registrations) == 1
+
+    # Get the registration
+    reg = registrations[0]
+
+    # Verify linking behavior based on parameter
+    assert reg["id"] == pre_registration_id
+    assert reg["pre_email"] == existing_user_email
+
+    # When True, user_id should be set to the existing user ID
+    # When False, user_id should be None
+    if expected_linked:
+        assert (
+            reg["user_id"] == existing_user_id
+        ), "Should be linked to the existing user"
+    else:
+        assert reg["user_id"] is None, "Should NOT be linked to any user"
+
+    # Clean up
+    async with asyncpg_engine.connect() as conn:
+        await conn.execute(
+            sa.delete(users_pre_registration_details).where(
+                users_pre_registration_details.c.id == pre_registration_id
+            )
+        )
+        await conn.commit()