Skip to content

Your favorite shift management application!

4.7 KB
Raw Blame
import { NextRequest, NextResponse } from "next/server";
import { desc, eq, sql } from "drizzle-orm";
import { db } from "@/lib/db";
import { announcements, user as userTable } from "@/lib/db/schema";
import {
  getValidatedAdminUser,
  isErrorResponse,
  type AdminUser,
} from "@/lib/auth/admin-helpers";
import { canManageSystemSettings } from "@/lib/auth/admin";
import { sanitizeAnnouncementInput } from "@/lib/announcements";
import { rateLimit } from "@/lib/rate-limiter";
import { logAdminAction, type AdminAnnouncementCreatedMetadata } from "@/lib/audit-log";

/**
 * Admin Announcements API
 *
 * GET  /api/admin/announcements  -- every row, including disabled and expired
 * POST /api/admin/announcements
 *
 * Permission: Admin or Superadmin (canManageSystemSettings)
 */
/** Timestamps defaulted by SQLite are "YYYY-MM-DD HH:MM:SS" text in UTC; app-written ones are unix seconds. */
function toDate(value: unknown): Date {
  if (typeof value === "number") return new Date(value * 1000);
  if (typeof value === "string") {
    if (/^\d+$/.test(value)) return new Date(Number(value) * 1000);
    const utc = new Date(`${value.replace(" ", "T")}Z`);
    return isNaN(utc.getTime()) ? new Date(value) : utc;
  }
  return new Date();
}

// Same column can hold either shape (see toDate above); normalise to seconds
// here too so ORDER BY reflects actual time rather than SQLite's storage-class
// ordering (INTEGER before TEXT), which would otherwise separate the two.
const createdAtEpoch = sql`case when typeof(${announcements.createdAt}) = 'text' then cast(strftime('%s', ${announcements.createdAt}) as integer) else ${announcements.createdAt} end`;

export type AnnouncementAccess =
  | { error: NextResponse; currentUser?: undefined }
  | { error?: undefined; currentUser: AdminUser };

export async function requireAnnouncementAccess(
  request: NextRequest
): Promise<AnnouncementAccess> {
  const currentUser = await getValidatedAdminUser(request);
  if (isErrorResponse(currentUser)) {
    return { error: currentUser };
  }
  if (!canManageSystemSettings(currentUser)) {
    return { error: NextResponse.json({ error: "Admin access required" }, { status: 403 }) };
  }
  return { currentUser };
}

export async function GET(request: NextRequest) {
  const access = await requireAnnouncementAccess(request);
  if (access.error) return access.error;

  try {
    const rows = await db
      .select({
        id: announcements.id,
        title: announcements.title,
        body: announcements.body,
        tone: announcements.tone,
        showOnAuth: announcements.showOnAuth,
        showOnDashboard: announcements.showOnDashboard,
        enabled: announcements.enabled,
        startsAt: announcements.startsAt,
        endsAt: announcements.endsAt,
        createdAt: sql<unknown>`${announcements.createdAt}`,
        createdByName: userTable.name,
      })
      .from(announcements)
      .leftJoin(userTable, eq(announcements.createdBy, userTable.id))
      .orderBy(desc(createdAtEpoch));

    const items = rows.map((row) => ({ ...row, createdAt: toDate(row.createdAt) }));

    return NextResponse.json({ announcements: items });
  } catch (err) {
    console.error("Failed to list announcements:", err);
    return NextResponse.json({ error: "Failed to list announcements" }, { status: 500 });
  }
}

export async function POST(request: NextRequest) {
  const access = await requireAnnouncementAccess(request);
  if (access.error) return access.error;
  const currentUser = access.currentUser;

  const rateLimitResponse = rateLimit(request, currentUser.id, "admin-announcement-mutations");
  if (rateLimitResponse) return rateLimitResponse;

  try {
    const parsed = sanitizeAnnouncementInput(await request.json());
    if (!parsed.ok) {
      return NextResponse.json({ error: parsed.error }, { status: 400 });
    }

    const [created] = await db
      .insert(announcements)
      .values({ ...parsed.value, createdBy: currentUser.id })
      .returning();

    await logAdminAction<AdminAnnouncementCreatedMetadata>({
      action: "admin.announcement.create",
      userId: currentUser.id,
      resourceType: "announcement",
      resourceId: created.id,
      metadata: {
        announcement: {
          title: created.title,
          tone: created.tone,
          showOnAuth: created.showOnAuth,
          showOnDashboard: created.showOnDashboard,
          enabled: created.enabled,
          startsAt: created.startsAt,
          endsAt: created.endsAt,
        },
      },
      request,
    });

    return NextResponse.json({ announcement: created }, { status: 201 });
  } catch (err) {
    console.error("Failed to create announcement:", err);
    return NextResponse.json({ error: "Failed to create announcement" }, { status: 500 });
  }
}