fractal-server 2.8.1__py3-none-any.whl → 2.9.0__py3-none-any.whl

fractal_server/app/routes/admin/v2/task_group.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Optional
 
 from fastapi import APIRouter
@@ -12,13 +13,17 @@ from sqlmodel import select
 from fractal_server.app.db import AsyncSession
 from fractal_server.app.db import get_async_db
 from fractal_server.app.models import UserOAuth
-from fractal_server.app.models.v2 import CollectionStateV2
+from fractal_server.app.models.v2 import TaskGroupActivityV2
 from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.models.v2 import WorkflowTaskV2
 from fractal_server.app.routes.auth import current_active_superuser
 from fractal_server.app.routes.auth._aux_auth import (
     _verify_user_belongs_to_group,
 )
+from fractal_server.app.routes.aux import _raise_if_naive_datetime
+from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
+from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
+from fractal_server.app.schemas.v2 import TaskGroupActivityV2Read
 from fractal_server.app.schemas.v2 import TaskGroupReadV2
 from fractal_server.app.schemas.v2 import TaskGroupUpdateV2
 from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
@@ -29,6 +34,44 @@ router = APIRouter()
 logger = set_logger(__name__)
 
 
+@router.get("/activity/", response_model=list[TaskGroupActivityV2Read])
+async def get_task_group_activity_list(
+    task_group_activity_id: Optional[int] = None,
+    user_id: Optional[int] = None,
+    taskgroupv2_id: Optional[int] = None,
+    pkg_name: Optional[str] = None,
+    status: Optional[TaskGroupActivityStatusV2] = None,
+    action: Optional[TaskGroupActivityActionV2] = None,
+    timestamp_started_min: Optional[datetime] = None,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[TaskGroupActivityV2Read]:
+
+    _raise_if_naive_datetime(timestamp_started_min)
+
+    stm = select(TaskGroupActivityV2)
+    if task_group_activity_id is not None:
+        stm = stm.where(TaskGroupActivityV2.id == task_group_activity_id)
+    if user_id:
+        stm = stm.where(TaskGroupActivityV2.user_id == user_id)
+    if taskgroupv2_id:
+        stm = stm.where(TaskGroupActivityV2.taskgroupv2_id == taskgroupv2_id)
+    if pkg_name:
+        stm = stm.where(TaskGroupActivityV2.pkg_name.icontains(pkg_name))
+    if status:
+        stm = stm.where(TaskGroupActivityV2.status == status)
+    if action:
+        stm = stm.where(TaskGroupActivityV2.action == action)
+    if timestamp_started_min is not None:
+        stm = stm.where(
+            TaskGroupActivityV2.timestamp_started >= timestamp_started_min
+        )
+
+    res = await db.execute(stm)
+    activities = res.scalars().all()
+    return activities
+
+
 @router.get("/{task_group_id}/", response_model=TaskGroupReadV2)
 async def query_task_group(
     task_group_id: int,
@@ -53,16 +96,26 @@ async def query_task_group_list(
     active: Optional[bool] = None,
     pkg_name: Optional[str] = None,
     origin: Optional[TaskGroupV2OriginEnum] = None,
+    timestamp_last_used_min: Optional[datetime] = None,
+    timestamp_last_used_max: Optional[datetime] = None,
     user: UserOAuth = Depends(current_active_superuser),
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskGroupReadV2]:
 
     stm = select(TaskGroupV2)
 
+    _raise_if_naive_datetime(
+        timestamp_last_used_max,
+        timestamp_last_used_min,
+    )
+
     if user_group_id is not None and private is True:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Cannot set `user_group_id` with {private=}",
+            detail=(
+                "Cannot get task groups with both "
+                f"{user_group_id=} and {private=}."
+            ),
         )
     if user_id is not None:
         stm = stm.where(TaskGroupV2.user_id == user_id)
@@ -82,6 +135,14 @@ async def query_task_group_list(
         stm = stm.where(TaskGroupV2.origin == origin)
     if pkg_name is not None:
         stm = stm.where(TaskGroupV2.pkg_name.icontains(pkg_name))
+    if timestamp_last_used_min is not None:
+        stm = stm.where(
+            TaskGroupV2.timestamp_last_used >= timestamp_last_used_min
+        )
+    if timestamp_last_used_max is not None:
+        stm = stm.where(
+            TaskGroupV2.timestamp_last_used <= timestamp_last_used_max
+        )
 
     res = await db.execute(stm)
     task_groups_list = res.scalars().all()
@@ -139,22 +200,22 @@ async def delete_task_group(
             detail=f"TaskV2 {workflow_tasks[0].task_id} is still in use",
         )
 
-    # Cascade operations: set foreign-keys to null for CollectionStateV2 which
-    # are in relationship with the current TaskGroupV2
-    logger.debug("Start of cascade operations on CollectionStateV2.")
-    stm = select(CollectionStateV2).where(
-        CollectionStateV2.taskgroupv2_id == task_group_id
+    # Cascade operations: set foreign-keys to null for TaskGroupActivityV2
+    # which are in relationship with the current TaskGroupV2
+    logger.debug("Start of cascade operations on TaskGroupActivityV2.")
+    stm = select(TaskGroupActivityV2).where(
+        TaskGroupActivityV2.taskgroupv2_id == task_group_id
     )
     res = await db.execute(stm)
-    collection_states = res.scalars().all()
-    for collection_state in collection_states:
+    task_group_activity_list = res.scalars().all()
+    for task_group_activity in task_group_activity_list:
         logger.debug(
-            f"Setting CollectionStateV2[{collection_state.id}].taskgroupv2_id "
-            "to None."
+            f"Setting TaskGroupActivityV2[{task_group_activity.id}]"
+            ".taskgroupv2_id to None."
         )
-        collection_state.taskgroupv2_id = None
-        db.add(collection_state)
-    logger.debug("End of cascade operations on CollectionStateV2.")
+        task_group_activity.taskgroupv2_id = None
+        db.add(task_group_activity)
+    logger.debug("End of cascade operations on TaskGroupActivityV2.")
 
     await db.delete(task_group)
     await db.commit()

fractal_server/app/routes/admin/v2/task_group_lifecycle.py

@@ -0,0 +1,267 @@
+from fastapi import APIRouter
+from fastapi import BackgroundTasks
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import Request
+from fastapi import Response
+from fastapi import status
+
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
+from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2 import TaskGroupActivityV2
+from fractal_server.app.routes.api.v2._aux_functions_task_lifecycle import (
+    check_no_ongoing_activity,
+)
+from fractal_server.app.routes.api.v2._aux_functions_task_lifecycle import (
+    check_no_submitted_job,
+)
+from fractal_server.app.routes.api.v2._aux_functions_tasks import (
+    _get_task_group_or_404,
+)
+from fractal_server.app.routes.auth import current_active_superuser
+from fractal_server.app.routes.aux.validate_user_settings import (
+    validate_user_settings,
+)
+from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
+from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
+from fractal_server.app.schemas.v2 import TaskGroupActivityV2Read
+from fractal_server.app.schemas.v2 import TaskGroupReadV2
+from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
+from fractal_server.config import get_settings
+from fractal_server.logger import set_logger
+from fractal_server.syringe import Inject
+from fractal_server.tasks.v2.local import deactivate_local
+from fractal_server.tasks.v2.local import reactivate_local
+from fractal_server.tasks.v2.ssh import deactivate_ssh
+from fractal_server.tasks.v2.ssh import reactivate_ssh
+from fractal_server.utils import get_timestamp
+
+router = APIRouter()
+
+logger = set_logger(__name__)
+
+
+@router.post(
+    "/{task_group_id}/deactivate/",
+    response_model=TaskGroupActivityV2Read,
+)
+async def deactivate_task_group(
+    task_group_id: int,
+    background_tasks: BackgroundTasks,
+    response: Response,
+    request: Request,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupReadV2:
+    """
+    Deactivate task-group venv
+    """
+    task_group = await _get_task_group_or_404(
+        task_group_id=task_group_id, db=db
+    )
+
+    # Check that task-group is active
+    if not task_group.active:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Cannot deactivate a task group with {task_group.active=}."
+            ),
+        )
+
+    # Check no other activity is ongoing
+    await check_no_ongoing_activity(task_group_id=task_group_id, db=db)
+
+    # Check no submitted jobs use tasks from this task group
+    await check_no_submitted_job(task_group_id=task_group.id, db=db)
+
+    # Shortcut for task-group with origin="other"
+    if task_group.origin == TaskGroupV2OriginEnum.OTHER:
+        task_group.active = False
+        task_group_activity = TaskGroupActivityV2(
+            user_id=task_group.user_id,
+            taskgroupv2_id=task_group.id,
+            status=TaskGroupActivityStatusV2.OK,
+            action=TaskGroupActivityActionV2.DEACTIVATE,
+            pkg_name=task_group.pkg_name,
+            version=(task_group.version or "N/A"),
+            log=(
+                f"Task group has {task_group.origin=}, set "
+                "task_group.active to False and exit."
+            ),
+            timestamp_started=get_timestamp(),
+            timestamp_ended=get_timestamp(),
+        )
+        db.add(task_group)
+        db.add(task_group_activity)
+        await db.commit()
+        response.status_code = status.HTTP_202_ACCEPTED
+        return task_group_activity
+
+    task_group_activity = TaskGroupActivityV2(
+        user_id=task_group.user_id,
+        taskgroupv2_id=task_group.id,
+        status=TaskGroupActivityStatusV2.PENDING,
+        action=TaskGroupActivityActionV2.DEACTIVATE,
+        pkg_name=task_group.pkg_name,
+        version=task_group.version,
+        timestamp_started=get_timestamp(),
+    )
+    db.add(task_group_activity)
+    await db.commit()
+
+    # Submit background task
+    settings = Inject(get_settings)
+    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
+        # Validate user settings (backend-specific)
+        user = await db.get(UserOAuth, task_group.user_id)
+        user_settings = await validate_user_settings(
+            user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
+        )
+        # User appropriate FractalSSH object
+        ssh_credentials = dict(
+            user=user_settings.ssh_username,
+            host=user_settings.ssh_host,
+            key_path=user_settings.ssh_private_key_path,
+        )
+        fractal_ssh_list = request.app.state.fractal_ssh_list
+        fractal_ssh = fractal_ssh_list.get(**ssh_credentials)
+
+        background_tasks.add_task(
+            deactivate_ssh,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+            fractal_ssh=fractal_ssh,
+            tasks_base_dir=user_settings.ssh_tasks_dir,
+        )
+    else:
+        background_tasks.add_task(
+            deactivate_local,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+        )
+
+    logger.debug(
+        "Admin task group deactivation endpoint: start deactivate "
+        "and return task_group_activity"
+    )
+    response.status_code = status.HTTP_202_ACCEPTED
+    return task_group_activity
+
+
+@router.post(
+    "/{task_group_id}/reactivate/",
+    response_model=TaskGroupActivityV2Read,
+)
+async def reactivate_task_group(
+    task_group_id: int,
+    background_tasks: BackgroundTasks,
+    response: Response,
+    request: Request,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> TaskGroupReadV2:
+    """
+    Deactivate task-group venv
+    """
+
+    task_group = await _get_task_group_or_404(
+        task_group_id=task_group_id, db=db
+    )
+
+    # Check that task-group is not active
+    if task_group.active:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Cannot reactivate a task group with {task_group.active=}."
+            ),
+        )
+
+    # Check no other activity is ongoing
+    await check_no_ongoing_activity(task_group_id=task_group_id, db=db)
+
+    # Check no submitted jobs use tasks from this task group
+    await check_no_submitted_job(task_group_id=task_group.id, db=db)
+
+    # Shortcut for task-group with origin="other"
+    if task_group.origin == TaskGroupV2OriginEnum.OTHER:
+        task_group.active = True
+        task_group_activity = TaskGroupActivityV2(
+            user_id=task_group.user_id,
+            taskgroupv2_id=task_group.id,
+            status=TaskGroupActivityStatusV2.OK,
+            action=TaskGroupActivityActionV2.REACTIVATE,
+            pkg_name=task_group.pkg_name,
+            version=(task_group.version or "N/A"),
+            log=(
+                f"Task group has {task_group.origin=}, set "
+                "task_group.active to True and exit."
+            ),
+            timestamp_started=get_timestamp(),
+            timestamp_ended=get_timestamp(),
+        )
+        db.add(task_group)
+        db.add(task_group_activity)
+        await db.commit()
+        response.status_code = status.HTTP_202_ACCEPTED
+        return task_group_activity
+
+    if task_group.pip_freeze is None:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                "Cannot reactivate a task group with "
+                f"{task_group.pip_freeze=}."
+            ),
+        )
+
+    task_group_activity = TaskGroupActivityV2(
+        user_id=task_group.user_id,
+        taskgroupv2_id=task_group.id,
+        status=TaskGroupActivityStatusV2.PENDING,
+        action=TaskGroupActivityActionV2.REACTIVATE,
+        pkg_name=task_group.pkg_name,
+        version=task_group.version,
+        timestamp_started=get_timestamp(),
+    )
+    db.add(task_group_activity)
+    await db.commit()
+
+    # Submit background task
+    settings = Inject(get_settings)
+    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
+        # Validate user settings (backend-specific)
+        user = await db.get(UserOAuth, task_group.user_id)
+        user_settings = await validate_user_settings(
+            user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
+        )
+        # Use appropriate FractalSSH object
+        ssh_credentials = dict(
+            user=user_settings.ssh_username,
+            host=user_settings.ssh_host,
+            key_path=user_settings.ssh_private_key_path,
+        )
+        fractal_ssh_list = request.app.state.fractal_ssh_list
+        fractal_ssh = fractal_ssh_list.get(**ssh_credentials)
+
+        background_tasks.add_task(
+            reactivate_ssh,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+            fractal_ssh=fractal_ssh,
+            tasks_base_dir=user_settings.ssh_tasks_dir,
+        )
+    else:
+        background_tasks.add_task(
+            reactivate_local,
+            task_group_id=task_group.id,
+            task_group_activity_id=task_group_activity.id,
+        )
+    logger.debug(
+        "Admin task group reactivation endpoint: start reactivate "
+        "and return task_group_activity"
+    )
+    response.status_code = status.HTTP_202_ACCEPTED
+    return task_group_activity

