db

Author: matusdrobuliak66

services/web/server/src/simcore_service_webserver/folders/_folders_db.py

@@ -6,7 +6,7 @@
 
 import logging
 from datetime import datetime
-from typing import Any, Final, cast
+from typing import Final, cast
 
 import sqlalchemy as sa
 from aiohttp import web
@@ -33,6 +33,7 @@
 from simcore_postgres_database.utils_workspaces_sql import (
     create_my_workspace_access_rights_subquery,
 )
+from simcore_service_webserver.utils import UnSet, as_dict_exclude_unset
 from sqlalchemy import func
 from sqlalchemy.ext.asyncio import AsyncConnection
 from sqlalchemy.orm import aliased
@@ -43,18 +44,9 @@
 
 _logger = logging.getLogger(__name__)
 
-
-class UnSet:
-    ...
-
-
 _unset: Final = UnSet()
 
 
-def as_dict_exclude_unset(**params) -> dict[str, Any]:
-    return {k: v for k, v in params.items() if not isinstance(v, UnSet)}
-
-
 _SELECTION_ARGS = (
     folders_v2.c.folder_id,
     folders_v2.c.name,
@@ -324,6 +316,7 @@ async def update(
     parent_folder_id: FolderID | None | UnSet = _unset,
     trashed_at: datetime | None | UnSet = _unset,
     trashed_explicitly: bool | UnSet = _unset,
+    workspace_id: WorkspaceID | None | UnSet = _unset,
 ) -> FolderDB:
     """
     Batch/single patch of folder/s
@@ -334,6 +327,7 @@ async def update(
         parent_folder_id=parent_folder_id,
         trashed_at=trashed_at,
         trashed_explicitly=trashed_explicitly,
+        workspace_id=workspace_id,
     )
 
     query = (
@@ -467,6 +461,60 @@ async def get_projects_recursively_only_if_user_is_owner(
         return [ProjectID(row[0]) async for row in result]
 
 
+async def get_all_folders_and_projects_recursively(
+    app: web.Application,
+    connection: AsyncConnection | None = None,
+    *,
+    folder_id: FolderID,
+    private_workspace_user_id_or_none: UserID | None,
+    product_name: ProductName,
+) -> tuple[list[FolderID], list[ProjectID]]:
+    """
+    The purpose of this function is to retrieve all projects within the provided folder ID.
+    """
+
+    async with pass_or_acquire_connection(get_asyncpg_engine(app), connection) as conn:
+
+        # Step 1: Define the base case for the recursive CTE
+        base_query = select(
+            folders_v2.c.folder_id, folders_v2.c.parent_folder_id
+        ).where(
+            (folders_v2.c.folder_id == folder_id)  # <-- specified folder id
+            & (folders_v2.c.product_name == product_name)
+        )
+        folder_hierarchy_cte = base_query.cte(name="folder_hierarchy", recursive=True)
+
+        # Step 2: Define the recursive case
+        folder_alias = aliased(folders_v2)
+        recursive_query = select(
+            folder_alias.c.folder_id, folder_alias.c.parent_folder_id
+        ).select_from(
+            folder_alias.join(
+                folder_hierarchy_cte,
+                folder_alias.c.parent_folder_id == folder_hierarchy_cte.c.folder_id,
+            )
+        )
+
+        # Step 3: Combine base and recursive cases into a CTE
+        folder_hierarchy_cte = folder_hierarchy_cte.union_all(recursive_query)
+
+        # Step 4: Execute the query to get all descendants
+        final_query = select(folder_hierarchy_cte)
+        result = await conn.stream(final_query)
+        # list of tuples [(folder_id, parent_folder_id), ...] ex. [(1, None), (2, 1)]
+        folder_ids = [item[0] async for item in result]
+
+        query = select(projects_to_folders.c.project_uuid).where(
+            (projects_to_folders.c.folder_id.in_(folder_ids))
+            & (projects_to_folders.c.user_id == private_workspace_user_id_or_none)
+        )
+
+        result = await conn.stream(query)
+        project_ids = [ProjectID(row[0]) async for row in result]
+
+        return folder_ids, project_ids
+
+
 async def get_folders_recursively(
     app: web.Application,
     connection: AsyncConnection | None = None,

services/web/server/src/simcore_service_webserver/folders/_workspaces_api.py

@@ -1,12 +1,15 @@
 import logging
 
 from aiohttp import web
-from models_library.access_rights import AccessRights
 from models_library.folders import FolderID
 from models_library.products import ProductName
 from models_library.users import UserID
 from models_library.workspaces import WorkspaceID
+from simcore_service_webserver.projects.db import ProjectDBAPI
 
+from ..projects import _folders_db as project_to_folders_db
+from ..projects import _groups_db as project_groups_db
+from ..projects._access_rights_api import check_user_project_permission
 from ..users.api import get_user
 from ..workspaces.api import check_user_workspace_access
 from . import _folders_db
@@ -22,64 +25,107 @@ async def move_folder_into_workspace(
     workspace_id: WorkspaceID | None,
     product_name: ProductName,
 ) -> None:
+    projects_db = ProjectDBAPI.get_from_app_context(app)
+
     # 1. User needs to have delete permission on source folder
     folder_db = await _folders_db.get(
         app, folder_id=folder_id, product_name=product_name
     )
     workspace_is_private = True
-    user_folder_access_rights = AccessRights(read=True, write=True, delete=True)
     if folder_db.workspace_id:
-        user_workspace_access_rights = await check_user_workspace_access(
+        await check_user_workspace_access(
             app,
             user_id=user_id,
             workspace_id=folder_db.workspace_id,
             product_name=product_name,
             permission="delete",
         )
         workspace_is_private = False
-        user_folder_access_rights = user_workspace_access_rights.my_access_rights
-
-    # Here we have checked user has delete access rights on the folder he is moving
 
-    # 2.  User needs to have write permission on destination workspace
+    # 2. User needs to have write permission on destination workspace
     if workspace_id is not None:
-        user_workspace_access_rights = await check_user_workspace_access(
+        await check_user_workspace_access(
             app,
             user_id=user_id,
             workspace_id=workspace_id,
             product_name=product_name,
             permission="write",
         )
 
-    # Here we have already guaranties that user has all the right permissions to do this operation
+    # 3. User needs to have delete permission on all the projects inside source folder
+    (
+        folder_ids,
+        project_ids,
+    ) = await _folders_db.get_all_folders_and_projects_recursively(
+        app,
+        connection=None,
+        folder_id=folder_id,
+        private_workspace_user_id_or_none=user_id if workspace_is_private else None,
+        product_name=product_name,
+    )
+    # NOTE: Not the most effective, can be improved
+    for project_id in project_ids:
+        await check_user_project_permission(
+            app,
+            project_id=project_id,
+            user_id=user_id,
+            product_name=product_name,
+            permission="delete",
+        )
 
-    # Get all project children
-    # await _folders_db.
-    # Get all folder children
-    children_folders_list = await _folders_db.get_folders_recursively(
-        app, connection=None, folder_id=folder_id, product_name=product_name
+    # ⬆️ Here we have already guaranties that user has all the right permissions to do this operation ⬆️
+
+    # 4. Update workspace ID on the project resource
+    for project_id in project_ids:
+        await projects_db.patch_project(
+            project_uuid=project_id,
+            new_partial_project_data={"workspace_id": workspace_id},
+        )
+
+    # 5. BATCH update of folders with workspace_id
+    await _folders_db.update(
+        app,
+        connection=None,
+        folders_id_or_ids=set(folder_ids),
+        product_name=product_name,
+        workspace_id=workspace_id,  # <-- Updating workspace_id
     )
 
-    # 3. Delete project to folders (for everybody)
-    await project_to_folders_db.delete_all_project_to_folder_by_project_id(
+    # 6. Update source folder parent folder ID with NULL (it will appear in the root directory)
+    await _folders_db.update(
         app,
-        project_id=project_id,
+        connection=None,
+        folders_id_or_ids=folder_id,
+        product_name=product_name,
+        parent_folder_id=None,  # <-- Updating parent folder ID
     )
 
-    # 4. Update workspace ID on the project resource
-    await project_api.patch_project(
-        project_uuid=project_id,
-        new_partial_project_data={"workspace_id": workspace_id},
+    # 7. Remove all records of project to folders that are not in the folders that we are moving
+    # (ex. If we are moving from private workspace, the same project can be in different folders for different users)
+    await project_to_folders_db.delete_all_project_to_folder_by_project_ids_not_in_folder_ids(
+        app,
+        connection=None,
+        project_id_or_ids=set(project_ids),
+        not_in_folder_ids=set(folder_ids),
     )
 
-    # 5. Remove all project permissions, leave only the user who moved the project
-    user = await get_user(app, user_id=user_id)
-    await project_groups_db.delete_all_project_groups(app, project_id=project_id)
-    await project_groups_db.update_or_insert_project_group(
+    # 8. Update the user id field for the remaining folders
+    await project_to_folders_db.update_project_to_folder(
         app,
-        project_id=project_id,
-        group_id=user["primary_gid"],
-        read=True,
-        write=True,
-        delete=True,
+        connection=None,
+        folders_id_or_ids=set(folder_ids),
+        user_id=user_id if workspace_id is None else None,
     )
+
+    # 9. Remove all project permissions, leave only the user who moved the project
+    user = await get_user(app, user_id=user_id)
+    for project_id in project_ids:
+        await project_groups_db.delete_all_project_groups(app, project_id=project_id)
+        await project_groups_db.update_or_insert_project_group(
+            app,
+            project_id=project_id,
+            group_id=user["primary_gid"],
+            read=True,
+            write=True,
+            delete=True,
+        )

services/web/server/src/simcore_service_webserver/folders/_workspaces_handlers.py

@@ -14,6 +14,7 @@
 from .._meta import api_version_prefix as VTAG
 from ..folders.errors import FolderAccessForbiddenError, FolderNotFoundError
 from ..login.decorators import login_required
+from ..projects.exceptions import ProjectInvalidRightsError, ProjectNotFoundError
 from ..security.decorators import permission_required
 from ..workspaces.errors import WorkspaceAccessForbiddenError, WorkspaceNotFoundError
 from . import _workspaces_api
@@ -29,12 +30,14 @@ async def wrapper(request: web.Request) -> web.StreamResponse:
             return await handler(request)
 
         except (
+            ProjectInvalidRightsError,
             FolderNotFoundError,
             WorkspaceNotFoundError,
         ) as exc:
             raise web.HTTPNotFound(reason=f"{exc}") from exc
 
         except (
+            ProjectNotFoundError,
             FolderAccessForbiddenError,
             WorkspaceAccessForbiddenError,
         ) as exc:

services/web/server/src/simcore_service_webserver/projects/_folders_db.py

@@ -6,22 +6,25 @@
 
 import logging
 from datetime import datetime
+from typing import Final
 
 from aiohttp import web
 from models_library.folders import FolderID
 from models_library.projects import ProjectID
 from models_library.users import UserID
 from pydantic import BaseModel
 from simcore_postgres_database.models.projects_to_folders import projects_to_folders
+from simcore_postgres_database.utils_repos import transaction_context
+from simcore_service_webserver.utils import UnSet, as_dict_exclude_unset
 from sqlalchemy import func, literal_column
+from sqlalchemy.ext.asyncio import AsyncConnection
 from sqlalchemy.sql import select
 
-from ..db.plugin import get_database_engine
+from ..db.plugin import get_asyncpg_engine, get_database_engine
 
 _logger = logging.getLogger(__name__)
 
-
-_logger = logging.getLogger(__name__)
+_unset: Final = UnSet()
 
 ### Models
 
@@ -110,3 +113,72 @@ async def delete_all_project_to_folder_by_project_id(
                 projects_to_folders.c.project_uuid == f"{project_id}"
             )
         )
+
+
+### AsyncPg
+
+
+async def update_project_to_folder(
+    app: web.Application,
+    connection: AsyncConnection | None = None,
+    *,
+    folders_id_or_ids: FolderID | set[FolderID],
+    filter_by_user_id: UserID | None | UnSet = _unset,
+    # updatable columns
+    user_id: UserID | None | UnSet = _unset,
+) -> None:
+    """
+    Batch/single patch of project to folders
+    """
+    # NOTE: exclude unset can also be done using a pydantic model and dict(exclude_unset=True)
+    updated = as_dict_exclude_unset(
+        user_id=user_id,
+    )
+
+    query = projects_to_folders.update().values(modified=func.now(), **updated)
+
+    if isinstance(folders_id_or_ids, set):
+        # batch-update
+        query = query.where(
+            projects_to_folders.c.folder_id.in_(list(folders_id_or_ids))
+        )
+    else:
+        # single-update
+        query = query.where(projects_to_folders.c.folder_id == folders_id_or_ids)
+
+    if not isinstance(filter_by_user_id, UnSet):
+        query = query.where(projects_to_folders.c.user_id == filter_by_user_id)
+
+    async with transaction_context(get_asyncpg_engine(app), connection) as conn:
+        await conn.stream(query)
+
+
+async def delete_all_project_to_folder_by_project_ids_not_in_folder_ids(
+    app: web.Application,
+    connection: AsyncConnection | None = None,
+    *,
+    project_id_or_ids: ProjectID | set[ProjectID],
+    # Optional filter
+    not_in_folder_ids: set[FolderID],
+) -> None:
+    query = projects_to_folders.delete()
+
+    if isinstance(project_id_or_ids, set):
+        # batch-delete
+        query = query.where(
+            projects_to_folders.c.project_uuid.in_(list(project_id_or_ids))
+        )
+    else:
+        # single-delete
+        query = query.where(
+            projects_to_folders.c.project_uuid == f"{project_id_or_ids}"
+        )
+
+    query = query.where(
+        projects_to_folders.c.folder_id.not_in(  # <-- NOT IN!
+            [f"{folder_id}" for folder_id in not_in_folder_ids]
+        )
+    )
+
+    async with transaction_context(get_asyncpg_engine(app), connection) as conn:
+        await conn.stream(query)

services/web/server/src/simcore_service_webserver/projects/_workspaces_api.py

@@ -55,6 +55,7 @@ async def move_project_into_workspace(
         project_uuid=project_id,
         new_partial_project_data={"workspace_id": workspace_id},
     )
+    # NOTE: MD: should I also patch the project owner? -> probably yes, or if it is more like "original owner" then probably no
 
     # 5. Remove all project permissions, leave only the user who moved the project
     user = await get_user(app, user_id=user_id)