Implement case mass-update endpoint.

Author: apognu

api/handle_cases.go

@@ -741,3 +741,22 @@ func handleEnrichCasePivotObjects(uc usecases.Usecases) func(c *gin.Context) {
 		c.JSON(http.StatusOK, agent_dto.AdaptKYCEnrichmentResultsDto(responses))
 	}
 }
+
+func handleCaseMassUpdate(uc usecases.Usecases) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		ctx := c.Request.Context()
+
+		var params dto.CaseMassUpdateDto
+
+		if err := c.ShouldBindJSON(&params); presentError(ctx, c, err) {
+			c.Status(http.StatusBadRequest)
+			return
+		}
+
+		uc := usecasesWithCreds(ctx, uc).NewCaseUseCase()
+
+		if err := uc.MassUpdate(ctx, params); presentError(ctx, c, err) {
+			return
+		}
+	}
+}

api/routes.go

@@ -238,6 +238,7 @@ func addRoutes(r *gin.Engine, conf Configuration, uc usecases.Usecases, auth uti
 
 	router.GET("/cases", tom, handleListCases(uc))
 	router.POST("/cases", tom, handlePostCase(uc))
+	router.POST("/cases/mass-update", tom, handleCaseMassUpdate(uc))
 	router.GET("/cases/:case_id", tom, handleGetCase(uc))
 	router.GET("/cases/:case_id/next", tom, handleGetNextCase(uc))
 	router.POST("/cases/:case_id/snooze", tom, handleSnoozeCase(uc))

dto/case_dto.go

@@ -155,3 +155,18 @@ type CaseDecisionListPaginationDto struct {
 	HasMore      bool   `json:"has_more"`
 	NextCursorId string `json:"next_cursor_id"`
 }
+
+type CaseMassUpdateDto struct {
+	Action      string                     `json:"action" binding:"required,oneof=close reopen assign move_to_inbox"`
+	CaseIds     []uuid.UUID                `json:"case_ids" binding:"required,dive,uuid"`
+	Assign      *CaseMassUpdateAssignDto   `json:"assign" binding:"required_if=Action assign"`
+	MoveToInbox *CaseMassUpdateMoveToInbox `json:"move_to_inbox" binding:"required_if=Action move_to_inbox"`
+}
+
+type CaseMassUpdateAssignDto struct {
+	AssigneeId uuid.UUID `json:"assignee_id" binding:"required"`
+}
+
+type CaseMassUpdateMoveToInbox struct {
+	InboxId uuid.UUID `json:"inbox_id" binding:"required"`
+}

repositories/case_mass_update_repository.go

@@ -0,0 +1,88 @@
+package repositories
+
+import (
+	"context"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/checkmarble/marble-backend/models"
+	"github.com/checkmarble/marble-backend/repositories/dbmodels"
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+)
+
+func (repo *MarbleDbRepository) CaseMassChangeStatus(ctx context.Context, tx Transaction, caseIds []uuid.UUID, status models.CaseStatus) ([]uuid.UUID, error) {
+	query := NewQueryBuilder().
+		Update(dbmodels.TABLE_CASES).
+		Set("status", status).
+		Where(squirrel.And{
+			squirrel.Eq{"id": caseIds},
+			squirrel.NotEq{"status": status},
+		}).
+		Suffix("returning id")
+
+	return caseMassUpdateExecAndReturnedChanged(ctx, tx, query)
+}
+
+func (repo *MarbleDbRepository) CaseMassAssign(ctx context.Context, tx Transaction, caseIds []uuid.UUID, assigneeId uuid.UUID) ([]uuid.UUID, error) {
+	query := NewQueryBuilder().
+		Update(dbmodels.TABLE_CASES).
+		Set("assigned_to", assigneeId).
+		Where(squirrel.And{
+			squirrel.Eq{"id": caseIds},
+			squirrel.Or{
+				squirrel.Eq{"assigned_to": nil},
+				squirrel.NotEq{"assigned_to": assigneeId},
+			},
+		}).
+		Suffix("returning id")
+
+	return caseMassUpdateExecAndReturnedChanged(ctx, tx, query)
+}
+
+func (repo *MarbleDbRepository) CaseMassMoveToInbox(ctx context.Context, tx Transaction, caseIds []uuid.UUID, inboxId uuid.UUID) ([]uuid.UUID, error) {
+	query := NewQueryBuilder().
+		Update(dbmodels.TABLE_CASES).
+		Set("inbox_id", inboxId).
+		Where(squirrel.And{
+			squirrel.Eq{"id": caseIds},
+			squirrel.Or{
+				squirrel.Eq{"inbox_id": nil},
+				squirrel.NotEq{"inbox_id": inboxId},
+			},
+		}).
+		Suffix("returning id")
+
+	return caseMassUpdateExecAndReturnedChanged(ctx, tx, query)
+}
+
+func caseMassUpdateExecAndReturnedChanged(ctx context.Context, tx Transaction, query squirrel.UpdateBuilder) ([]uuid.UUID, error) {
+	sql, args, err := query.ToSql()
+
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := tx.Query(ctx, sql, args...)
+
+	if err != nil {
+		return nil, err
+	}
+
+	defer rows.Close()
+
+	var tmp uuid.UUID
+
+	ids, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (uuid.UUID, error) {
+		if err := row.Scan(&tmp); err != nil {
+			return uuid.Nil, err
+		}
+
+		return tmp, nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return ids, nil
+}

usecases/case_usecase.go

@@ -4,11 +4,13 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"maps"
 	"mime/multipart"
 	"slices"
 	"strings"
 	"time"
 
+	"github.com/checkmarble/marble-backend/dto"
 	"github.com/checkmarble/marble-backend/models"
 	"github.com/checkmarble/marble-backend/pure_utils"
 	"github.com/checkmarble/marble-backend/repositories"
@@ -69,6 +71,10 @@ type CaseUseCaseRepository interface {
 	GetNextCase(ctx context.Context, exec repositories.Executor, c models.Case) (string, error)
 
 	UserById(ctx context.Context, exec repositories.Executor, userId string) (models.User, error)
+
+	CaseMassChangeStatus(ctx context.Context, tx repositories.Transaction, caseIds []uuid.UUID, status models.CaseStatus) ([]uuid.UUID, error)
+	CaseMassAssign(ctx context.Context, tx repositories.Transaction, caseIds []uuid.UUID, assigneeId uuid.UUID) ([]uuid.UUID, error)
+	CaseMassMoveToInbox(ctx context.Context, tx repositories.Transaction, caseIds []uuid.UUID, inboxId uuid.UUID) ([]uuid.UUID, error)
 }
 
 type CaseUsecaseScreeningRepository interface {
@@ -1663,3 +1669,141 @@ func (uc *CaseUseCase) triggerAutoAssignment(ctx context.Context, tx repositorie
 
 	return nil
 }
+
+func (uc *CaseUseCase) MassUpdate(ctx context.Context, req dto.CaseMassUpdateDto) error {
+	exec := uc.executorFactory.NewExecutor()
+	orgId := uc.enforceSecurity.OrgId()
+	userId := uc.enforceSecurity.UserId()
+
+	sourceCases := make(map[string]models.Case, len(req.CaseIds))
+	events := make(map[string]models.CreateCaseEventAttributes, len(req.CaseIds))
+
+	var newAssignee models.User
+
+	availableInboxIds, err := uc.getAvailableInboxIds(ctx, exec, orgId)
+	if err != nil {
+		return err
+	}
+
+	if req.Action == "assign" {
+		var err error
+
+		newAssignee, err = uc.repository.UserById(ctx, exec, req.Assign.AssigneeId.String())
+		if err != nil {
+			return errors.Wrap(err, "target user for assignment not found")
+		}
+	}
+
+	// For all cases in the mass update, we need to check the current user can manage them.
+	for _, caseId := range req.CaseIds {
+		// TODO: that is harsh, refactor GetCaseById into a single SQL query to
+		// retrieve all cases outside of the loop
+		c, err := uc.repository.GetCaseById(ctx, exec, caseId.String())
+		if err != nil {
+			return err
+		}
+
+		if err := uc.enforceSecurity.ReadOrUpdateCase(c.GetMetadata(), availableInboxIds); err != nil {
+			return err
+		}
+
+		// If we are trying to mass-assign, we need to check, for each case, that the target user can manage the case.
+		if req.Action == "assign" {
+			if err := security.EnforceSecurityCaseForUser(newAssignee).ReadOrUpdateCase(c.GetMetadata(), availableInboxIds); err != nil {
+				return errors.Wrap(err, "target user lacks case permissions for assignment")
+			}
+		}
+
+		sourceCases[c.Id] = c
+	}
+
+	// When changing the cases' inboxes, the user needs to have access to the target inbox.
+	if req.Action == "move_to_inbox" {
+		if _, err := uc.inboxReader.GetInboxById(ctx, req.MoveToInbox.InboxId); err != nil {
+			return errors.Wrap(err, fmt.Sprintf("User does not have access the new inbox %s", req.MoveToInbox.InboxId))
+		}
+	}
+
+	return uc.transactionFactory.Transaction(ctx, func(tx repositories.Transaction) error {
+		switch req.Action {
+		case "close":
+			updatedIds, err := uc.repository.CaseMassChangeStatus(ctx, tx, req.CaseIds, models.CaseClosed)
+
+			if err != nil {
+				return err
+			}
+
+			for _, updatedId := range updatedIds {
+				events[updatedId.String()] = models.CreateCaseEventAttributes{
+					UserId:        userId,
+					CaseId:        updatedId.String(),
+					EventType:     models.CaseStatusUpdated,
+					PreviousValue: utils.Ptr(string(sourceCases[updatedId.String()].Status)),
+					NewValue:      utils.Ptr(string(models.CaseClosed)),
+				}
+			}
+
+		case "reopen":
+			updatedIds, err := uc.repository.CaseMassChangeStatus(ctx, tx, req.CaseIds, models.CasePending)
+
+			if err != nil {
+				return err
+			}
+
+			for _, updatedId := range updatedIds {
+				events[updatedId.String()] = models.CreateCaseEventAttributes{
+					UserId:        userId,
+					CaseId:        updatedId.String(),
+					EventType:     models.CaseStatusUpdated,
+					PreviousValue: utils.Ptr(string(sourceCases[updatedId.String()].Status)),
+					NewValue:      utils.Ptr(string(models.CasePending)),
+				}
+			}
+
+		case "assign":
+			updatedIds, err := uc.repository.CaseMassAssign(ctx, tx, req.CaseIds, req.Assign.AssigneeId)
+
+			if err != nil {
+				return err
+			}
+
+			for _, updatedId := range updatedIds {
+				events[updatedId.String()] = models.CreateCaseEventAttributes{
+					UserId:        userId,
+					CaseId:        updatedId.String(),
+					EventType:     models.CaseAssigned,
+					PreviousValue: (*string)(sourceCases[updatedId.String()].AssignedTo),
+					NewValue:      utils.Ptr(req.Assign.AssigneeId.String()),
+				}
+			}
+
+		case "move_to_inbox":
+			updatedIds, err := uc.repository.CaseMassMoveToInbox(ctx, tx, req.CaseIds, req.MoveToInbox.InboxId)
+
+			if err != nil {
+				return err
+			}
+
+			for _, updatedId := range updatedIds {
+				events[updatedId.String()] = models.CreateCaseEventAttributes{
+					UserId:        userId,
+					CaseId:        updatedId.String(),
+					EventType:     models.CaseInboxChanged,
+					PreviousValue: utils.Ptr(sourceCases[updatedId.String()].InboxId.String()),
+					NewValue:      utils.Ptr(req.MoveToInbox.InboxId.String()),
+				}
+			}
+
+		}
+
+		if len(events) == 0 {
+			return nil
+		}
+
+		if err := uc.repository.BatchCreateCaseEvents(ctx, tx, slices.Collect(maps.Values(events))); err != nil {
+			return err
+		}
+
+		return nil
+	})
+}