fractal-server 2.6.3__py3-none-any.whl → 2.7.0__py3-none-any.whl

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

@@ -0,0 +1,360 @@
+from typing import Optional
+
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import status
+from sqlmodel import or_
+from sqlmodel import select
+
+from ....db import AsyncSession
+from ....db import get_async_db
+from ....models.v2 import TaskV2
+from ....models.v2 import WorkflowV2
+from ....schemas.v2 import TaskImportV2Legacy
+from ....schemas.v2 import WorkflowImportV2
+from ....schemas.v2 import WorkflowReadV2WithWarnings
+from ....schemas.v2 import WorkflowTaskCreateV2
+from ._aux_functions import _check_workflow_exists
+from ._aux_functions import _get_project_check_owner
+from ._aux_functions import _workflow_insert_task
+from ._aux_functions_tasks import _add_warnings_to_workflow_tasks
+from fractal_server.app.models import LinkUserGroup
+from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2.task import TaskGroupV2
+from fractal_server.app.routes.auth import current_active_user
+from fractal_server.app.routes.auth._aux_auth import _get_default_usergroup_id
+from fractal_server.app.schemas.v2.task import TaskImportV2
+from fractal_server.logger import set_logger
+
+router = APIRouter()
+
+
+logger = set_logger(__name__)
+
+
+async def _get_user_accessible_taskgroups(
+    *,
+    user_id: int,
+    db: AsyncSession,
+) -> list[TaskGroupV2]:
+    """
+    Retrieve list of task groups that the user has access to.
+    """
+    stm = select(TaskGroupV2).where(
+        or_(
+            TaskGroupV2.user_id == user_id,
+            TaskGroupV2.user_group_id.in_(
+                select(LinkUserGroup.group_id).where(
+                    LinkUserGroup.user_id == user_id
+                )
+            ),
+        )
+    )
+    res = await db.execute(stm)
+    accessible_task_groups = res.scalars().all()
+    logger.info(
+        f"Found {len(accessible_task_groups)} accessible "
+        f"task groups for {user_id=}."
+    )
+    return accessible_task_groups
+
+
+async def _get_task_by_source(
+    source: str,
+    task_groups_list: list[TaskGroupV2],
+) -> Optional[int]:
+    """
+    Find task with a given source.
+
+    Args:
+        task_import: Info on task to be imported.
+        user_id: ID of current user.
+        default_group_id: ID of default user group.
+        task_group_list: Current list of valid task groups.
+        db: Asynchronous db session
+
+    Return:
+        `id` of the matching task, or `None`.
+    """
+    task_id = next(
+        iter(
+            task.id
+            for task_group in task_groups_list
+            for task in task_group.task_list
+            if task.source == source
+        ),
+        None,
+    )
+    return task_id
+
+
+async def _disambiguate_task_groups(
+    *,
+    matching_task_groups: list[TaskGroupV2],
+    user_id: int,
+    db: AsyncSession,
+    default_group_id: int,
+) -> Optional[TaskV2]:
+    """
+    Disambiguate task groups based on ownership information.
+    """
+    # Highest priority: task groups created by user
+    for task_group in matching_task_groups:
+        if task_group.user_id == user_id:
+            logger.info(
+                "[_disambiguate_task_groups] "
+                f"Found task group {task_group.id} with {user_id=}, return."
+            )
+            return task_group
+    logger.info(
+        "[_disambiguate_task_groups] "
+        f"No task group found with {user_id=}, continue."
+    )
+
+    # Medium priority: task groups owned by default user group
+    for task_group in matching_task_groups:
+        if task_group.user_group_id == default_group_id:
+            logger.info(
+                "[_disambiguate_task_groups] "
+                f"Found task group {task_group.id} with user_group_id="
+                f"{default_group_id}, return."
+            )
+            return task_group
+    logger.info(
+        "[_disambiguate_task_groups] "
+        "No task group found with user_group_id="
+        f"{default_group_id}, continue."
+    )
+
+    # Lowest priority: task groups owned by other groups, sorted
+    # according to age of the user/usergroup link
+    logger.info(
+        "[_disambiguate_task_groups] "
+        "Now sorting remaining task groups by oldest-user-link."
+    )
+    user_group_ids = [
+        task_group.user_group_id for task_group in matching_task_groups
+    ]
+    stm = (
+        select(LinkUserGroup.group_id)
+        .where(LinkUserGroup.user_id == user_id)
+        .where(LinkUserGroup.group_id.in_(user_group_ids))
+        .order_by(LinkUserGroup.timestamp_created.asc())
+    )
+    res = await db.execute(stm)
+    oldest_user_group_id = res.scalars().first()
+    logger.info(
+        "[_disambiguate_task_groups] "
+        f"Result of sorting: {oldest_user_group_id=}."
+    )
+    task_group = next(
+        iter(
+            task_group
+            for task_group in matching_task_groups
+            if task_group.user_group_id == oldest_user_group_id
+        ),
+        None,
+    )
+    return task_group
+
+
+async def _get_task_by_taskimport(
+    *,
+    task_import: TaskImportV2,
+    task_groups_list: list[TaskGroupV2],
+    user_id: int,
+    default_group_id: int,
+    db: AsyncSession,
+) -> Optional[int]:
+    """
+    Find a task based on `task_import`.
+
+    Args:
+        task_import: Info on task to be imported.
+        user_id: ID of current user.
+        default_group_id: ID of default user group.
+        task_group_list: Current list of valid task groups.
+        db: Asynchronous db session
+
+    Return:
+        `id` of the matching task, or `None`.
+    """
+
+    logger.info(f"[_get_task_by_taskimport] START, {task_import=}")
+
+    # Filter by `pkg_name` and by presence of a task with given `name`.
+    matching_task_groups = [
+        task_group
+        for task_group in task_groups_list
+        if (
+            task_group.pkg_name == task_import.pkg_name
+            and task_import.name
+            in [task.name for task in task_group.task_list]
+        )
+    ]
+    if len(matching_task_groups) < 1:
+        logger.info(
+            "[_get_task_by_taskimport] "
+            f"No task group with {task_import.pkg_name=} "
+            f"and a task with {task_import.name=}."
+        )
+        return None
+
+    # Determine target `version`
+    # Note that task_import.version cannot be "", due to a validator
+    if task_import.version is None:
+        logger.info(
+            "[_get_task_by_taskimport] "
+            "No version requested, looking for latest."
+        )
+        latest_task = max(
+            matching_task_groups, key=lambda tg: tg.version or ""
+        )
+        version = latest_task.version
+        logger.info(
+            f"[_get_task_by_taskimport] Latest version set to {version}."
+        )
+    else:
+        version = task_import.version
+
+    # Filter task groups by version
+    final_matching_task_groups = list(
+        filter(lambda tg: tg.version == version, task_groups_list)
+    )
+
+    if len(final_matching_task_groups) < 1:
+        logger.info(
+            "[_get_task_by_taskimport] "
+            "No task group left after filtering by version."
+        )
+        return None
+    elif len(final_matching_task_groups) == 1:
+        final_task_group = final_matching_task_groups[0]
+        logger.info(
+            "[_get_task_by_taskimport] "
+            "Found a single task group, after filtering by version."
+        )
+    else:
+        logger.info(
+            "[_get_task_by_taskimport] "
+            "Found many task groups, after filtering by version."
+        )
+        final_task_group = await _disambiguate_task_groups(
+            matching_task_groups=matching_task_groups,
+            user_id=user_id,
+            db=db,
+            default_group_id=default_group_id,
+        )
+        if final_task_group is None:
+            logger.info(
+                "[_get_task_by_taskimport] Disambiguation returned None."
+            )
+            return None
+
+    # Find task with given name
+    task_id = next(
+        iter(
+            task.id
+            for task in final_task_group.task_list
+            if task.name == task_import.name
+        ),
+        None,
+    )
+
+    logger.info(f"[_get_task_by_taskimport] END, {task_import=}, {task_id=}.")
+
+    return task_id
+
+
+@router.post(
+    "/project/{project_id}/workflow/import/",
+    response_model=WorkflowReadV2WithWarnings,
+    status_code=status.HTTP_201_CREATED,
+)
+async def import_workflow(
+    project_id: int,
+    workflow_import: WorkflowImportV2,
+    user: UserOAuth = Depends(current_active_user),
+    db: AsyncSession = Depends(get_async_db),
+) -> WorkflowReadV2WithWarnings:
+    """
+    Import an existing workflow into a project and create required objects.
+    """
+
+    # Preliminary checks
+    await _get_project_check_owner(
+        project_id=project_id,
+        user_id=user.id,
+        db=db,
+    )
+    await _check_workflow_exists(
+        name=workflow_import.name,
+        project_id=project_id,
+        db=db,
+    )
+
+    task_group_list = await _get_user_accessible_taskgroups(
+        user_id=user.id,
+        db=db,
+    )
+    default_group_id = await _get_default_usergroup_id(db)
+
+    list_wf_tasks = []
+    list_task_ids = []
+    for wf_task in workflow_import.task_list:
+        task_import = wf_task.task
+        if isinstance(task_import, TaskImportV2Legacy):
+            task_id = await _get_task_by_source(
+                source=task_import.source,
+                task_groups_list=task_group_list,
+            )
+        else:
+            task_id = await _get_task_by_taskimport(
+                task_import=task_import,
+                user_id=user.id,
+                default_group_id=default_group_id,
+                task_groups_list=task_group_list,
+                db=db,
+            )
+        if task_id is None:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Could not find a task matching with {wf_task.task}.",
+            )
+        new_wf_task = WorkflowTaskCreateV2(
+            **wf_task.dict(exclude_none=True, exclude={"task"})
+        )
+        list_wf_tasks.append(new_wf_task)
+        list_task_ids.append(task_id)
+
+    # Create new Workflow
+    db_workflow = WorkflowV2(
+        project_id=project_id,
+        **workflow_import.dict(exclude_none=True, exclude={"task_list"}),
+    )
+    db.add(db_workflow)
+    await db.commit()
+    await db.refresh(db_workflow)
+
+    # Insert task into the workflow
+    for ind, new_wf_task in enumerate(list_wf_tasks):
+        await _workflow_insert_task(
+            **new_wf_task.dict(),
+            workflow_id=db_workflow.id,
+            task_id=list_task_ids[ind],
+            db=db,
+        )
+
+    # Add warnings for non-active tasks (or non-accessible tasks,
+    # although that should never happen)
+    wftask_list_with_warnings = await _add_warnings_to_workflow_tasks(
+        wftask_list=db_workflow.task_list, user_id=user.id, db=db
+    )
+    workflow_data = dict(
+        **db_workflow.model_dump(),
+        project=db_workflow.project,
+        task_list=wftask_list_with_warnings,
+    )
+
+    return workflow_data

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

