[ADD] war room task subtasks + tag/status filters — parent_task_id column & indexes, war_room_task_used_tags helper, list endpoint accepts q/status_id/tag/parent_task_id, business layer enforces single-level nesting and same-room parent

Author: whitekernel

source/app/alembic/versions/d5e6f7a8b9c0_add_war_room_task_parent_and_indexes.py

@@ -0,0 +1,74 @@
+"""Add parent_task_id + search indexes on war_room_task.
+
+Subtasks are single-level: a war-room task may point at another
+war-room task in the same room via `parent_task_id`. Enforcement of
+the "no grand-children" rule lives in the business layer (a task
+that is itself a child cannot be given children) so the DB stays
+simple. `ON DELETE CASCADE` on the FK: removing a parent removes its
+subtasks, matching the UX expectation ("delete a task, delete its
+subtasks").
+
+Also adds three helper indexes used by the new search/filter list:
+- `parent_task_id` for expand-children lookups
+- `status_id` for status-filter scans
+- `war_room_id, parent_task_id` composite to cheaply pull the
+  top-level tree on the tasks page (parent_task_id IS NULL).
+
+Idempotent via `_has_table` / `_table_has_column` so re-running on
+environments that already applied the migration is a no-op.
+
+Revision ID: d5e6f7a8b9c0
+Revises: c3d4e5f6a9b0
+Create Date: 2026-07-13 10:00:00.000000
+"""
+import sqlalchemy as sa
+from alembic import op
+
+from app.alembic.alembic_utils import _has_table, _table_has_column
+
+
+revision = 'd5e6f7a8b9c0'
+down_revision = 'c3d4e5f6a9b0'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    if not _has_table('war_room_task'):
+        return
+
+    if not _table_has_column('war_room_task', 'parent_task_id'):
+        op.add_column(
+            'war_room_task',
+            sa.Column(
+                'parent_task_id', sa.BigInteger(),
+                sa.ForeignKey('war_room_task.task_id', ondelete='CASCADE'),
+                nullable=True,
+            ),
+        )
+        op.create_index(
+            'ix_war_room_task_parent_task_id',
+            'war_room_task',
+            ['parent_task_id'],
+        )
+
+    op.execute(
+        'CREATE INDEX IF NOT EXISTS ix_war_room_task_status_id '
+        'ON war_room_task (status_id)'
+    )
+    op.execute(
+        'CREATE INDEX IF NOT EXISTS ix_war_room_task_war_room_parent '
+        'ON war_room_task (war_room_id, parent_task_id)'
+    )
+
+
+def downgrade():
+    if not _has_table('war_room_task'):
+        return
+
+    op.execute('DROP INDEX IF EXISTS ix_war_room_task_war_room_parent')
+    op.execute('DROP INDEX IF EXISTS ix_war_room_task_status_id')
+
+    if _table_has_column('war_room_task', 'parent_task_id'):
+        op.execute('DROP INDEX IF EXISTS ix_war_room_task_parent_task_id')
+        op.drop_column('war_room_task', 'parent_task_id')

source/app/blueprints/rest/v2/war_rooms/tasks.py

@@ -26,6 +26,7 @@
     war_room_task_list,
     war_room_task_reopen,
     war_room_task_update,
+    war_room_task_used_tags,
 )
 from app.models.errors import BusinessProcessingError
 from app.models.errors import ObjectNotFoundError
@@ -52,13 +53,47 @@ def _parse_due(raw):
         raise BusinessProcessingError('due_at must be an ISO date string')
 
 
