kita-planer/src/app/dashboard/kalender/actions.ts

"use server";

import { revalidatePath } from "next/cache";
import { TerminStatus, TerminType, UserRole } from "@prisma/client";
import { z } from "zod";

import { requireKitaSession, requireRole } from "@/lib/auth-utils";
import { prisma } from "@/lib/prisma";

// =====================================================================
// /dashboard/kalender · Server Actions
// =====================================================================

const terminSchema = z.object({
  title: z.string().min(2, "Titel muss mindestens 2 Zeichen lang sein"),
  description: z.string().optional(),
  type: z.nativeEnum(TerminType),
  startDate: z.string().datetime(),
  endDate: z.string().datetime(),
  allDay: z.boolean().default(false),
});

export async function createTerminRequest(rawPayload: unknown) {
  const session = await requireKitaSession();
  
  const parsed = terminSchema.safeParse(rawPayload);
  if (!parsed.success) {
    return { error: "Ungültige Eingabedaten." };
  }
  
  const data = parsed.data;

  try {
    await prisma.termin.create({
      data: {
        kitaId: session.user.kitaId,
        createdById: session.user.id,
        title: data.title,
        description: data.description,
        type: data.type,
        startDate: new Date(data.startDate),
        endDate: new Date(data.endDate),
        allDay: data.allDay,
        status: TerminStatus.PENDING,
      },
    });

    revalidatePath("/dashboard/kalender");
    return { success: true };
  } catch (error) {
    console.error("Fehler beim Erstellen der Terminanfrage:", error);
    return { error: "Ein Fehler ist aufgetreten." };
  }
}

export async function createTerminAdmin(rawPayload: unknown) {
  const session = await requireRole([UserRole.ADMIN, UserRole.KOORDINATOR]);
  const kitaId = session.user.kitaId;
  if (!kitaId) {
    return { error: "Kein Mandant zugeordnet." };
  }
  
  const parsed = terminSchema.safeParse(rawPayload);
  if (!parsed.success) {
    return { error: "Ungültige Eingabedaten." };
  }
  
  const data = parsed.data;

  try {
    await prisma.termin.create({
      data: {
        kitaId,
        createdById: session.user.id,
        title: data.title,
        description: data.description,
        type: data.type,
        startDate: new Date(data.startDate),
        endDate: new Date(data.endDate),
        allDay: data.allDay,
        status: TerminStatus.CONFIRMED,
        approvedById: session.user.id,
        approvedAt: new Date(),
      },
    });

    revalidatePath("/dashboard/kalender");
    return { success: true };
  } catch (error) {
    console.error("Fehler beim Erstellen des Termins:", error);
    return { error: "Ein Fehler ist aufgetreten." };
  }
}

export async function approveTermin(terminId: string) {
  const session = await requireRole([UserRole.ADMIN, UserRole.KOORDINATOR]);
  const kitaId = session.user.kitaId;
  if (!kitaId) {
    return { error: "Kein Mandant zugeordnet." };
  }

  try {
    await prisma.termin.update({
      where: {
        id: terminId,
        kitaId,
      },
      data: {
        status: TerminStatus.CONFIRMED,
        approvedById: session.user.id,
        approvedAt: new Date(),
      },
    });

    revalidatePath("/dashboard/kalender");
    return { success: true };
  } catch (error) {
    console.error("Fehler beim Bestätigen des Termins:", error);
    return { error: "Ein Fehler ist aufgetreten." };
  }
}

export async function rejectTermin(terminId: string, reason?: string) {
  const session = await requireRole([UserRole.ADMIN, UserRole.KOORDINATOR]);
  const kitaId = session.user.kitaId;
  if (!kitaId) {
    return { error: "Kein Mandant zugeordnet." };
  }

  try {
    await prisma.termin.update({
      where: {
        id: terminId,
        kitaId,
      },
      data: {
        status: TerminStatus.REJECTED,
        rejectionReason: reason,
        approvedById: session.user.id,
        approvedAt: new Date(),
      },
    });

    revalidatePath("/dashboard/kalender");
    return { success: true };
  } catch (error) {
    console.error("Fehler beim Ablehnen des Termins:", error);
    return { error: "Ein Fehler ist aufgetreten." };
  }
}

export async function toggleMitbringselList(terminId: string, enabled: boolean) {
  const session = await requireRole([UserRole.ADMIN, UserRole.KOORDINATOR]);
  const kitaId = session.user.kitaId;
  if (!kitaId) {
    return { error: "Kein Mandant zugeordnet." };
  }

  try {
    await prisma.termin.update({
      where: {
        id: terminId,
        kitaId,
      },
      data: {
        mitbringselListEnabled: enabled,
      },
    });

    revalidatePath("/dashboard/kalender");
    return { success: true };
  } catch (error) {
    console.error("Fehler beim Umschalten der Mitbring-Liste:", error);
    return { error: "Ein Fehler ist aufgetreten." };
  }
}

const mitbringselSchema = z.object({
  terminId: z.string(),
  content: z.string().min(1, "Eintrag darf nicht leer sein"),
});

export async function addMitbringsel(rawPayload: unknown) {
  const session = await requireKitaSession();
  
  const parsed = mitbringselSchema.safeParse(rawPayload);
  if (!parsed.success) {
    return { error: "Ungültige Eingabedaten." };
  }
  
  const { terminId, content } = parsed.data;

  try {
    // Verify termin is active and list is enabled
    const termin = await prisma.termin.findUnique({
      where: { id: terminId, kitaId: session.user.kitaId },
    });

    if (!termin || termin.status !== TerminStatus.CONFIRMED || !termin.mitbringselListEnabled) {
      return { error: "Mitbring-Liste ist für diesen Termin nicht aktiv." };
    }

    await prisma.mitbringselItem.create({
      data: {
        kitaId: session.user.kitaId,
        terminId: terminId,
        userId: session.user.id,
        content: content,
      },
    });

    revalidatePath("/dashboard/kalender");
    return { success: true };
  } catch (error) {
    console.error("Fehler beim Hinzufügen des Eintrags:", error);
    return { error: "Ein Fehler ist aufgetreten." };
  }
}

export async function deleteMitbringsel(itemId: string) {
  const session = await requireKitaSession();

  try {
    const item = await prisma.mitbringselItem.findUnique({
      where: { id: itemId, kitaId: session.user.kitaId },
    });

    if (!item) {
      return { error: "Eintrag nicht gefunden." };
    }

    // Admins/Koords can delete any item. Users can only delete their own.
    if (
      session.user.role !== UserRole.ADMIN &&
      session.user.role !== UserRole.KOORDINATOR &&
      item.userId !== session.user.id
    ) {
      return { error: "Keine Berechtigung diesen Eintrag zu löschen." };
    }

    await prisma.mitbringselItem.delete({
      where: { id: itemId },
    });

    revalidatePath("/dashboard/kalender");
    return { success: true };
  } catch (error) {
    console.error("Fehler beim Löschen des Eintrags:", error);
    return { error: "Ein Fehler ist aufgetreten." };
  }
}