@@ -9,13 +9,13 @@ from fastapi import status
 
 from ....db import AsyncSession
 from ....db import get_async_db
-from ....models.v2 import TaskV2
 from ....schemas.v2 import WorkflowTaskCreateV2
 from ....schemas.v2 import WorkflowTaskReadV2
 from ....schemas.v2 import WorkflowTaskUpdateV2
 from ._aux_functions import _get_workflow_check_owner
 from ._aux_functions import _get_workflow_task_check_owner
 from ._aux_functions import _workflow_insert_task
+from ._aux_functions_tasks import _get_task_read_access
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.routes.auth import current_active_user
 
@@ -43,12 +43,9 @@ async def create_workflowtask(
         project_id=project_id, workflow_id=workflow_id, user_id=user.id, db=db
     )
 
-    task = await db.get(TaskV2, task_id)
-    if not task:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"TaskV2 {task_id} not found.",
-        )
+    task = await _get_task_read_access(
+        task_id=task_id, user_id=user.id, db=db, require_active=True
+    )
 
     if task.type == "parallel":
         if (
@@ -80,7 +77,6 @@ async def create_workflowtask(
     workflow_task = await _workflow_insert_task(
         workflow_id=workflow.id,
         task_id=task_id,
-        order=new_task.order,
         meta_non_parallel=new_task.meta_non_parallel,
         meta_parallel=new_task.meta_parallel,
         args_non_parallel=new_task.args_non_parallel,

fractal_server/app/routes/auth/_aux_auth.py

@@ -1,6 +1,7 @@
 from fastapi import HTTPException
 from fastapi import status
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import asc
 from sqlmodel import select
 
 from fractal_server.app.models.linkusergroup import LinkUserGroup
@@ -8,63 +9,64 @@ from fractal_server.app.models.security import UserGroup
 from fractal_server.app.models.security import UserOAuth
 from fractal_server.app.schemas.user import UserRead
 from fractal_server.app.schemas.user_group import UserGroupRead
+from fractal_server.app.security import FRACTAL_DEFAULT_GROUP_NAME
+from fractal_server.logger import set_logger
 
+logger = set_logger(__name__)
 
-async def _get_single_user_with_group_names(
+
+async def _get_single_user_with_groups(
     user: UserOAuth,
     db: AsyncSession,
 ) -> UserRead:
     """
-    Enrich a user object by filling its `group_names` attribute.
+    Enrich a user object by filling its `group_ids_names` attribute.
 
     Arguments:
         user: The current `UserOAuth` object
         db: Async db session
 
     Returns:
-        A `UserRead` object with `group_names` set
+        A `UserRead` object with `group_ids_names` dict
     """
     stm_groups = (
         select(UserGroup)
         .join(LinkUserGroup)
-        .where(LinkUserGroup.user_id == UserOAuth.id)
+        .where(LinkUserGroup.user_id == user.id)
+        .order_by(asc(LinkUserGroup.timestamp_created))
     )
     res = await db.execute(stm_groups)
     groups = res.scalars().unique().all()
-    group_names = [group.name for group in groups]
-    return UserRead(
-        **user.model_dump(),
-        group_names=group_names,
-        oauth_accounts=user.oauth_accounts,
+    group_ids_names = [(group.id, group.name) for group in groups]
+
+    # Check that Fractal Default Group is the first of the list. If not, fix.
+    index = next(
+        (
+            i
+            for i, group_tuple in enumerate(group_ids_names)
+            if group_tuple[1] == FRACTAL_DEFAULT_GROUP_NAME
+        ),
+        None,
     )
+    if index is None:
+        logger.warning(
+            f"User {user.id} not in "
+            f"default UserGroup '{FRACTAL_DEFAULT_GROUP_NAME}'"
+        )
+    elif index != 0:
+        default_group = group_ids_names.pop(index)
+        group_ids_names.insert(0, default_group)
+    else:
+        pass
 
-
-async def _get_single_user_with_group_ids(
-    user: UserOAuth,
-    db: AsyncSession,
-) -> UserRead:
-    """
-    Enrich a user object by filling its `group_ids` attribute.
-
-    Arguments:
-        user: The current `UserOAuth` object
-        db: Async db session
-
-    Returns:
-        A `UserRead` object with `group_ids` set
-    """
-    stm_links = select(LinkUserGroup).where(LinkUserGroup.user_id == user.id)
-    res = await db.execute(stm_links)
-    links = res.scalars().unique().all()
-    group_ids = [link.group_id for link in links]
     return UserRead(
         **user.model_dump(),
-        group_ids=group_ids,
+        group_ids_names=group_ids_names,
         oauth_accounts=user.oauth_accounts,
     )
 
 
-async def _get_single_group_with_user_ids(
+async def _get_single_usergroup_with_user_ids(
     group_id: int, db: AsyncSession
 ) -> UserGroupRead:
     """
@@ -78,15 +80,7 @@ async def _get_single_group_with_user_ids(
         `UserGroupRead` object, with `user_ids` attribute populated
         from database.
     """
-    # Get the UserGroup object from the database
-    stm_group = select(UserGroup).where(UserGroup.id == group_id)
-    res = await db.execute(stm_group)
-    group = res.scalars().one_or_none()
-    if group is None:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Group {group_id} not found.",
-        )
+    group = await _usergroup_or_404(group_id, db)
 
     # Get all user/group links
     stm_links = select(LinkUserGroup).where(LinkUserGroup.group_id == group_id)
@@ -108,6 +102,58 @@ async def _user_or_404(user_id: int, db: AsyncSession) -> UserOAuth:
     user = await db.get(UserOAuth, user_id, populate_existing=True)
     if user is None:
         raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="User not found."
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"User {user_id} not found.",
+        )
+    return user
+
+
+async def _usergroup_or_404(usergroup_id: int, db: AsyncSession) -> UserGroup:
+    user = await db.get(UserGroup, usergroup_id)
+    if user is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"UserGroup {usergroup_id} not found.",
         )
     return user
+
+
+async def _get_default_usergroup_id(db: AsyncSession) -> int:
+    stm = select(UserGroup.id).where(
+        UserGroup.name == FRACTAL_DEFAULT_GROUP_NAME
+    )
+    res = await db.execute(stm)
+    user_group_id = res.scalars().one_or_none()
+    if user_group_id is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"User group '{FRACTAL_DEFAULT_GROUP_NAME}' not found.",
+        )
+    return user_group_id
+
+
+async def _verify_user_belongs_to_group(
+    *, user_id: int, user_group_id: int, db: AsyncSession
+):
+    stm = (
+        select(LinkUserGroup)
+        .where(LinkUserGroup.user_id == user_id)
+        .where(LinkUserGroup.group_id == user_group_id)
+    )
+    res = await db.execute(stm)
+    link = res.scalars().one_or_none()
+    if link is None:
+        group = await db.get(UserGroup, user_group_id)
+        if group is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"UserGroup {user_group_id} not found",
+            )
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail=(
+                    f"User {user_id} does not belong "
+                    f"to UserGroup {user_group_id}"
+                ),
+            )