+def _parse_int_list(raw):
+    """Parse a repeatable query-string int param into a list.
+
+    Accepts `?status_id=1&status_id=2` or `?status_id=1,2`. Silently
+    drops non-integer entries so a bad tag doesn't 400 the whole list
+    call.
+    """
+    if raw is None:
+        return []
+    if isinstance(raw, list):
+        parts = raw
+    else:
+        parts = [p for p in str(raw).split(',') if p]
+    out = []
+    for p in parts:
+        try:
+            out.append(int(p))
+        except (TypeError, ValueError):
+            continue
+    return out
+
+
+def _parse_str_list(raw):
+    if raw is None:
+        return []
+    if isinstance(raw, list):
+        parts = raw
+    else:
+        parts = str(raw).split(',')
+    return [p.strip() for p in parts if p and p.strip()]
+
+
 def _serialize_row(row):
     return {
         'task_id': row.task_id,
         'war_room_id': row.war_room_id,
         'title': row.title,
         'description': row.description,
         'status_id': row.status_id,
+        'status_name': getattr(row, 'status_name', None),
+        'status_bscolor': getattr(row, 'status_bscolor', None),
         'assignee_id': row.assignee_id,
         'assignee_login': row.assignee_login,
         'assignee_name': row.assignee_name,
@@ -76,36 +111,173 @@ def _serialize_row(row):
         'closed_by_login': getattr(row, 'closed_by_login', None),
         'closed_by_name': getattr(row, 'closed_by_name', None),
         'tags': row.tags,
+        'parent_task_id': getattr(row, 'parent_task_id', None),
     }
 
 
 def _serialize_obj(task):
+    """Serialize a plain `WarRoomTask` row (no join info).
+
+    Used by the mutation endpoints. Status name / actor logins are
+    resolved via a light relationship lookup so the SPA doesn't have
+    to re-request the row after every write.
+    """
+    status_name = task.status.status_name if task.status else None
+    status_bscolor = task.status.status_bscolor if task.status else None
+    assignee = task.assignee
+    creator = task.created_by
+    closer = task.closed_by
     return {
         'task_id': task.task_id,
         'war_room_id': task.war_room_id,
         'title': task.title,
         'description': task.description,
         'status_id': task.status_id,
+        'status_name': status_name,
+        'status_bscolor': status_bscolor,
         'assignee_id': task.assignee_id,
+        'assignee_login': assignee.user if assignee else None,
+        'assignee_name': assignee.name if assignee else None,
         'due_at': task.due_at.isoformat() if task.due_at else None,
         'source_case_id': task.source_case_id,
         'source_case_task_id': task.source_case_task_id,
         'created_at': task.created_at.isoformat() if task.created_at else None,
         'created_by_id': task.created_by_id,
+        'created_by_login': creator.user if creator else None,
+        'created_by_name': creator.name if creator else None,
         'closed_at': task.closed_at.isoformat() if task.closed_at else None,
         'closed_by_id': task.closed_by_id,
+        'closed_by_login': closer.user if closer else None,
+        'closed_by_name': closer.name if closer else None,
         'tags': task.tags,
+        'parent_task_id': getattr(task, 'parent_task_id', None),
     }
 
 
+def _parse_bool(raw, default=True):
+    if raw is None:
+        return default
+    return str(raw).strip().lower() not in ('0', 'false', 'no', 'off')
+
+
+def _parse_date_arg(raw):
+    """Parse an ISO date/datetime string; returns None if empty/invalid.
+
+    Kept lenient — a bad value silently drops the endpoint rather
+    than 400-ing the whole list. That matches the tolerance of the
+    other filter parsers on this endpoint.
+    """
+    if not raw:
+        return None
+    s = str(raw).strip()
+    if not s:
+        return None
+    try:
+        if len(s) == 10:
+            return datetime.fromisoformat(s)
+        return datetime.fromisoformat(s.replace('Z', '+00:00'))
+    except ValueError:
+        return None
+
+
 @war_rooms_tasks_blueprint.get('')
 @ac_api_requires()
 def list_tasks(war_room_id):
     err = require_war_room_read(war_room_id)
     if err is not None:
         return err
