Skip to content

Your favorite shift management application!

9.7 KB
Raw Blame
"use client";

import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
import { toast } from "sonner";
import { useTranslations } from "next-intl";
import { queryKeys } from "@/lib/query-keys";
import { BACKGROUND_REFETCH_INTERVAL } from "@/lib/query-client";

/**
 * Audit Log Types
 */
export interface AuditLog {
  id: string;
  userId: string | null;
  action: string;
  resourceType: string | null;
  resourceId: string | null;
  metadata: unknown;
  ipAddress: string | null;
  userAgent: string | null;
  severity: "info" | "warning" | "error" | "critical";
  isUserVisible: boolean;
  timestamp: Date;
  userName: string | null;
  userEmail: string | null;
  userImage: string | null;
}

export interface AuditLogFilters {
  action?: string;
  userId?: string;
  resourceType?: string;
  resourceId?: string;
  severity?: "info" | "warning" | "error" | "critical";
  search?: string;
  startDate?: string;
  endDate?: string;
  isUserVisible?: boolean;
}

/** One collapsed row standing in for every routine (auto-scheduler) run of one external sync. */
export interface RoutineAuditLogBundle {
  resourceId: string;
  count: number;
  firstTimestamp: Date;
  lastTimestamp: Date;
  syncName: string;
  calendarName: string;
}

export interface AuditLogSort {
  field: "timestamp" | "action" | "severity" | "user" | "ipAddress";
  direction: "asc" | "desc";
}

export interface AuditLogPagination {
  limit: number;
  offset: number;
}

export interface AuditLogsResponse {
  logs: AuditLog[];
  total: number;
  limit: number;
  offset: number;
  routineBundles: RoutineAuditLogBundle[];
}

/**
 * Fetch audit logs from API
 */
async function fetchAuditLogsApi(
  filters: AuditLogFilters,
  sort: AuditLogSort,
  pagination: AuditLogPagination,
  t: ReturnType<typeof useTranslations>,
  bundleRoutine = false,
): Promise<AuditLogsResponse> {
  const params = new URLSearchParams();

  if (filters.action) params.set("action", filters.action);
  if (filters.userId) params.set("userId", filters.userId);
  if (filters.resourceType) params.set("resourceType", filters.resourceType);
  if (filters.resourceId) params.set("resourceId", filters.resourceId);
  if (filters.severity) params.set("severity", filters.severity);
  if (filters.search) params.set("search", filters.search);
  if (filters.startDate) params.set("startDate", filters.startDate);
  if (filters.endDate) params.set("endDate", filters.endDate);
  if (filters.isUserVisible !== undefined) params.set("isUserVisible", String(filters.isUserVisible));

  params.set("sortBy", sort.field);
  params.set("sortOrder", sort.direction);
  params.set("limit", pagination.limit.toString());
  params.set("offset", pagination.offset.toString());
  if (bundleRoutine) params.set("bundleRoutine", "true");

  const response = await fetch(`/api/admin/audit-logs?${params.toString()}`, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
    },
  });

  if (!response.ok) {
    if (response.status === 403) {
      throw new Error(t("admin.accessDenied"));
    }
    throw new Error(t("common.fetchError", { item: t("admin.auditLogs") }));
  }

  const data = await response.json();

  // Parse date strings to Date objects
  const logs = data.logs.map((log: Record<string, unknown>) => ({
    ...log,
    timestamp: new Date(log.timestamp as string),
  }));
  const routineBundles = (data.routineBundles ?? []).map((bundle: Record<string, unknown>) => ({
    ...bundle,
    firstTimestamp: new Date(bundle.firstTimestamp as string),
    lastTimestamp: new Date(bundle.lastTimestamp as string),
  }));

  return {
    logs,
    total: data.pagination.total,
    limit: data.pagination.limit,
    offset: data.pagination.offset,
    routineBundles,
  };
}

/**
 * Delete audit logs by IDs via API
 */
async function deleteLogsByIdsApi(
  logIds: string[],
  t: ReturnType<typeof useTranslations>,
): Promise<{ deletedCount: number }> {
  const response = await fetch("/api/admin/audit-logs", {
    method: "DELETE",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ logIds }),
  });

  if (!response.ok) {
    if (response.status === 403) {
      throw new Error(t("admin.accessDenied"));
    }
    throw new Error(t("common.deleteError", { item: t("admin.auditLogs") }));
  }

  return await response.json();
}

/**
 * Delete audit logs by date via API
 */
async function deleteLogsByDateApi(
  beforeDate: string,
  t: ReturnType<typeof useTranslations>,
): Promise<{ deletedCount: number }> {
  const response = await fetch(
    `/api/admin/audit-logs?before=${encodeURIComponent(beforeDate)}`,
    {
      method: "DELETE",
    },
  );

  if (!response.ok) {
    if (response.status === 403) {
      throw new Error(t("admin.accessDenied"));
    }
    throw new Error(t("common.deleteError", { item: t("admin.auditLogs") }));
  }

  return await response.json();
}

