fix: enhance bulk removal functionality across various CRUD operations and add tests for it

Author: x0sina

app/db/crud/admin.py

@@ -1,7 +1,7 @@
 from datetime import datetime, timezone
 from enum import Enum
 
-from sqlalchemy import and_, case, delete, func, select
+from sqlalchemy import and_, case, delete, func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.crud.general import (
@@ -560,5 +560,7 @@ async def remove_admins(db: AsyncSession, admin_ids: list[int]) -> None:
     if not admin_ids:
         return
 
+    await db.execute(update(User).where(User.admin_id.in_(admin_ids)).values(admin_id=None))
+    await db.execute(delete(AdminUsageLogs).where(AdminUsageLogs.admin_id.in_(admin_ids)))
     await db.execute(delete(Admin).where(Admin.id.in_(admin_ids)))
     await db.commit()

app/db/crud/client_template.py

@@ -159,6 +159,7 @@ async def get_first_template_by_type(
     db: AsyncSession,
     template_type: ClientTemplateType,
     exclude_id: int | None = None,
+    exclude_ids: list[int] | set[int] | None = None,
 ) -> ClientTemplate | None:
     stmt = (
         select(ClientTemplate)
@@ -167,6 +168,8 @@ async def get_first_template_by_type(
     )
     if exclude_id is not None:
         stmt = stmt.where(ClientTemplate.id != exclude_id)
+    if exclude_ids:
+        stmt = stmt.where(ClientTemplate.id.not_in(list(exclude_ids)))
     return (await db.execute(stmt)).scalars().first()
 
 

app/db/crud/core.py

@@ -1,9 +1,9 @@
 from enum import Enum
 
-from sqlalchemy import delete, func, select
+from sqlalchemy import delete, func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.db.models import CoreConfig
+from app.db.models import CoreConfig, Node
 from app.models.core import CoreCreate
 
 CoreSortingOptionsSimple = Enum(
@@ -186,5 +186,6 @@ async def remove_cores(db: AsyncSession, core_ids: list[int]) -> None:
     if not core_ids:
         return
 
+    await db.execute(update(Node).where(Node.core_config_id.in_(core_ids)).values(core_config_id=None))
     await db.execute(delete(CoreConfig).where(CoreConfig.id.in_(core_ids)))
     await db.commit()

app/db/crud/group.py

@@ -3,7 +3,13 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
 
-from app.db.models import ProxyInbound, Group, users_groups_association
+from app.db.models import (
+    Group,
+    ProxyInbound,
+    inbounds_groups_association,
+    template_group_association,
+    users_groups_association,
+)
 from app.models.group import GroupCreate, GroupModify
 
 from .host import upsert_inbounds
@@ -257,8 +263,8 @@ async def remove_groups(db: AsyncSession, group_ids: list[int]) -> None:
     if not group_ids:
         return
 
-    # Delete user-group associations first
     await db.execute(delete(users_groups_association).where(users_groups_association.c.groups_id.in_(group_ids)))
-    # Then delete groups
+    await db.execute(delete(template_group_association).where(template_group_association.c.group_id.in_(group_ids)))
+    await db.execute(delete(inbounds_groups_association).where(inbounds_groups_association.c.group_id.in_(group_ids)))
     await db.execute(delete(Group).where(Group.id.in_(group_ids)))
     await db.commit()

app/db/crud/node.py

@@ -830,5 +830,9 @@ async def remove_nodes(db: AsyncSession, node_ids: list[int]) -> None:
     if not node_ids:
         return
 
+    await db.execute(delete(NodeUserUsage).where(NodeUserUsage.node_id.in_(node_ids)))
+    await db.execute(delete(NodeUsage).where(NodeUsage.node_id.in_(node_ids)))
+    await db.execute(delete(NodeUsageResetLogs).where(NodeUsageResetLogs.node_id.in_(node_ids)))
+    await db.execute(delete(NodeStat).where(NodeStat.node_id.in_(node_ids)))
     await db.execute(delete(Node).where(Node.id.in_(node_ids)))
     await db.commit()

app/db/crud/user_template.py

@@ -1,10 +1,10 @@
 from typing import Union, List
 from enum import Enum
 
-from sqlalchemy import delete, func, select
+from sqlalchemy import delete, func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.db.models import UserTemplate
+from app.db.models import NextPlan, UserTemplate, template_group_association
 from app.models.user_template import UserTemplateCreate, UserTemplateModify
 
 from .group import get_groups_by_ids
@@ -234,5 +234,9 @@ async def remove_user_templates(db: AsyncSession, template_ids: list[int]) -> No
     if not template_ids:
         return
 
+    await db.execute(
+        delete(template_group_association).where(template_group_association.c.user_template_id.in_(template_ids))
+    )
+    await db.execute(update(NextPlan).where(NextPlan.user_template_id.in_(template_ids)).values(user_template_id=None))
     await db.execute(delete(UserTemplate).where(UserTemplate.id.in_(template_ids)))
     await db.commit()

app/operation/client_template.py

@@ -236,15 +236,8 @@ async def bulk_remove_client_templates(
         for template_type, templates_of_type in templates_by_type.items():
             defaults_to_replace = [t for t in templates_of_type if t.is_default]
             if defaults_to_replace:
-                # Get replacement for this type (exclude all templates being deleted)
                 exclude_ids = {t.id for t in templates_of_type}
-                replacement = await get_first_template_by_type(db, template_type, exclude_id=None)
-                # Find first non-deleted template
-                for candidate_id in [t.id for t in templates_of_type if not t.is_default]:
-                    if candidate_id not in exclude_ids:
-                        replacement = await self.get_validated_client_template(db, candidate_id)
-                        break
-
+                replacement = await get_first_template_by_type(db, template_type, exclude_ids=exclude_ids)
                 if replacement:
                     await set_default_template(db, replacement)