fractal_server/app/routes/api/v1/project.py

@@ -1,5 +1,5 @@
+import json
 import os
-from datetime import datetime
 from datetime import timedelta
 from datetime import timezone
 from typing import Optional
@@ -50,10 +50,6 @@ router = APIRouter()
 logger = set_logger(__name__)
 
 
-def _encode_as_utc(dt: datetime):
-    return dt.replace(tzinfo=timezone.utc).isoformat()
-
-
 @router.get("/", response_model=list[ProjectReadV1])
 async def get_list_project(
     user: UserOAuth = Depends(current_active_user),
@@ -393,33 +389,25 @@ async def apply_workflow(
         workflow_id=workflow_id,
         user_email=user.email,
         input_dataset_dump=dict(
-            **input_dataset.model_dump(
-                exclude={"resource_list", "history", "timestamp_created"}
+            **json.loads(
+                input_dataset.json(exclude={"resource_list", "history"})
             ),
-            timestamp_created=_encode_as_utc(input_dataset.timestamp_created),
             resource_list=[
                 resource.model_dump()
                 for resource in input_dataset.resource_list
             ],
         ),
         output_dataset_dump=dict(
-            **output_dataset.model_dump(
-                exclude={"resource_list", "history", "timestamp_created"}
+            **json.loads(
+                output_dataset.json(exclude={"resource_list", "history"})
             ),
-            timestamp_created=_encode_as_utc(output_dataset.timestamp_created),
             resource_list=[
                 resource.model_dump()
                 for resource in output_dataset.resource_list
             ],
         ),
-        workflow_dump=dict(
-            **workflow.model_dump(exclude={"task_list", "timestamp_created"}),
-            timestamp_created=_encode_as_utc(workflow.timestamp_created),
-        ),
-        project_dump=dict(
-            **project.model_dump(exclude={"user_list", "timestamp_created"}),
-            timestamp_created=_encode_as_utc(project.timestamp_created),
-        ),
+        workflow_dump=json.loads(workflow.json(exclude={"task_list"})),
+        project_dump=json.loads(project.json(exclude={"user_list"})),
         **apply_workflow.dict(),
     )
 

fractal_server/app/routes/api/v2/__init__.py

@@ -13,6 +13,7 @@ from .task import router as task_router_v2
 from .task_collection import router as task_collection_router_v2
 from .task_collection_custom import router as task_collection_router_v2_custom
 from .task_group import router as task_group_router_v2
+from .task_group_lifecycle import router as task_group_lifecycle_router_v2
 from .workflow import router as workflow_router_v2
 from .workflow_import import router as workflow_import_router_v2
 from .workflowtask import router as workflowtask_router_v2
@@ -31,13 +32,21 @@ router_api_v2.include_router(submit_job_router_v2, tags=["V2 Job"])
 
 settings = Inject(get_settings)
 router_api_v2.include_router(
-    task_collection_router_v2, prefix="/task", tags=["V2 Task Collection"]
+    task_collection_router_v2,
+    prefix="/task",
+    tags=["V2 Task Lifecycle"],
 )
 router_api_v2.include_router(
     task_collection_router_v2_custom,
     prefix="/task",
-    tags=["V2 Task Collection"],
+    tags=["V2 Task Lifecycle"],
+)
+router_api_v2.include_router(
+    task_group_lifecycle_router_v2,
+    prefix="/task-group",
+    tags=["V2 Task Lifecycle"],
 )
+
 router_api_v2.include_router(task_router_v2, prefix="/task", tags=["V2 Task"])
 router_api_v2.include_router(
     task_group_router_v2, prefix="/task-group", tags=["V2 TaskGroup"]

fractal_server/app/routes/api/v2/{_aux_functions_task_collection.py → _aux_functions_task_lifecycle.py}

@@ -4,7 +4,17 @@ from fastapi import HTTPException
 from fastapi import status
 from httpx import AsyncClient
 from httpx import TimeoutException
+from sqlmodel import func
+from sqlmodel import select
 
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.models.v2 import JobV2
+from fractal_server.app.models.v2 import TaskGroupActivityV2
+from fractal_server.app.models.v2 import TaskV2
+from fractal_server.app.models.v2 import WorkflowTaskV2
+from fractal_server.app.models.v2 import WorkflowV2
+from fractal_server.app.schemas.v2 import JobStatusTypeV2
+from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
 from fractal_server.logger import set_logger
 
 
@@ -122,3 +132,76 @@ async def get_package_version_from_pypi(
         # Case 3: `version` is unset and we use latest
         logger.info(f"No version requested, returning {latest_version=}.")
         return latest_version
+
+
+async def check_no_ongoing_activity(
+    *,
+    task_group_id: int,
+    db: AsyncSession,
+) -> None:
+    """
+    Find ongoing activities for the same task group.
+
+    Arguments:
+        task_group_id:
+        db:
+    """
+    # DB query
+    stm = (
+        select(TaskGroupActivityV2)
+        .where(TaskGroupActivityV2.taskgroupv2_id == task_group_id)
+        .where(TaskGroupActivityV2.status == TaskGroupActivityStatusV2.ONGOING)
+    )
+    res = await db.execute(stm)
+    ongoing_activities = res.scalars().all()
+
+    if ongoing_activities == []:
+        # All good, exit
+        return
+
+    msg = "Found ongoing activities for the same task-group:"
+    for ind, activity in enumerate(ongoing_activities):
+        msg = (
+            f"{msg}\n{ind + 1}) "
+            f"Action={activity.action}, "
+            f"status={activity.status}, "
+            f"timestamp_started={activity.timestamp_started}."
+        )
+    raise HTTPException(
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        detail=msg,
+    )
+
+
+async def check_no_submitted_job(
+    *,
+    task_group_id: int,
+    db: AsyncSession,
+) -> None:
+    """
+    Find submitted jobs which include tasks from a given task group.
+
+    Arguments:
+        task_id_list: List of TaskV2 IDs
+        db: Database session
+    """
+    stm = (
+        select(func.count(JobV2.id))
+        .join(WorkflowV2, JobV2.workflow_id == WorkflowV2.id)
+        .join(WorkflowTaskV2, WorkflowTaskV2.workflow_id == WorkflowV2.id)
+        .join(TaskV2, WorkflowTaskV2.task_id == TaskV2.id)
+        .where(WorkflowTaskV2.order >= JobV2.first_task_index)
+        .where(WorkflowTaskV2.order <= JobV2.last_task_index)
+        .where(JobV2.status == JobStatusTypeV2.SUBMITTED)
+        .where(TaskV2.taskgroupv2_id == task_group_id)
+    )
+    res = await db.execute(stm)
+    num_submitted_jobs = res.scalar()
+    if num_submitted_jobs > 0:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Cannot act on task group because {num_submitted_jobs} "
+                "submitted jobs use its tasks."
+            ),
+        )

fractal_server/app/routes/api/v2/_aux_functions_tasks.py

@@ -13,7 +13,7 @@ from fractal_server.app.db import AsyncSession
 from fractal_server.app.models import LinkUserGroup
 from fractal_server.app.models import UserGroup
 from fractal_server.app.models import UserOAuth
-from fractal_server.app.models.v2 import CollectionStateV2
+from fractal_server.app.models.v2 import TaskGroupActivityV2
 from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.models.v2 import TaskV2
 from fractal_server.app.models.v2 import WorkflowTaskV2
@@ -21,6 +21,7 @@ from fractal_server.app.routes.auth._aux_auth import _get_default_usergroup_id
 from fractal_server.app.routes.auth._aux_auth import (
     _verify_user_belongs_to_group,
 )
+from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
 from fractal_server.logger import set_logger
 
 logger = set_logger(__name__)
@@ -219,27 +220,32 @@ async def _get_valid_user_group_id(
     return user_group_id
 
 
-async def _get_collection_status_message(
-    task_group: TaskGroupV2, db: AsyncSession
+async def _get_collection_task_group_activity_status_message(
+    task_group_id: int,
+    db: AsyncSession,
 ) -> str:
+
     res = await db.execute(
-        select(CollectionStateV2).where(
-            CollectionStateV2.taskgroupv2_id == task_group.id
-        )
+        select(TaskGroupActivityV2)
+        .where(TaskGroupActivityV2.taskgroupv2_id == task_group_id)
+        .where(TaskGroupActivityV2.action == TaskGroupActivityActionV2.COLLECT)
     )
-    states = res.scalars().all()
-    if len(states) > 1:
+    task_group_activity_list = res.scalars().all()
+    if len(task_group_activity_list) > 1:
         msg = (
-            "Expected one CollectionStateV2 associated to TaskGroup "
-            f"{task_group.id}, found {len(states)} "
-            f"(IDs: {[state.id for state in states]}).\n"
+            "\nWarning: "
+            "Expected only one TaskGroupActivityV2 associated to TaskGroup "
+            f"{task_group_id}, found {len(task_group_activity_list)} "
+            f"(IDs: {[tga.id for tga in task_group_activity_list]})."
             "Warning: this should have not happened, please contact an admin."
         )
-    elif len(states) == 1:
+    elif len(task_group_activity_list) == 1:
         msg = (
-            f"\nThere exists a task-collection state (ID={states[0].id}) for "
-            f"such task group (ID={task_group.id}), with status "
-            f"'{states[0].data.get('status')}'."
+            "\nNote:"
+            "There exists another task-group collection "
+            f"(activity ID={task_group_activity_list[0].id}) for "
+            f"this task group (ID={task_group_id}), with status "
+            f"'{task_group_activity_list[0].status}'."
         )
     else:
         msg = ""
@@ -273,7 +279,9 @@ async def _verify_non_duplication_user_constraint(
                     "This should have not happened: please contact an admin."
                 ),
             )
-        state_msg = await _get_collection_status_message(duplicate[0], db)
+        state_msg = await _get_collection_task_group_activity_status_message(
+            duplicate[0].id, db
+        )
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=(
@@ -313,7 +321,9 @@ async def _verify_non_duplication_group_constraint(
                     "This should have not happened: please contact an admin."
                 ),
             )
-        state_msg = await _get_collection_status_message(duplicate[0], db)
+        state_msg = await _get_collection_task_group_activity_status_message(
+            duplicate[0].id, db
+        )
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail=(