fractal_server/app/routes/auth/current_user.py

@@ -13,7 +13,7 @@ from ...schemas.user import UserRead
 from ...schemas.user import UserUpdate
 from ...schemas.user import UserUpdateStrict
 from ..aux.validate_user_settings import verify_user_has_settings
-from ._aux_auth import _get_single_user_with_group_names
+from ._aux_auth import _get_single_user_with_groups
 from fractal_server.app.models import LinkUserGroup
 from fractal_server.app.models import UserGroup
 from fractal_server.app.models import UserOAuth
@@ -28,15 +28,15 @@ router_current_user = APIRouter()
 
 @router_current_user.get("/current-user/", response_model=UserRead)
 async def get_current_user(
-    group_names: bool = False,
+    group_ids_names: bool = False,
     user: UserOAuth = Depends(current_active_user),
     db: AsyncSession = Depends(get_async_db),
 ):
     """
     Return current user
     """
-    if group_names is True:
-        user_with_groups = await _get_single_user_with_group_names(user, db)
+    if group_ids_names is True:
+        user_with_groups = await _get_single_user_with_groups(user, db)
         return user_with_groups
     else:
         return user
@@ -65,7 +65,7 @@ async def patch_current_user(
     patched_user = await db.get(
         UserOAuth, validated_user.id, populate_existing=True
     )
-    patched_user_with_groups = await _get_single_user_with_group_names(
+    patched_user_with_groups = await _get_single_user_with_groups(
         patched_user, db
     )
     return patched_user_with_groups