-    rows = war_room_task_list(war_room_id)
-    return response_api_success(data=[_serialize_row(r) for r in rows])
+    q = request.args.get('q') or None
+    status_ids = _parse_int_list(request.args.getlist('status_id')
+                                  or request.args.get('status_id'))
+    assignee_ids_raw = (request.args.getlist('assignee_id')
+                        or request.args.get('assignee_id'))
+    # Accept `0` to mean Unassigned; parse ints then reinject the flag.
+    assignee_ids = []
+    if assignee_ids_raw:
+        if isinstance(assignee_ids_raw, list):
+            parts = assignee_ids_raw
+        else:
+            parts = str(assignee_ids_raw).split(',')
+        for p in parts:
+            p = str(p).strip().lower()
+            if p in ('0', 'unassigned', 'null', 'none'):
+                assignee_ids.append(0)
+                continue
+            try:
+                assignee_ids.append(int(p))
+            except ValueError:
+                continue
+    tags = _parse_str_list(request.args.getlist('tag')
+                            or request.args.get('tag'))
+    parent = request.args.get('parent_task_id')
+    if parent is None:
+        parent_task_id = -1
+    else:
+        p = str(parent).strip().lower()
+        if p in ('', 'null', 'none', 'top', 'root'):
+            parent_task_id = 0
+        else:
+            try:
+                parent_task_id = int(p)
+            except ValueError:
+                parent_task_id = -1
+    include_closed = _parse_bool(request.args.get('include_closed'), True)
+    due_from = _parse_date_arg(request.args.get('due_from'))
+    due_to = _parse_date_arg(request.args.get('due_to'))
+    include_no_due = _parse_bool(request.args.get('include_no_due'), True)
+
+    # Pagination is opt-in: `page` present → return the envelope;
+    # absent → return the raw array (back-compat with earlier callers).
+    page_raw = request.args.get('page')
+    if page_raw is None:
+        rows = war_room_task_list(
+            war_room_id,
+            q=q,
+            status_ids=status_ids or None,
+            tags=tags or None,
+            assignee_ids=assignee_ids or None,
+            parent_task_id=parent_task_id,
+            due_from=due_from,
+            due_to=due_to,
+            include_no_due=include_no_due,
+            include_closed=include_closed,
+        )
+        return response_api_success(data=[_serialize_row(r) for r in rows])
+
+    try:
+        page = int(page_raw)
+    except (TypeError, ValueError):
+        page = 1
+    try:
+        per_page = int(request.args.get('per_page', 25))
+    except (TypeError, ValueError):
+        per_page = 25
+    envelope = war_room_task_list(
+        war_room_id,
+        q=q,
+        status_ids=status_ids or None,
+        tags=tags or None,
+        assignee_ids=assignee_ids or None,
+        parent_task_id=parent_task_id,
+        due_from=due_from,
+        due_to=due_to,
+        include_no_due=include_no_due,
+        include_closed=include_closed,
+        page=page,
+        per_page=per_page,
+    )
+    envelope['data'] = [_serialize_row(r) for r in envelope['data']]
+    return response_api_success(data=envelope)
+
+
+@war_rooms_tasks_blueprint.get('/tags')
+@ac_api_requires()
+def list_used_tags(war_room_id):
+    """Distinct tag values already in use in this war room."""
+    err = require_war_room_read(war_room_id)
+    if err is not None:
+        return err
+    return response_api_success(data=war_room_task_used_tags(war_room_id))
 
 
 @war_rooms_tasks_blueprint.post('')
@@ -129,6 +301,7 @@ def create_task(war_room_id):
             source_case_id=raw.get('source_case_id'),
             source_case_task_id=raw.get('source_case_task_id'),
             tags=raw.get('tags'),
+            parent_task_id=raw.get('parent_task_id'),
             created_by_id=iris_current_user.id,
         )
     except BusinessProcessingError as e:
@@ -154,9 +327,11 @@ def update_task(war_room_id, task_id):
     try:
         fields = {k: raw[k] for k in raw if k in
                   ('title', 'description', 'status_id', 'assignee_id',
-                   'source_case_id', 'source_case_task_id', 'tags')}
+                   'source_case_id', 'source_case_task_id', 'tags',
+                   'parent_task_id')}
         if 'due_at' in raw:
             fields['due_at'] = _parse_due(raw['due_at'])
+        fields['updated_by_id'] = iris_current_user.id
         task = war_room_task_update(war_room_id, task_id, **fields)
     except ObjectNotFoundError:
         return response_api_not_found()