From ccfe065979ee3822be872ce96bbb9d1183794ea1 Mon Sep 17 00:00:00 2001 From: Ashwin Date: Wed, 12 Aug 2026 08:06:00 +0530 Subject: [PATCH] feat(tickets): implement bulk update and delete actions for tickets - Added bulkUpdate and bulkDelete actions in the tickets server-side logic. - Enhanced the tickets Svelte component to support bulk selection and actions. - Introduced a BulkActionBar component for managing selected tickets. - Updated the tickets API configuration for bulk operations in the mobile app. - Implemented bulk update and delete methods in the mobile tickets provider. - Created unit tests for bulk update and delete functionalities in both mobile and frontend. - Added UI tests for ticket selection and bulk actions in the mobile app. --- backend/cases/bulk_views.py | 200 ++++-- backend/cases/tests/test_cases_bulk.py | 304 +++++++++ frontend/src/lib/server/v2/bulk-form.js | 21 + .../src/lib/server/v2/tickets-bulk.test.js | 26 + frontend/src/lib/server/v2/tickets.js | 48 ++ .../lib/v2/components/BulkActionBar.svelte | 153 +++++ .../src/routes/(app)/tickets/+page.server.js | 26 +- .../src/routes/(app)/tickets/+page.svelte | 72 +++ .../(app)/tickets/tickets-actions.test.js | 47 ++ mobile/lib/config/api_config.dart | 11 +- mobile/lib/providers/tickets_provider.dart | 38 ++ .../screens/tickets/tickets_list_screen.dart | 578 ++++++++++++++++-- mobile/test/unit/tickets_bulk_test.dart | 105 ++++ .../test/widgets/tickets_selection_test.dart | 269 ++++++++ 14 files changed, 1809 insertions(+), 89 deletions(-) create mode 100644 frontend/src/lib/server/v2/bulk-form.js create mode 100644 frontend/src/lib/server/v2/tickets-bulk.test.js create mode 100644 frontend/src/lib/v2/components/BulkActionBar.svelte create mode 100644 frontend/src/routes/(app)/tickets/tickets-actions.test.js create mode 100644 mobile/test/unit/tickets_bulk_test.dart create mode 100644 mobile/test/widgets/tickets_selection_test.dart diff --git a/backend/cases/bulk_views.py b/backend/cases/bulk_views.py index 4e52275e..a1ccb81c 100644 --- a/backend/cases/bulk_views.py +++ b/backend/cases/bulk_views.py @@ -1,5 +1,7 @@ """Bulk update / bulk delete endpoints for the Cases module.""" +import uuid + from django.core.exceptions import ValidationError from django.db import transaction from rest_framework import status @@ -7,6 +9,7 @@ from rest_framework.permissions import IsAuthenticated from rest_framework.response import Response from rest_framework.views import APIView +from cases.access import has_case_write_access, is_org_admin from cases.models import Case from common.models import Activity, Profile, Tags from common.permissions import HasOrgContext @@ -14,18 +17,69 @@ from common.permissions import HasOrgContext ALLOWED_FIELDS = {"status", "priority", "case_type", "closed_on"} ALLOWED_M2M = {"assigned_to": Profile, "tags": Tags} +# Scalar fields whose value must be one of the model's declared choices. A raw +# `setattr` + `save()` skips both DRF's ChoiceField and the model's `clean_fields`, +# so without this an authenticated caller could persist an off-enum status. +_CHOICE_FIELDS = ("status", "priority", "case_type") + + +def _valid_ids(raw): + """Keep only the well-formed UUIDs from a client-supplied `ids` list. + + Case PKs are UUIDs, so `Case.objects.filter(pk__in=ids)` raises a + ValidationError (a 500) the moment the queryset is evaluated on a value + like "not-a-uuid". That evaluation happens in the bulk loops, outside any + try/except, so a single malformed id in the request body would crash the + whole call. A malformed id names no real case, so drop it here: this + matches how a well-formed-but-nonexistent or other-org id already produces + no result row rather than an error. + """ + ids = [] + for value in raw if isinstance(raw, (list, tuple)) else []: + try: + ids.append(str(uuid.UUID(str(value)))) + except (ValueError, TypeError, AttributeError): + continue + return ids + + +def _close_gate_outcome(case_id, exc): + """Map a `Case.clean()` ValidationError to a per-record outcome. + + Keyed on the message dict's field name, not its text, so wording changes do + not move a ticket into the wrong bucket. `status` is the approval error, + `closed_on` is the missing-date error, anything else is a generic invalid. + """ + detail = ( + exc.message_dict if hasattr(exc, "message_dict") else {"error": exc.messages} + ) + if "status" in detail: + return { + "id": case_id, + "status": "approval_required", + "detail": detail["status"], + } + if "closed_on" in detail: + return {"id": case_id, "status": "closed_on_required"} + return {"id": case_id, "status": "invalid", "detail": detail} + class BulkUpdateCasesView(APIView): permission_classes = (IsAuthenticated, HasOrgContext) def post(self, request): - ids = request.data.get("ids") or [] + ids = _valid_ids(request.data.get("ids")) fields = request.data.get("fields") or {} if not ids: return Response( {"error": True, "errors": "ids required"}, status=status.HTTP_400_BAD_REQUEST, ) + if not fields: + return Response( + {"error": True, "errors": "fields required"}, + status=status.HTTP_400_BAD_REQUEST, + ) unknown = set(fields) - ALLOWED_FIELDS - set(ALLOWED_M2M) if unknown: @@ -34,47 +88,91 @@ class BulkUpdateCasesView(APIView): status=status.HTTP_400_BAD_REQUEST, ) + for field_name in _CHOICE_FIELDS: + if field_name not in fields: + continue + value = fields[field_name] + model_field = Case._meta.get_field(field_name) + valid_values = {choice for choice, _ in model_field.choices} + # `value in valid_values` would raise TypeError (500) on an + # unhashable payload like `{"status": ["Closed"]}`, so gate the + # membership test on a string first: a list/dict/number is simply + # an invalid value and gets the clean 400. + if isinstance(value, str) and value in valid_values: + continue + if value is None and model_field.null: + continue + return Response( + {"error": True, "errors": f"Invalid value for '{field_name}'"}, + status=status.HTTP_400_BAD_REQUEST, + ) + + # `closed_on` is a scalar date, not a choice field, so it skips the loop + # above. A non-string payload would setattr onto the model and blow up at + # `save()` as a DB error (500). Reject it here with the same clean 400. + if "closed_on" in fields: + closed_on = fields["closed_on"] + if closed_on is not None and not isinstance(closed_on, str): + return Response( + {"error": True, "errors": "Invalid value for 'closed_on'"}, + status=status.HTTP_400_BAD_REQUEST, + ) + scalar_updates = {k: v for k, v in fields.items() if k in ALLOWED_FIELDS} m2m_updates = {k: v for k, v in fields.items() if k in ALLOWED_M2M} org = request.profile.org - qs = Case.objects.filter(pk__in=ids, org=org) - - try: - with transaction.atomic(): - updated_count = 0 - for case in qs: - changed = False + results = [] + updated_count = 0 + for case in Case.objects.filter(pk__in=ids, org=org): + # Per-case authorization, mirroring the single-case PUT path + # (`CaseDetailView.put` calls `assert_case_write_access`). Without + # this any org member could edit, reassign or close any case in + # the org. Cases the caller may not write are reported as + # `no_access` rather than silently skipped, so the caller can see + # which of their selected tickets were denied. + if not has_case_write_access(request.profile, case): + results.append({"id": str(case.pk), "status": "no_access"}) + continue + try: + # A savepoint per case, so a blocked close rolls back only + # itself and the rest of the batch still commits. + with transaction.atomic(): for k, v in scalar_updates.items(): setattr(case, k, v) - changed = True - if changed: + if scalar_updates: + # `Case.clean()` carries the close-transition guard: a + # `closed_on` is required and, where a pre_close + # ApprovalRule matches, a recorded approval is too. A + # raw `save()` skips it, which is how the bulk path + # let a case be closed with no approval; the + # single-case path runs the same rule through the + # serializer. + case.clean() case.save() for m2m_field, model in ALLOWED_M2M.items(): - if m2m_field in m2m_updates: - related_ids = m2m_updates[m2m_field] or [] - related = list( - model.objects.filter(pk__in=related_ids, org=org) - ) - getattr(case, m2m_field).set(related) - changed = True - if changed: - updated_count += 1 - except ValidationError as exc: - return Response( - { - "error": True, - "errors": ( - exc.message_dict - if hasattr(exc, "message_dict") - else exc.messages - ), - }, - status=status.HTTP_400_BAD_REQUEST, - ) + if m2m_field not in m2m_updates: + continue + related_ids = m2m_updates[m2m_field] or [] + related = list( + model.objects.filter(pk__in=related_ids, org=org) + ) + manager = getattr(case, m2m_field) + if m2m_field == "tags": + # Append: bulk-tagging must not wipe a ticket's + # other tags. Reassign (`assigned_to`) still + # replaces. + manager.add(*related) + else: + manager.set(related) + except ValidationError as exc: + results.append(_close_gate_outcome(str(case.pk), exc)) + continue + results.append({"id": str(case.pk), "status": "updated"}) + updated_count += 1 return Response( - {"error": False, "updated": updated_count}, + {"error": False, "updated": updated_count, "results": results}, status=status.HTTP_200_OK, ) @@ -83,34 +181,50 @@ class BulkDeleteCasesView(APIView): permission_classes = (IsAuthenticated, HasOrgContext) def post(self, request): - ids = request.data.get("ids") or [] + ids = _valid_ids(request.data.get("ids")) if not ids: return Response( {"error": True, "errors": "ids required"}, status=status.HTTP_400_BAD_REQUEST, ) org = request.profile.org - # Snapshot the cases so we can emit Activity rows after the bulk update - # ; queryset.update() bypasses signals. - qs = Case.objects.filter(pk__in=ids, org=org, is_active=True) - target_cases = list(qs.values("id", "name")) - deleted_count = qs.update(is_active=False) - if target_cases: + admin = is_org_admin(request.profile) + results = [] + deletable = [] + # Deleting is admin-or-creator only (`assert_case_delete_access`); an + # assignee may work a ticket but not erase it. + for row in Case.objects.filter(pk__in=ids, org=org, is_active=True).values( + "id", "name", "created_by_id" + ): + if admin or row["created_by_id"] == request.profile.user_id: + deletable.append(row) + else: + results.append({"id": str(row["id"]), "status": "no_access"}) + + deleted_count = 0 + if deletable: + deleted_count = Case.objects.filter( + id__in=[row["id"] for row in deletable] + ).update(is_active=False) + # queryset.update() bypasses signals, so emit Activity rows here. Activity.objects.bulk_create( [ Activity( user=request.profile, action="DELETE", entity_type="Case", - entity_id=case["id"], - entity_name=(case["name"] or "")[:255], + entity_id=row["id"], + entity_name=(row["name"] or "")[:255], metadata={"bulk": True}, org_id=org.id, ) - for case in target_cases + for row in deletable ] ) + for row in deletable: + results.append({"id": str(row["id"]), "status": "deleted"}) + return Response( - {"error": False, "deleted": deleted_count}, + {"error": False, "deleted": deleted_count, "results": results}, status=status.HTTP_200_OK, ) diff --git a/backend/cases/tests/test_cases_bulk.py b/backend/cases/tests/test_cases_bulk.py index b01e9e41..970b4e22 100644 --- a/backend/cases/tests/test_cases_bulk.py +++ b/backend/cases/tests/test_cases_bulk.py @@ -2,6 +2,8 @@ import pytest +from cases.approvals import ApprovalRule +from cases.models import Case from conftest import rls_org @@ -65,6 +67,237 @@ class TestBulkUpdateCases: ) assert response.status_code == 400 + def test_bulk_update_rejects_off_enum_status(self, admin_client, case_a): + response = admin_client.post( + "/api/cases/bulk/update/", + {"ids": [str(case_a.pk)], "fields": {"status": "Hacked"}}, + content_type="application/json", + ) + assert response.status_code == 400 + case_a.refresh_from_db() + assert case_a.status == "New" + + def test_bulk_update_rejects_nonstring_choice_value(self, admin_client, case_a): + # A crafted unhashable payload must be a clean 400, not a 500 from + # `value in valid_values` raising TypeError on a list. + response = admin_client.post( + "/api/cases/bulk/update/", + {"ids": [str(case_a.pk)], "fields": {"status": ["Closed"]}}, + content_type="application/json", + ) + assert response.status_code == 400 + case_a.refresh_from_db() + assert case_a.status == "New" + + def test_bulk_update_rejects_nonstring_closed_on(self, admin_client, case_a): + # `closed_on` is a scalar date; a non-string payload must 400 here rather + # than reach `save()` and surface as a 500 DB error. + response = admin_client.post( + "/api/cases/bulk/update/", + { + "ids": [str(case_a.pk)], + "fields": {"status": "Closed", "closed_on": ["2026-05-09"]}, + }, + content_type="application/json", + ) + assert response.status_code == 400 + case_a.refresh_from_db() + assert case_a.status == "New" + + def test_bulk_update_malformed_id_is_not_500(self, admin_client): + # A malformed UUID in `ids` must not crash the query. It names no real + # case, so it drops out and the request reads as "no valid ids" (400), + # never a 500 from `pk__in` raising ValidationError. + response = admin_client.post( + "/api/cases/bulk/update/", + {"ids": ["not-a-uuid"], "fields": {"status": "Pending"}}, + content_type="application/json", + ) + assert response.status_code == 400 + + def test_bulk_update_drops_malformed_id_keeps_valid(self, admin_client, case_a): + # A mix of one good and one malformed id processes the good one and + # silently ignores the garbage, matching how a nonexistent id behaves. + response = admin_client.post( + "/api/cases/bulk/update/", + { + "ids": [str(case_a.pk), "not-a-uuid"], + "fields": {"priority": "Urgent"}, + }, + content_type="application/json", + ) + assert response.status_code == 200 + assert response.json()["updated"] == 1 + case_a.refresh_from_db() + assert case_a.priority == "Urgent" + + +@pytest.mark.django_db +class TestBulkUpdateCasesAuthz: + """A regular member may only bulk-edit cases they may write.""" + + def test_non_writer_cannot_modify(self, user_client, case_a): + # `case_a` was created by admin_user; the regular member is neither its + # creator nor an assignee, so it must be left untouched. + response = user_client.post( + "/api/cases/bulk/update/", + {"ids": [str(case_a.pk)], "fields": {"priority": "Urgent"}}, + content_type="application/json", + ) + assert response.status_code == 200 + assert response.json()["updated"] == 0 + case_a.refresh_from_db() + assert case_a.priority == "High" + + def test_creator_can_modify_own_case(self, user_client, regular_user, org_a): + case = Case.objects.create( + name="My own case", + status="New", + priority="Low", + created_by=regular_user, + org=org_a, + ) + response = user_client.post( + "/api/cases/bulk/update/", + {"ids": [str(case.pk)], "fields": {"priority": "Urgent"}}, + content_type="application/json", + ) + assert response.status_code == 200 + assert response.json()["updated"] == 1 + case.refresh_from_db() + assert case.priority == "Urgent" + + +@pytest.mark.django_db +class TestBulkUpdateCasesCloseGate: + """Closing through the bulk path runs the same guard as the single case.""" + + def test_close_requires_closed_on(self, admin_client, case_a): + # Per-record outcomes mean a blocked close is now a 200 with a + # `closed_on_required` outcome for this ticket, not a request-level + # 400: see `TestBulkUpdatePerRecord.test_close_missing_date`. + response = admin_client.post( + "/api/cases/bulk/update/", + {"ids": [str(case_a.pk)], "fields": {"status": "Closed"}}, + content_type="application/json", + ) + assert response.status_code == 200 + body = response.json() + assert body["updated"] == 0 + assert body["results"][0]["status"] == "closed_on_required" + case_a.refresh_from_db() + assert case_a.status == "New" + + def test_close_requires_approval_when_rule_matches( + self, admin_client, case_a, org_a + ): + # A rule with no match filters applies to every case in the org. Per- + # record outcomes mean this is now a 200 with an `approval_required` + # outcome, not a request-level 400: see + # `TestBulkUpdatePerRecord.test_close_blocked_is_partial`. + ApprovalRule.objects.create( + name="Close gate", + org=org_a, + trigger_event="pre_close", + is_active=True, + ) + response = admin_client.post( + "/api/cases/bulk/update/", + { + "ids": [str(case_a.pk)], + "fields": {"status": "Closed", "closed_on": "2026-05-09"}, + }, + content_type="application/json", + ) + assert response.status_code == 200 + body = response.json() + assert body["updated"] == 0 + assert body["results"][0]["status"] == "approval_required" + case_a.refresh_from_db() + assert case_a.status == "New" + + +@pytest.mark.django_db +class TestBulkUpdatePerRecord: + def test_mixed_access_reports_both(self, user_client, regular_user, org_a, case_a): + # `case_a` was created by admin_user, so the regular member cannot write + # it. A case they own can be written. + mine = Case.objects.create( + name="Mine", + status="New", + priority="Low", + created_by=regular_user, + org=org_a, + ) + response = user_client.post( + "/api/cases/bulk/update/", + {"ids": [str(mine.pk), str(case_a.pk)], "fields": {"priority": "Urgent"}}, + content_type="application/json", + ) + assert response.status_code == 200 + body = response.json() + assert body["updated"] == 1 + by_id = {r["id"]: r["status"] for r in body["results"]} + assert by_id[str(mine.pk)] == "updated" + assert by_id[str(case_a.pk)] == "no_access" + + def test_close_blocked_is_partial( + self, admin_client, org_a, case_a, case_b_same_org + ): + ApprovalRule.objects.create( + name="Close gate", org=org_a, trigger_event="pre_close", is_active=True + ) + # A rule with no match filters applies to every case, so both closes are + # gated; both come back approval_required and neither is closed. + response = admin_client.post( + "/api/cases/bulk/update/", + { + "ids": [str(case_a.pk), str(case_b_same_org.pk)], + "fields": {"status": "Closed", "closed_on": "2026-05-09"}, + }, + content_type="application/json", + ) + assert response.status_code == 200 + body = response.json() + assert body["updated"] == 0 + assert {r["status"] for r in body["results"]} == {"approval_required"} + case_a.refresh_from_db() + assert case_a.status == "New" + + def test_close_missing_date(self, admin_client, case_a): + response = admin_client.post( + "/api/cases/bulk/update/", + {"ids": [str(case_a.pk)], "fields": {"status": "Closed"}}, + content_type="application/json", + ) + assert response.status_code == 200 + body = response.json() + assert body["results"][0]["status"] == "closed_on_required" + assert body["updated"] == 0 + + def test_tags_append_not_replace(self, admin_client, org_a, case_a): + from common.models import Tags + + keep = Tags.objects.create(name="keep", org=org_a) + add = Tags.objects.create(name="add", org=org_a) + case_a.tags.add(keep) + response = admin_client.post( + "/api/cases/bulk/update/", + {"ids": [str(case_a.pk)], "fields": {"tags": [str(add.pk)]}}, + content_type="application/json", + ) + assert response.status_code == 200 + case_a.refresh_from_db() + assert set(case_a.tags.values_list("name", flat=True)) == {"keep", "add"} + + def test_empty_fields_rejected(self, admin_client, case_a): + response = admin_client.post( + "/api/cases/bulk/update/", + {"ids": [str(case_a.pk)], "fields": {}}, + content_type="application/json", + ) + assert response.status_code == 400 + @pytest.mark.django_db class TestBulkDeleteCases: @@ -102,3 +335,74 @@ class TestBulkDeleteCases: content_type="application/json", ) assert response.status_code == 400 + + def test_bulk_delete_malformed_id_is_not_500(self, admin_client): + # Same malformed-id guard as bulk update: a bad UUID must 400, never + # 500 from the queryset raising ValidationError on `pk__in`. + response = admin_client.post( + "/api/cases/bulk/delete/", + {"ids": ["not-a-uuid"]}, + content_type="application/json", + ) + assert response.status_code == 400 + + +@pytest.mark.django_db +class TestBulkDeleteCasesAuthz: + """Deleting is admin-or-creator only; an assignee is not enough.""" + + def test_non_creator_cannot_delete(self, user_client, case_a): + response = user_client.post( + "/api/cases/bulk/delete/", + {"ids": [str(case_a.pk)]}, + content_type="application/json", + ) + assert response.status_code == 200 + assert response.json()["deleted"] == 0 + case_a.refresh_from_db() + assert case_a.is_active is True + + def test_creator_can_delete_own_case(self, user_client, regular_user, org_a): + case = Case.objects.create( + name="My own case", + status="New", + priority="Low", + created_by=regular_user, + org=org_a, + ) + response = user_client.post( + "/api/cases/bulk/delete/", + {"ids": [str(case.pk)]}, + content_type="application/json", + ) + assert response.status_code == 200 + assert response.json()["deleted"] == 1 + case.refresh_from_db() + assert case.is_active is False + + +@pytest.mark.django_db +class TestBulkDeletePerRecord: + def test_reports_deleted_and_no_access( + self, user_client, regular_user, org_a, case_a + ): + mine = Case.objects.create( + name="Mine", + status="New", + priority="Low", + created_by=regular_user, + org=org_a, + ) + response = user_client.post( + "/api/cases/bulk/delete/", + {"ids": [str(mine.pk), str(case_a.pk)]}, + content_type="application/json", + ) + assert response.status_code == 200 + body = response.json() + assert body["deleted"] == 1 + by_id = {r["id"]: r["status"] for r in body["results"]} + assert by_id[str(mine.pk)] == "deleted" + assert by_id[str(case_a.pk)] == "no_access" + case_a.refresh_from_db() + assert case_a.is_active is True diff --git a/frontend/src/lib/server/v2/bulk-form.js b/frontend/src/lib/server/v2/bulk-form.js new file mode 100644 index 00000000..8ee67c2c --- /dev/null +++ b/frontend/src/lib/server/v2/bulk-form.js @@ -0,0 +1,21 @@ +export const M2M_FIELDS = new Set(['assigned_to', 'tags']); + +/** + * Turn the bulk form into { ids, fields }. `field` names which field to set; + * `value` is repeatable, so an m2m field arrives as an array and a scalar as a + * single string. A Close also carries `closed_on`. + * @param {FormData} formData + */ +export function parseBulkForm(formData) { + const ids = formData.getAll('ids').map(String); + const field = String(formData.get('field') ?? ''); + const values = formData.getAll('value').map(String); + /** @type {Record} */ + const fields = {}; + if (field) { + fields[field] = M2M_FIELDS.has(field) ? values : (values[0] ?? ''); + } + const closedOn = formData.get('closed_on'); + if (closedOn) fields.closed_on = String(closedOn); + return { ids, fields }; +} diff --git a/frontend/src/lib/server/v2/tickets-bulk.test.js b/frontend/src/lib/server/v2/tickets-bulk.test.js new file mode 100644 index 00000000..2789e885 --- /dev/null +++ b/frontend/src/lib/server/v2/tickets-bulk.test.js @@ -0,0 +1,26 @@ +import { describe, it, expect } from 'vitest'; +import { summarizeBulk } from '$lib/server/v2/tickets.js'; + +describe('summarizeBulk', () => { + it('counts each outcome status', () => { + const s = summarizeBulk([ + { id: '1', status: 'updated' }, + { id: '2', status: 'updated' }, + { id: '3', status: 'no_access' }, + { id: '4', status: 'approval_required' }, + { id: '5', status: 'closed_on_required' }, + { id: '6', status: 'invalid' } + ]); + expect(s.updated).toBe(2); + expect(s.no_access).toBe(1); + expect(s.approval_required).toBe(1); + expect(s.closed_on_required).toBe(1); + expect(s.invalid).toBe(1); + }); + + it('handles an empty list', () => { + const s = summarizeBulk([]); + expect(s.updated).toBe(0); + expect(s.no_access).toBe(0); + }); +}); diff --git a/frontend/src/lib/server/v2/tickets.js b/frontend/src/lib/server/v2/tickets.js index 7931e3e1..24f21c2e 100644 --- a/frontend/src/lib/server/v2/tickets.js +++ b/frontend/src/lib/server/v2/tickets.js @@ -520,6 +520,54 @@ export async function replyToTicket({ cookies }, id, reply) { ); } +/** + * Bulk-update tickets. `fields` is a subset of + * { status, priority, case_type, closed_on, assigned_to: string[], tags: string[] }. + * The backend enforces per-case write access and the close gate, so this only + * forwards; it never gates. + * @param {{ cookies: any }} evt + * @param {string[]} ids + * @param {Record} fields + */ +export async function bulkUpdateTickets({ cookies }, ids, fields) { + return await apiRequest( + '/cases/bulk/update/', + { method: 'POST', body: { ids, fields } }, + { cookies } + ); +} + +/** + * Bulk soft-delete tickets. Backend deletes only those the caller may delete + * (admin or creator) and reports the rest as no_access. + * @param {{ cookies: any }} evt + * @param {string[]} ids + */ +export async function bulkDeleteTickets({ cookies }, ids) { + return await apiRequest('/cases/bulk/delete/', { method: 'POST', body: { ids } }, { cookies }); +} + +/** + * Count a bulk `results` array by outcome status, for the summary banner. + * Each entry also carries an `id` and, on some outcomes, a `detail`; only + * `status` is read here. + * @param {Array<{status: string, [key: string]: any}>} results + */ +export function summarizeBulk(results) { + const out = { + updated: 0, + deleted: 0, + no_access: 0, + approval_required: 0, + closed_on_required: 0, + invalid: 0 + }; + for (const r of results ?? []) { + if (r.status in out) out[r.status] += 1; + } + return out; +} + /** * `CaseDetailView.get` answers 404 for another org's ticket. Deliberately not * 403, which would confirm the id exists, and 403 for a ticket inside the org diff --git a/frontend/src/lib/v2/components/BulkActionBar.svelte b/frontend/src/lib/v2/components/BulkActionBar.svelte new file mode 100644 index 00000000..aed59b6c --- /dev/null +++ b/frontend/src/lib/v2/components/BulkActionBar.svelte @@ -0,0 +1,153 @@ + + +
+ {ids.length} selected + + + {#if action === ''} + + {:else if action === 'delete'} +
+ async ({ update }) => { + await update({ reset: false }); + reset(); + }} + > + {#each ids as id (id)}{/each} + {#if !armed} + + {:else} + + + {/if} + +
+ {:else} +
+ async ({ update }) => { + await update({ reset: false }); + reset(); + }} + > + {#each ids as id (id)}{/each} + + + {#if action === 'assigned_to'} + + {:else if action === 'tags'} + + {:else if action === 'priority'} + + {:else if action === 'case_type'} + + {:else if action === 'status'} + + {#if statusValue === 'Closed'} + + {/if} + {/if} + + + +
+ {/if} +
+ + diff --git a/frontend/src/routes/(app)/tickets/+page.server.js b/frontend/src/routes/(app)/tickets/+page.server.js index d7218a67..381d10a5 100644 --- a/frontend/src/routes/(app)/tickets/+page.server.js +++ b/frontend/src/routes/(app)/tickets/+page.server.js @@ -1,7 +1,16 @@ -import { listTickets, OPEN_STATUSES, FILTER_FIELDS } from '$lib/server/v2/tickets.js'; +import { fail } from '@sveltejs/kit'; +import { + listTickets, + OPEN_STATUSES, + FILTER_FIELDS, + bulkUpdateTickets, + bulkDeleteTickets, + summarizeBulk +} from '$lib/server/v2/tickets.js'; import { readFilters, buildFilterQuery } from '$lib/server/v2/filter-params.js'; import { getOrgPeopleAndTeams, resolveMe } from '$lib/server/v2/org-people.js'; import { getTags } from '$lib/server/v2/tags.js'; +import { parseBulkForm } from '$lib/server/v2/bulk-form.js'; /** * Only filters the API actually applies are forwarded. A parameter that @@ -56,3 +65,18 @@ export async function load({ cookies, url, locals }) { meId: resolveMe(orgPeople.people, /** @type {any} */ (locals).user?.email) }; } + +export const actions = { + bulkUpdate: async ({ request, cookies }) => { + const { ids, fields } = parseBulkForm(await request.formData()); + if (ids.length === 0) return fail(400, { message: 'Select at least one ticket.' }); + const res = await bulkUpdateTickets({ cookies }, ids, fields); + return { ok: true, kind: 'update', summary: summarizeBulk(res.results) }; + }, + bulkDelete: async ({ request, cookies }) => { + const ids = (await request.formData()).getAll('ids').map(String); + if (ids.length === 0) return fail(400, { message: 'Select at least one ticket.' }); + const res = await bulkDeleteTickets({ cookies }, ids); + return { ok: true, kind: 'delete', summary: summarizeBulk(res.results) }; + } +}; diff --git a/frontend/src/routes/(app)/tickets/+page.svelte b/frontend/src/routes/(app)/tickets/+page.svelte index 104ec9fb..d9d23393 100644 --- a/frontend/src/routes/(app)/tickets/+page.svelte +++ b/frontend/src/routes/(app)/tickets/+page.svelte @@ -1,12 +1,15 @@