vfxreview/actions/approvals.ts

"use server";

import { auth } from "@/auth";
import { db } from "@/lib/db";
import { revalidatePath } from "next/cache";
import { z } from "zod";
import { ApprovalStatus } from "@prisma/client";
import { recalcShotStatus, clearStaleShotApproval } from "@/lib/shot-status";
import { notifyApprovalChange } from "@/lib/notifications";
import { slackNotifyApproval } from "@/lib/slack";
import { versionLabel } from "@/lib/utils";
import { createDisplayEvent } from "@/lib/display-events";

const approvalSchema = z.object({
  versionId: z.string().cuid(),
  status: z.nativeEnum(ApprovalStatus),
  notes: z.string().optional(),
});

export async function submitApproval(data: z.infer<typeof approvalSchema>) {
  const session = await auth();
  if (!session?.user) throw new Error("Unauthorized");

  const parsed = approvalSchema.parse(data);

  // Only supervisors, producers, admins, and clients can approve
  const allowedRoles = ["ADMIN", "PRODUCER", "SUPERVISOR", "CLIENT"];
  if (!allowedRoles.includes(session.user.role)) {
    throw new Error("Insufficient permissions to review versions");
  }

  // The verdict, the version, the task and the derived shot status are one
  // decision and are written as one: a failure partway through used to leave the
  // three layers disagreeing, with no way to tell which one was right.
  const { approval, version } = await db.$transaction(async (tx) => {
    const approval = await tx.approval.create({
      data: {
        versionId: parsed.versionId,
        userId: session.user.id,
        status: parsed.status,
        notes: parsed.notes,
      },
    });

    await tx.version.update({
      where: { id: parsed.versionId },
      data: { approvalStatus: parsed.status },
    });

    // Load version + task + shot + project for downstream effects
    const version = await tx.version.findUnique({
      where: { id: parsed.versionId },
      include: {
        task: {
          include: {
            shot: true,
            project: true,
          },
        },
      },
    });

    if (!version) throw new Error("Version not found");

    // Update task status based on approval result
    if (version.task && parsed.status !== "PENDING_REVIEW") {
      if (parsed.status === "APPROVED") {
        await tx.task.update({
          where: { id: version.task.id },
          data: { status: "DONE" },
        });
      } else if (parsed.status === "REJECTED" || parsed.status === "NEEDS_CHANGES") {
        await tx.task.update({
          where: { id: version.task.id },
          data: { status: "CHANGES" },
        });
      }

      // Recalculate shot status from updated task states
      if (version.task.shot) {
        await recalcShotStatus(version.task.shot.id, tx);
      }
    }

    return { approval, version };
  });

  // Notifications
  const reviewer = await db.user.findUnique({ where: { id: session.user.id } });
  const reviewerName = reviewer?.name ?? "Reviewer";

  if (version.task && parsed.status !== "PENDING_REVIEW") {
    const contextCode = version.task.shot?.shotCode ?? null;
    await notifyApprovalChange({
      artistId: version.task.assignedArtistId ?? version.artistId,
      shotCode: contextCode ?? version.task.title,
      versionId: parsed.versionId,
      status: parsed.status as "APPROVED" | "REJECTED" | "NEEDS_CHANGES",
      reviewerName,
    });

    // Slack
    if (version.task.project.slackWebhook) {
      const appUrl = process.env.NEXT_PUBLIC_APP_URL ?? "http://localhost:3000";
      await slackNotifyApproval(version.task.project.slackWebhook, {
        shotCode: contextCode ?? version.task.title,
        versionLabel: versionLabel(version.versionNumber),
        status: parsed.status as "APPROVED" | "REJECTED" | "NEEDS_CHANGES",
        reviewerName,
        projectName: version.task.project.name,
        reviewUrl: `${appUrl}/review/${parsed.versionId}`,
      });
    }
  }

  // Display board event
  const contextCode = version.task?.shot?.shotCode ?? version.task?.title ?? null;
  if (contextCode && parsed.status !== "PENDING_REVIEW") {
    const displayType =
      parsed.status === "APPROVED" ? "APPROVED" :
      parsed.status === "NEEDS_CHANGES" ? "CHANGES" : "REJECTED";
    await createDisplayEvent(displayType, contextCode, reviewerName);
  }

  revalidatePath(`/review/${parsed.versionId}`);
  if (version.task) {
    revalidatePath(`/tasks/${version.task.id}`);
    revalidatePath(`/projects/${version.task.projectId}`);
  }

  return { success: true, approval };
}

export async function getApprovalHistory(versionId: string) {
  const session = await auth();
  if (!session?.user) throw new Error("Unauthorized");

  return db.approval.findMany({
    where: { versionId },
    include: {
      user: { select: { id: true, name: true, email: true, image: true, role: true } },
    },
    orderBy: { createdAt: "desc" },
  });
}

/**
 * Resets an approved version back to PENDING_REVIEW and the associated task
 * back to INTERNAL_REVIEW. Recalculates shot status.
 * Only ADMIN, PRODUCER, SUPERVISOR can unapprove.
 */
export async function unapproveVersion(versionId: string) {
  const session = await auth();
  if (!session?.user) throw new Error("Unauthorized");

  const allowedRoles = ["ADMIN", "PRODUCER", "SUPERVISOR"];
  if (!allowedRoles.includes(session.user.role)) {
    throw new Error("Insufficient permissions to unapprove versions");
  }

  const version = await db.version.findUnique({
    where: { id: versionId },
    include: {
      task: {
        include: { shot: true },
      },
    },
  });
  if (!version) throw new Error("Version not found");
  if (version.approvalStatus !== "APPROVED") {
    throw new Error("Only approved versions can be unapproved");
  }

  // One decision, one write — same reasoning as submitApproval.
  await db.$transaction(async (tx) => {
    // Create an audit record for the unapproval
    await tx.approval.create({
      data: {
        versionId,
        userId: session.user.id,
        status: "PENDING_REVIEW",
        notes: "Approval undone",
      },
    });

    // Reset version approval status
    await tx.version.update({
      where: { id: versionId },
      data: { approvalStatus: "PENDING_REVIEW" },
    });

    // Reset task back to INTERNAL_REVIEW if it was moved to DONE
    if (version.task && version.task.status === "DONE") {
      await tx.task.update({
        where: { id: version.task.id },
        data: { status: "INTERNAL_REVIEW" },
      });
    }

    // Undoing a version approval also invalidates any shot-level sign-off that
    // rested on it, otherwise the shot keeps reading COMPLETE / READY_FOR_CLIENT.
    if (version.task?.shot) {
      await clearStaleShotApproval(tx, version.task.shot.id);
      await recalcShotStatus(version.task.shot.id, tx);
    }
  });

  revalidatePath(`/review/${versionId}`);
  if (version.task) {
    revalidatePath(`/tasks/${version.task.id}`);
    revalidatePath(`/projects/${version.task.projectId}`);
  }

  return { success: true };
}