events.cancelEvent

export const cancelEvent = mutation({
  args: { eventId: v.id("events") },
  handler: async (ctx, { eventId }) => {
    const event = await ctx.db.get(eventId);
    if (!event) throw new Error("Event not found");

    // Get all valid tickets for this event
    const tickets = await ctx.db
      .query("tickets")
      .withIndex("by_event", (q) => q.eq("eventId", eventId))
      .filter((q) =>
        q.or(q.eq(q.field("status"), "valid"), q.eq(q.field("status"), "used"))
      )
      .collect();

    if (tickets.length > 0) {
      throw new Error(
        "Cannot cancel event with active tickets. Please refund all tickets first."
      );
    }

    // Mark event as cancelled
    await ctx.db.patch(eventId, {
      is_cancelled: true,
    });

    // Delete any waiting list entries
    const waitingListEntries = await ctx.db
      .query("waitingList")
      .withIndex("by_event_status", (q) => q.eq("eventId", eventId))
      .collect();

    for (const entry of waitingListEntries) {
      await ctx.db.delete(entry._id);
    }

    return { success: true };
  },
});

import { useMutation } from "convex/react";
import { api } from "../convex/_generated/api";
import { refundEventTickets } from "@/actions/refund-event-ticket";

function CancelEventButton({ eventId }) {
  const cancelEvent = useMutation(api.events.cancelEvent);

  const handleCancel = async () => {
    // Confirm with user first
    const confirmed = confirm(
      "Are you sure you want to cancel this event? " +
      "All tickets will be refunded and the event will be cancelled permanently."
    );
    
    if (!confirmed) return;

    try {
      // Step 1: Refund all tickets first (required)
      await refundEventTickets(eventId);
      
      // Step 2: Cancel the event
      await cancelEvent({ eventId });
      
      toast.success("Event cancelled", {
        description: "All tickets have been refunded successfully.",
      });
      
      router.push("/seller/events");
    } catch (error) {
      console.error("Failed to cancel event:", error);
      toast.error("Failed to cancel event", {
        description: error.message || "Please try again.",
      });
    }
  };
}

{
  "success": true
}

import { useQuery } from "convex/react";
import { api } from "../convex/_generated/api";

function EventCancellationCheck({ eventId }) {
  const availability = useQuery(api.events.getEventAvailability, { eventId });
  
  const hasActiveTickets = availability && availability.purchasedCount > 0;
  
  if (hasActiveTickets) {
    return (
      <div>
        <p>Cannot cancel: {availability.purchasedCount} tickets sold</p>
        <p>Please refund all tickets before cancelling</p>
      </div>
    );
  }
  
  return <CancelButton eventId={eventId} />;
}

import { refundEventTickets } from "@/actions/refund-event-ticket";

// Server action that processes Stripe refunds
try {
  await refundEventTickets(eventId);
  console.log("All tickets refunded successfully");
} catch (error) {
  console.error("Refund failed:", error);
  throw error;
}

const result = await cancelEvent({ eventId });
// result = { success: true }

// events.get query excludes cancelled events
export const get = query({
  args: {},
  handler: async (ctx) => {
    return await ctx.db
      .query("events")
      .filter((q) => q.eq(q.field("is_cancelled"), undefined))
      .collect();
  },
});

// events.search also excludes cancelled events
export const search = query({
  args: { searchTerm: v.string() },
  handler: async (ctx, { searchTerm }) => {
    const events = await ctx.db
      .query("events")
      .filter((q) => q.eq(q.field("is_cancelled"), undefined))
      .collect();
    // ... filtering logic
  },
});

try {
  // Step 1: Refund all tickets
  await refundEventTickets(eventId);
  
  // Step 2: Cancel event
  const result = await cancelEvent({ eventId });
  
  if (result.success) {
    toast.success("Event cancelled successfully");
    router.push("/seller/events");
  }
} catch (error) {
  console.error("Cancellation failed:", error);
  
  if (error.message?.includes("active tickets")) {
    toast.error("Cannot cancel event", {
      description: "Please refund all tickets first.",
    });
  } else if (error.message === "Event not found") {
    toast.error("Event not found", {
      description: "This event may have already been deleted.",
    });
  } else {
    toast.error("Cancellation failed", {
      description: "Please try again or contact support.",
    });
  }
}