/**
 * Admin Audit Logs Hook
 *
 * Provides functions for managing audit logs in the admin panel.
 * Uses React Query for automatic polling and cache management.
 *
 * Features:
 * - Fetch audit logs with filtering, sorting, and pagination
 * - Delete audit logs by IDs (superadmin only)
 * - Delete audit logs by date (superadmin only)
 * - Optimistic updates for instant UI feedback
 * - Error handling with toast notifications
 * - Automatic cache invalidation
 *
 * @param filters - Audit log filters
 * @param sort - Sort options (field, direction)
 * @param pagination - Pagination options (limit, offset)
 * @returns Object with audit log data and management functions
 */
export function useAdminAuditLogs(
  filters: AuditLogFilters = {},
  sort: AuditLogSort = { field: "timestamp", direction: "desc" },
  pagination: AuditLogPagination = { limit: 25, offset: 0 },
  /** Callers that only need the delete actions skip the polling list query */
  { listEnabled = true, bundleRoutine = false }: { listEnabled?: boolean; bundleRoutine?: boolean } = {},
) {
  const t = useTranslations();
  const queryClient = useQueryClient();

  // Fetch audit logs list with polling
  const {
    data: logsData,
    isLoading,
    error,
    refetch,
  } = useQuery({
    queryKey: queryKeys.admin.auditLogs({ filters, sort, pagination, bundleRoutine, t }),
    queryFn: () => fetchAuditLogsApi(filters, sort, pagination, t, bundleRoutine),
    enabled: listEnabled,
    refetchInterval: BACKGROUND_REFETCH_INTERVAL,
  });

  // Delete audit logs by IDs mutation
  const deleteByIdsMutation = useMutation({
    mutationFn: (logIds: string[]) => deleteLogsByIdsApi(logIds, t),
    onMutate: async (logIds) => {
      await queryClient.cancelQueries({
        queryKey: queryKeys.admin.auditLogs({ filters, sort, pagination, bundleRoutine }),
      });
      const previous = queryClient.getQueryData(
        queryKeys.admin.auditLogs({ filters, sort, pagination, bundleRoutine }),
      );

      // Optimistic update
      queryClient.setQueryData(
        queryKeys.admin.auditLogs({ filters, sort, pagination, bundleRoutine }),
        (old: AuditLogsResponse | undefined) => {
          if (!old) return old;
          return {
            ...old,
            logs: old.logs.filter((log) => !logIds.includes(log.id)),
            total: old.total - logIds.length,
          };
        },
      );

      return { previous };
    },
    onError: (err, logIds, context) => {
      queryClient.setQueryData(
        queryKeys.admin.auditLogs({ filters, sort, pagination, bundleRoutine }),
        context?.previous,
      );
      toast.error(
        err instanceof Error
          ? err.message
          : t("common.deleteError", { item: t("admin.auditLogs") }),
      );
    },
    onSuccess: (data) => {
      toast.success(t("common.deletedCount", { count: data.deletedCount }));
    },
    onSettled: () => {
      queryClient.invalidateQueries({ queryKey: queryKeys.admin.auditLogsAll });
      queryClient.invalidateQueries({ queryKey: queryKeys.admin.stats });
    },
  });

  // Delete audit logs by date mutation
  const deleteByDateMutation = useMutation({
    mutationFn: (beforeDate: string) => deleteLogsByDateApi(beforeDate, t),
    onError: (err) => {
      toast.error(
        err instanceof Error
          ? err.message
          : t("common.deleteError", { item: t("admin.auditLogs") }),
      );
    },
    onSuccess: (data) => {
      toast.success(t("common.deletedCount", { count: data.deletedCount }));
    },
    onSettled: () => {
      queryClient.invalidateQueries({ queryKey: queryKeys.admin.auditLogsAll });
      queryClient.invalidateQueries({ queryKey: queryKeys.admin.stats });
    },
  });

  return {
    // Data
    logs: logsData?.logs || [],
    total: logsData?.total || 0,
    limit: logsData?.limit || pagination.limit,
    offset: logsData?.offset || pagination.offset,
    routineBundles: logsData?.routineBundles || [],
    isLoading: isLoading || deleteByIdsMutation.isPending || deleteByDateMutation.isPending,
    error,

    // Functions
    refetch,
    deleteLogsByIds: async (logIds: string[]): Promise<boolean> => {
      if (logIds.length === 0) {
        return false;
      }
      try {
        await deleteByIdsMutation.mutateAsync(logIds);
        return true;
      } catch {
        return false;
      }
    },
    deleteLogsByDate: async (beforeDate: string): Promise<boolean> => {
      try {
        await deleteByDateMutation.mutateAsync(beforeDate);
        return true;
      } catch {
        return false;
      }
    },
    fetchAuditLogs: async (
      searchFilters: AuditLogFilters,
      searchSort: AuditLogSort,
      searchPagination: AuditLogPagination,
    ): Promise<AuditLogsResponse | null> => {
      try {
        return await fetchAuditLogsApi(
          searchFilters,
          searchSort,
          searchPagination,
          t,
        );
      } catch {
        return null;
      }
    },
  };
}