got-gaming/actions/admin/challenges.ts

"use server";

import { revalidatePath } from "next/cache";
import { auth } from "@/lib/auth";
import { challengeService } from "@/services/challenges/challenge.service";
import { Role } from "@/prisma/generated/prisma/client";
import { ValidationError, NotFoundError } from "@/services/errors";

async function checkAdminAccess() {
  const session = await auth();
  if (!session?.user || session.user.role !== Role.ADMIN) {
    throw new Error("Accès refusé - Admin uniquement");
  }
  return session;
}

export async function validateChallenge(
  challengeId: string,
  winnerId: string,
  adminComment?: string
) {
  try {
    const session = await checkAdminAccess();

    const challenge = await challengeService.validateChallenge(
      challengeId,
      session.user.id,
      winnerId,
      adminComment
    );

    revalidatePath("/admin");
    revalidatePath("/challenges");
    revalidatePath("/leaderboard");

    return {
      success: true,
      message: "Défi validé avec succès",
      data: challenge,
    };
  } catch (error) {
    console.error("Validate challenge error:", error);

    if (error instanceof ValidationError) {
      return { success: false, error: error.message };
    }
    if (error instanceof NotFoundError) {
      return { success: false, error: error.message };
    }
    if (error instanceof Error && error.message.includes("Accès refusé")) {
      return { success: false, error: error.message };
    }

    return {
      success: false,
      error: "Une erreur est survenue lors de la validation du défi",
    };
  }
}

export async function rejectChallenge(
  challengeId: string,
  adminComment?: string
) {
  try {
    const session = await checkAdminAccess();

    const challenge = await challengeService.rejectChallenge(
      challengeId,
      session.user.id,
      adminComment
    );

    revalidatePath("/admin");
    revalidatePath("/challenges");

    return { success: true, message: "Défi rejeté", data: challenge };
  } catch (error) {
    console.error("Reject challenge error:", error);

    if (error instanceof ValidationError) {
      return { success: false, error: error.message };
    }
    if (error instanceof NotFoundError) {
      return { success: false, error: error.message };
    }
    if (error instanceof Error && error.message.includes("Accès refusé")) {
      return { success: false, error: error.message };
    }

    return {
      success: false,
      error: "Une erreur est survenue lors du rejet du défi",
    };
  }
}

export async function updateChallenge(
  challengeId: string,
  data: {
    title?: string;
    description?: string;
    pointsReward?: number;
  }
) {
  try {
    await checkAdminAccess();

    const challenge = await challengeService.updateChallenge(challengeId, {
      title: data.title,
      description: data.description,
      pointsReward: data.pointsReward,
    });

    revalidatePath("/admin");
    revalidatePath("/challenges");

    return {
      success: true,
      message: "Défi mis à jour avec succès",
      data: challenge,
    };
  } catch (error) {
    console.error("Update challenge error:", error);

    if (error instanceof ValidationError) {
      return { success: false, error: error.message };
    }
    if (error instanceof NotFoundError) {
      return { success: false, error: error.message };
    }
    if (error instanceof Error && error.message.includes("Accès refusé")) {
      return { success: false, error: error.message };
    }

    return {
      success: false,
      error: "Une erreur est survenue lors de la mise à jour du défi",
    };
  }
}

export async function deleteChallenge(challengeId: string) {
  try {
    await checkAdminAccess();

    await challengeService.deleteChallenge(challengeId);

    revalidatePath("/admin");
    revalidatePath("/challenges");

    return { success: true, message: "Défi supprimé avec succès" };
  } catch (error) {
    console.error("Delete challenge error:", error);

    if (error instanceof NotFoundError) {
      return { success: false, error: error.message };
    }
    if (error instanceof Error && error.message.includes("Accès refusé")) {
      return { success: false, error: error.message };
    }

    return {
      success: false,
      error: "Une erreur est survenue lors de la suppression du défi",
    };
  }
}

export async function adminCancelChallenge(challengeId: string) {
  try {
    await checkAdminAccess();

    const challenge = await challengeService.adminCancelChallenge(challengeId);

    revalidatePath("/admin");
    revalidatePath("/challenges");

    return {
      success: true,
      message: "Défi annulé avec succès",
      data: challenge,
    };
  } catch (error) {
    console.error("Admin cancel challenge error:", error);

    if (error instanceof ValidationError) {
      return { success: false, error: error.message };
    }
    if (error instanceof NotFoundError) {
      return { success: false, error: error.message };
    }
    if (error instanceof Error && error.message.includes("Accès refusé")) {
      return { success: false, error: error.message };
    }

    return {
      success: false,
      error: "Une erreur est survenue lors de l'annulation du défi",
    };
  }
}

export async function reactivateChallenge(challengeId: string) {
  try {
    await checkAdminAccess();

    const challenge = await challengeService.reactivateChallenge(challengeId);

    revalidatePath("/admin");
    revalidatePath("/challenges");

    return {
      success: true,
      message: "Défi réactivé avec succès",
      data: challenge,
    };
  } catch (error) {
    console.error("Reactivate challenge error:", error);

    if (error instanceof ValidationError) {
      return { success: false, error: error.message };
    }
    if (error instanceof NotFoundError) {
      return { success: false, error: error.message };
    }
    if (error instanceof Error && error.message.includes("Accès refusé")) {
      return { success: false, error: error.message };
    }

    return {
      success: false,
      error: "Une erreur est survenue lors de la réactivation du défi",
    };
  }
}

export async function adminAcceptChallenge(challengeId: string) {
  try {
    await checkAdminAccess();

    const challenge = await challengeService.adminAcceptChallenge(challengeId);

    revalidatePath("/admin");
    revalidatePath("/challenges");

    return {
      success: true,
      message: "Défi accepté avec succès",
      data: challenge,
    };
  } catch (error) {
    console.error("Admin accept challenge error:", error);

    if (error instanceof ValidationError) {
      return { success: false, error: error.message };
    }
    if (error instanceof NotFoundError) {
      return { success: false, error: error.message };
    }
    if (error instanceof Error && error.message.includes("Accès refusé")) {
      return { success: false, error: error.message };
    }

    return {
      success: false,
      error: "Une erreur est survenue lors de l'acceptation du défi",
    };
  }
}