Unlink team from a project for allowing team deletion

backend/api/teams/actions.py

@@ -1,3 +1,5 @@
+from typing import List
+from backend.models.dtos.team_dto import ProjectTeamPairDTOList
 from databases import Database
 from fastapi import APIRouter, BackgroundTasks, Body, Depends, Request
 from fastapi.responses import JSONResponse
@@ -407,3 +409,213 @@ async def message_team(
         )
     except ValueError as e:
         return JSONResponse(content={"Error": str(e)}, status_code=400)
+
+
+@router.delete("/projects/{project_id}/teams/{team_id}/")
+async def remove_team_from_project(
+    project_id: int,
+    team_id: int,
+    request: Request,
+    user: AuthUserDTO = Depends(login_required),
+    db: Database = Depends(get_db),
+):
+    """
+    Unlink a Team from a Project.
+    """
+    permitted = await TeamService.is_user_team_manager(team_id, user.id, db)
+    if not permitted:
+        return JSONResponse(
+            {
+                "Error": "User is not a manager of the team",
+                "SubCode": "UserPermissionError",
+            },
+            status_code=403,
+        )
+
+    deny_resp = await TeamService.ensure_unlink_allowed(project_id, team_id, db)
+    if deny_resp:
+        return deny_resp
+
+    try:
+        deleted = await TeamService.unlink_team(project_id, team_id, db)
+        if not deleted:
+            return JSONResponse(
+                {"Error": "No such team linked to project", "SubCode": "NotFoundError"},
+                status_code=404,
+            )
+        return JSONResponse({"Success": True}, status_code=200)
+    except Exception as e:
+        return JSONResponse(
+            {"Error": "Internal server error", "Details": str(e)},
+            status_code=500,
+        )
+
+
+@router.delete("/projects/teams/{team_id}/unlink")
+async def remove_team_from_all_projects(
+    team_id: int,
+    request: Request,
+    user: AuthUserDTO = Depends(login_required),
+    db: Database = Depends(get_db),
+):
+    """
+    Unlink the given team from all projects it is assigned to.
+
+    Steps:
+    - ensure caller is a manager of the team
+    - fetch all project_ids for the team from project_teams
+    - run ensure_unlink_allowed(project_id, team_id, db) for every project
+    - if all checks pass, unlink each (inside one DB transaction)
+    """
+    permitted = await TeamService.is_user_team_manager(team_id, user.id, db)
+    if not permitted:
+        return JSONResponse(
+            {
+                "Error": (
+                    f"Cannot unlink team with team id-{team_id}: "
+                    f"user {user.id} is not a manager of the team"
+                ),
+                "SubCode": "UserPermissionError",
+            },
+            status_code=403,
+        )
+
+    rows = await db.fetch_all(
+        "SELECT project_id FROM project_teams WHERE team_id = :tid",
+        {"tid": team_id},
+    )
+    project_ids: List[int] = [r["project_id"] for r in rows] if rows else []
+
+    if not project_ids:
+        return JSONResponse(
+            {
+                "Error": (
+                    f"Cannot unlink team with team id-{team_id}: "
+                    "team is not linked to any projects"
+                ),
+                "SubCode": "NotFoundError",
+            },
+            status_code=404,
+        )
+
+    for pid in project_ids:
+        deny_resp = await TeamService.ensure_unlink_allowed(pid, team_id, db)
+        if deny_resp:
+            return deny_resp
+
+    try:
+        async with db.transaction():
+            for pid in project_ids:
+                deleted = await TeamService.unlink_team(pid, team_id, db)
+                if not deleted:
+                    raise RuntimeError(f"NOT_FOUND:{pid}:{team_id}")
+
+        projects_str = ", ".join(str(p) for p in project_ids)
+        return JSONResponse(
+            {
+                "Success": True,
+                "Message": (
+                    f"Team id-{team_id} unlinked from projects: {projects_str}"
+                ),
+            },
+            status_code=200,
+        )
+
+    except Exception as e:
+        return JSONResponse(
+            {
+                "Error": (
+                    f"Cannot unlink team with team id-{team_id}: internal server error - {str(e)}"
+                ),
+                "SubCode": "InternalServerError",
+            },
+            status_code=500,
+        )
+
+
+@router.delete("/projects/unlink")
+async def remove_teams_from_projects(
+    payload: ProjectTeamPairDTOList,
+    request: Request,
+    user: AuthUserDTO = Depends(login_required),
+    db: Database = Depends(get_db),
+):
+    """
+    Bulk unlink teams from projects.
+
+    Body:
+    {
+      "items": [
+        {"project_id": 1442, "team_id": 43},
+        {"project_id": 2000, "team_id": 55}
+      ]
+    }
+
+    First: run all checks for all items (manager check + ensure_unlink_allowed).
+    If any check fails, return error immediately and do NOT modify DB.
+    If all checks pass, perform unlink operations inside a single DB transaction.
+    """
+    items = payload.items or []
+    if not items:
+        return JSONResponse(
+            {"Error": "No project/team pairs provided", "SubCode": "InvalidRequest"},
+            status_code=400,
+        )
+
+    seen = set()
+    pairs = []
+    for it in items:
+        key = (it.project_id, it.team_id)
+        if key in seen:
+            continue
+        seen.add(key)
+        pairs.append(it)
+
+    for it in pairs:
+        pid = it.project_id
+        tid = it.team_id
+
+        permitted = await TeamService.is_user_team_manager(tid, user.id, db)
+        if not permitted:
+            return JSONResponse(
+                {
+                    "Error": (
+                        f"Cannot unlink team with team id-{tid}: user {user.id} is not a manager of the team"
+                    ),
+                    "SubCode": "UserPermissionError",
+                },
+                status_code=403,
+            )
+
+        deny_resp = await TeamService.ensure_unlink_allowed(pid, tid, db)
+        if deny_resp:
+            return deny_resp
+
+    try:
+        async with db.transaction():
+            for it in pairs:
+                pid = it.project_id
+                tid = it.team_id
+
+                deleted = await TeamService.unlink_team(pid, tid, db)
+                if not deleted:
+                    raise RuntimeError(f"NOT_FOUND:{pid}:{tid}")
+
+        pairs_str = ", ".join(
+            [f"(project {p.project_id}, team {p.team_id})" for p in pairs]
+        )
+        return JSONResponse(
+            {
+                "Success": True,
+                "Message": f"Unlinked teams: {pairs_str}",
+            },
+            status_code=200,
+        )
+    except Exception as e:
+        return JSONResponse(
+            {
+                "Error": f"Cannot unlink teams: internal server error - {str(e)}",
+                "SubCode": "InternalServerError",
+            },
+            status_code=500,
+        )

backend/models/dtos/team_dto.py

@@ -247,3 +247,12 @@ class TeamSearchDTO(BaseModel):
 
     class Config:
         populate_by_name = True
+
+
+class ProjectTeamPairDTO(BaseModel):
+    project_id: int
+    team_id: int
+
+
+class ProjectTeamPairDTOList(BaseModel):
+    items: List[ProjectTeamPairDTO]