Implementiere Stornierungssystem und E-Mail-Links zur Hauptseite

- Neues Stornierungssystem mit sicheren Token-basierten Links
- Stornierungsfrist konfigurierbar über MIN_STORNO_TIMESPAN (24h Standard)
- Stornierungs-Seite mit Buchungsdetails und Ein-Klick-Stornierung
- Automatische Slot-Freigabe bei Stornierung
- Stornierungs-Link in Bestätigungs-E-Mails integriert
- Alle E-Mails enthalten jetzt Links zur Hauptseite (DOMAIN Variable)
- Schöne HTML-Buttons und Text-Links in allen E-Mail-Templates
- Vollständige Validierung: Vergangenheits-Check, Token-Ablauf, Stornierungsfrist
- Responsive Stornierungs-Seite mit Loading-States und Fehlerbehandlung
- Dokumentation in README.md aktualisiert

src/server/rpc/availability.ts

@@ -85,7 +85,34 @@ const remove = os
   });
 
 const list = os.handler(async () => {
-  return kv.getAllItems();
+  const allSlots = await kv.getAllItems();
+  
+  // Filter out past slots automatically
+  const today = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
+  const now = new Date();
+  const currentTime = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+  
+  const filteredSlots = allSlots.filter(slot => {
+    // Keep slots for future dates
+    if (slot.date > today) return true;
+    
+    // For today: only keep future time slots
+    if (slot.date === today) {
+      return slot.time > currentTime;
+    }
+    
+    // Remove past slots
+    return false;
+  });
+  
+  // Debug logging (commented out - uncomment if needed)
+  // const statusCounts = filteredSlots.reduce((acc, slot) => {
+  //   acc[slot.status] = (acc[slot.status] || 0) + 1;
+  //   return acc;
+  // }, {} as Record<string, number>);
+  // console.log(`Availability list: ${filteredSlots.length} slots (${JSON.stringify(statusCounts)})`);
+  
+  return filteredSlots;
 });
 
 const get = os.input(z.string()).handler(async ({ input }) => {

src/server/rpc/bookings.ts

@@ -5,6 +5,13 @@ import { createKV } from "@/server/lib/create-kv";
 import { createKV as createAvailabilityKV } from "@/server/lib/create-kv";
 import { sendEmail, sendEmailWithAGB, sendEmailWithInspirationPhoto } from "@/server/lib/email";
 import { renderBookingPendingHTML, renderBookingConfirmedHTML, renderBookingCancelledHTML, renderAdminBookingNotificationHTML } from "@/server/lib/email-templates";
+import { router } from "@/server/rpc";
+import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+
+// Create a server-side client to call other RPC endpoints
+const link = new RPCLink({ url: "http://localhost:5173/rpc" });
+const queryClient = createORPCClient<typeof router>(link);
 
 // Helper function to convert date from yyyy-mm-dd to dd.mm.yyyy
 function formatDateGerman(dateString: string): string {
@@ -57,6 +64,27 @@ const treatmentsKV = createTreatmentsKV<Treatment>("treatments");
 const create = os
   .input(BookingSchema.omit({ id: true, createdAt: true, status: true }))
   .handler(async ({ input }) => {
+    // console.log("Booking create called with input:", {
+    //   ...input,
+    //   inspirationPhoto: input.inspirationPhoto ? `[${input.inspirationPhoto.length} chars]` : null
+    // });
+    
+    try {
+    // Validate that the booking is not in the past
+    const today = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
+    if (input.appointmentDate < today) {
+      throw new Error("Buchungen für vergangene Termine sind nicht möglich.");
+    }
+    
+    // For today's bookings, check if the time is not in the past
+    if (input.appointmentDate === today) {
+      const now = new Date();
+      const currentTime = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+      if (input.appointmentTime <= currentTime) {
+        throw new Error("Buchungen für vergangene Uhrzeiten sind nicht möglich.");
+      }
+    }
+    
     // Prevent double booking: same customer email with pending/confirmed on same date
     const existing = await kv.getAllItems();
     const hasConflict = existing.some(b =>
@@ -91,11 +119,14 @@ const create = os
     // Notify customer: request received (pending)
     void (async () => {
       const formattedDate = formatDateGerman(input.appointmentDate);
+      const domain = process.env.DOMAIN || 'localhost:5173';
+      const protocol = domain.includes('localhost') ? 'http' : 'https';
+      const homepageUrl = `${protocol}://${domain}`;
       const html = await renderBookingPendingHTML({ name: input.customerName, date: input.appointmentDate, time: input.appointmentTime });
       await sendEmail({
       to: input.customerEmail,
       subject: "Deine Terminanfrage ist eingegangen",
-      text: `Hallo ${input.customerName},\n\nwir haben deine Anfrage für ${formattedDate} um ${input.appointmentTime} erhalten. Wir bestätigen deinen Termin in Kürze.\n\nLiebe Grüße\nStargirlnails Kiel`,
+      text: `Hallo ${input.customerName},\n\nwir haben deine Anfrage für ${formattedDate} um ${input.appointmentTime} erhalten. Wir bestätigen deinen Termin in Kürze.\n\nZur Website: ${homepageUrl}\n\nLiebe Grüße\nStargirlnails Kiel`,
         html,
       }).catch(() => {});
     })();
@@ -119,6 +150,10 @@ const create = os
         hasInspirationPhoto: !!input.inspirationPhoto
       });
 
+      const domain = process.env.DOMAIN || 'localhost:5173';
+      const protocol = domain.includes('localhost') ? 'http' : 'https';
+      const homepageUrl = `${protocol}://${domain}`;
+      
       const adminText = `Neue Buchungsanfrage eingegangen:\n\n` +
         `Name: ${input.customerName}\n` +
         `Telefon: ${input.customerPhone}\n` +
@@ -127,6 +162,7 @@ const create = os
         `Uhrzeit: ${input.appointmentTime}\n` +
         `${input.notes ? `Notizen: ${input.notes}\n` : ''}` +
         `Inspiration-Foto: ${input.inspirationPhoto ? 'Im Anhang verfügbar' : 'Kein Foto hochgeladen'}\n\n` +
+        `Zur Website: ${homepageUrl}\n\n` +
         `Bitte logge dich in das Admin-Panel ein, um die Buchung zu bearbeiten.`;
 
       if (input.inspirationPhoto) {
@@ -146,13 +182,17 @@ const create = os
       }
     })();
     return booking;
+    } catch (error) {
+      console.error("Booking creation error:", error);
+      throw error;
+    }
   });
 
 // Owner check reuse (simple inline version)
 type Session = { id: string; userId: string; expiresAt: string; createdAt: string };
 type User = { id: string; username: string; email: string; passwordHash: string; role: "customer" | "owner"; createdAt: string };
-const sessionsKV = createAvailabilityKV<Session>("sessions");
-const usersKV = createAvailabilityKV<User>("users");
+const sessionsKV = createKV<Session>("sessions");
+const usersKV = createKV<User>("users");
 async function assertOwner(sessionId: string): Promise<void> {
   const session = await sessionsKV.getItem(sessionId);
   if (!session) throw new Error("Invalid session");
@@ -180,6 +220,8 @@ const updateStatus = os
     if (booking.slotId) {
       const slot = await availabilityKV.getItem(booking.slotId);
       if (slot) {
+        // console.log(`Updating slot ${slot.id} (${slot.date} ${slot.time}) from ${slot.status} to ${input.status}`);
+        
         if (input.status === "cancelled") {
           // Free the slot again
           await availabilityKV.setItem(slot.id, {
@@ -187,6 +229,7 @@ const updateStatus = os
             status: "free",
             reservedByBookingId: undefined,
           });
+          // console.log(`Slot ${slot.id} freed due to cancellation`);
         } else if (input.status === "pending") {
           // keep reserved as pending
           if (slot.status !== "reserved") {
@@ -195,6 +238,7 @@ const updateStatus = os
               status: "reserved",
               reservedByBookingId: booking.id,
             });
+            // console.log(`Slot ${slot.id} reserved for pending booking`);
           }
         } else if (input.status === "confirmed" || input.status === "completed") {
           // keep reserved; optionally noop
@@ -204,6 +248,7 @@ const updateStatus = os
               status: "reserved",
               reservedByBookingId: booking.id,
             });
+            // console.log(`Slot ${slot.id} confirmed as reserved`);
           }
         }
       }
@@ -211,22 +256,40 @@ const updateStatus = os
     // Email notifications on status changes
     try {
       if (input.status === "confirmed") {
+        // Create cancellation token for this booking
+        const cancellationToken = await queryClient.cancellation.createToken({ bookingId: booking.id });
+        
         const formattedDate = formatDateGerman(booking.appointmentDate);
-        const html = await renderBookingConfirmedHTML({ name: booking.customerName, date: booking.appointmentDate, time: booking.appointmentTime });
+        const cancellationUrl = `${process.env.FRONTEND_URL || 'http://localhost:5173'}/cancel/${cancellationToken.token}`;
+        
+        const html = await renderBookingConfirmedHTML({ 
+          name: booking.customerName, 
+          date: booking.appointmentDate, 
+          time: booking.appointmentTime,
+          cancellationUrl 
+        });
+        
+        const domain = process.env.DOMAIN || 'localhost:5173';
+        const protocol = domain.includes('localhost') ? 'http' : 'https';
+        const homepageUrl = `${protocol}://${domain}`;
+        
         await sendEmailWithAGB({
           to: booking.customerEmail,
           subject: "Dein Termin wurde bestätigt - AGB im Anhang",
-          text: `Hallo ${booking.customerName},\n\nwir haben deinen Termin am ${formattedDate} um ${booking.appointmentTime} bestätigt.\n\nWichtiger Hinweis: Die Allgemeinen Geschäftsbedingungen (AGB) findest du im Anhang dieser E-Mail. Bitte lies sie vor deinem Termin durch.\n\nBis bald!\nStargirlnails Kiel`,
+          text: `Hallo ${booking.customerName},\n\nwir haben deinen Termin am ${formattedDate} um ${booking.appointmentTime} bestätigt.\n\nWichtiger Hinweis: Die Allgemeinen Geschäftsbedingungen (AGB) findest du im Anhang dieser E-Mail. Bitte lies sie vor deinem Termin durch.\n\nFalls du den Termin stornieren möchtest, kannst du das hier tun: ${cancellationUrl}\n\nZur Website: ${homepageUrl}\n\nBis bald!\nStargirlnails Kiel`,
           html,
           cc: process.env.ADMIN_EMAIL ? [process.env.ADMIN_EMAIL] : undefined,
         });
       } else if (input.status === "cancelled") {
         const formattedDate = formatDateGerman(booking.appointmentDate);
+        const domain = process.env.DOMAIN || 'localhost:5173';
+        const protocol = domain.includes('localhost') ? 'http' : 'https';
+        const homepageUrl = `${protocol}://${domain}`;
         const html = await renderBookingCancelledHTML({ name: booking.customerName, date: booking.appointmentDate, time: booking.appointmentTime });
         await sendEmail({
           to: booking.customerEmail,
           subject: "Dein Termin wurde abgesagt",
-          text: `Hallo ${booking.customerName},\n\nleider wurde dein Termin am ${formattedDate} um ${booking.appointmentTime} abgesagt. Bitte buche einen neuen Termin.\n\nLiebe Grüße\nStargirlnails Kiel`,
+          text: `Hallo ${booking.customerName},\n\nleider wurde dein Termin am ${formattedDate} um ${booking.appointmentTime} abgesagt. Bitte buche einen neuen Termin.\n\nZur Website: ${homepageUrl}\n\nLiebe Grüße\nStargirlnails Kiel`,
           html,
           cc: process.env.ADMIN_EMAIL ? [process.env.ADMIN_EMAIL] : undefined,
         });

src/server/rpc/cancellation.ts

@@ -0,0 +1,199 @@
+import { call, os } from "@orpc/server";
+import { z } from "zod";
+import { createKV } from "@/server/lib/create-kv";
+import { createKV as createAvailabilityKV } from "@/server/lib/create-kv";
+import { randomUUID } from "crypto";
+
+// Schema for cancellation token
+const CancellationTokenSchema = z.object({
+  id: z.string(),
+  bookingId: z.string(),
+  token: z.string(),
+  expiresAt: z.string(),
+  createdAt: z.string(),
+});
+
+type CancellationToken = z.output<typeof CancellationTokenSchema>;
+
+const cancellationKV = createKV<CancellationToken>("cancellation_tokens");
+
+// Types for booking and availability
+type Booking = {
+  id: string;
+  treatmentId: string;
+  customerName: string;
+  customerEmail: string;
+  customerPhone: string;
+  appointmentDate: string;
+  appointmentTime: string;
+  notes?: string;
+  inspirationPhoto?: string;
+  slotId?: string;
+  status: "pending" | "confirmed" | "cancelled" | "completed";
+  createdAt: string;
+};
+
+type Availability = {
+  id: string;
+  date: string;
+  time: string;
+  durationMinutes: number;
+  status: "free" | "reserved";
+  reservedByBookingId?: string;
+  createdAt: string;
+};
+
+const bookingsKV = createKV<Booking>("bookings");
+const availabilityKV = createAvailabilityKV<Availability>("availability");
+
+// Helper function to convert date from yyyy-mm-dd to dd.mm.yyyy
+function formatDateGerman(dateString: string): string {
+  const [year, month, day] = dateString.split('-');
+  return `${day}.${month}.${year}`;
+}
+
+// Create cancellation token for a booking
+const createToken = os
+  .input(z.object({ bookingId: z.string() }))
+  .handler(async ({ input }) => {
+    const booking = await bookingsKV.getItem(input.bookingId);
+    if (!booking) {
+      throw new Error("Booking not found");
+    }
+    
+    if (booking.status === "cancelled") {
+      throw new Error("Booking is already cancelled");
+    }
+    
+    // Create token that expires in 30 days
+    const expiresAt = new Date();
+    expiresAt.setDate(expiresAt.getDate() + 30);
+    
+    const token = randomUUID();
+    const cancellationToken: CancellationToken = {
+      id: randomUUID(),
+      bookingId: input.bookingId,
+      token,
+      expiresAt: expiresAt.toISOString(),
+      createdAt: new Date().toISOString(),
+    };
+    
+    await cancellationKV.setItem(cancellationToken.id, cancellationToken);
+    return { token, expiresAt: expiresAt.toISOString() };
+  });
+
+// Get booking details by token
+const getBookingByToken = os
+  .input(z.object({ token: z.string() }))
+  .handler(async ({ input }) => {
+    const tokens = await cancellationKV.getAllItems();
+    const validToken = tokens.find(t => 
+      t.token === input.token && 
+      new Date(t.expiresAt) > new Date()
+    );
+    
+    if (!validToken) {
+      throw new Error("Invalid or expired cancellation token");
+    }
+    
+    const booking = await bookingsKV.getItem(validToken.bookingId);
+    if (!booking) {
+      throw new Error("Booking not found");
+    }
+    
+    // Get treatment details
+    const treatmentsKV = createKV<any>("treatments");
+    const treatment = await treatmentsKV.getItem(booking.treatmentId);
+    
+    return {
+      id: booking.id,
+      customerName: booking.customerName,
+      appointmentDate: booking.appointmentDate,
+      appointmentTime: booking.appointmentTime,
+      treatmentId: booking.treatmentId,
+      treatmentName: treatment?.name || "Unbekannte Behandlung",
+      status: booking.status,
+      formattedDate: formatDateGerman(booking.appointmentDate),
+    };
+  });
+
+// Cancel booking by token
+const cancelByToken = os
+  .input(z.object({ token: z.string() }))
+  .handler(async ({ input }) => {
+    const tokens = await cancellationKV.getAllItems();
+    const validToken = tokens.find(t => 
+      t.token === input.token && 
+      new Date(t.expiresAt) > new Date()
+    );
+    
+    if (!validToken) {
+      throw new Error("Invalid or expired cancellation token");
+    }
+    
+    const booking = await bookingsKV.getItem(validToken.bookingId);
+    if (!booking) {
+      throw new Error("Booking not found");
+    }
+    
+    // Check if booking is already cancelled
+    if (booking.status === "cancelled") {
+      throw new Error("Booking is already cancelled");
+    }
+    
+    // Check minimum cancellation timespan from environment variable
+    const minStornoTimespan = parseInt(process.env.MIN_STORNO_TIMESPAN || "24"); // Default: 24 hours
+    const appointmentDateTime = new Date(`${booking.appointmentDate}T${booking.appointmentTime}:00`);
+    const now = new Date();
+    const timeDifferenceHours = (appointmentDateTime.getTime() - now.getTime()) / (1000 * 60 * 60);
+    
+    if (timeDifferenceHours < minStornoTimespan) {
+      throw new Error(`Stornierung ist nur bis ${minStornoTimespan} Stunden vor dem Termin möglich. Der Termin liegt nur noch ${Math.round(timeDifferenceHours)} Stunden in der Zukunft.`);
+    }
+    
+    // Check if booking is in the past (additional safety check)
+    const today = new Date().toISOString().split("T")[0];
+    if (booking.appointmentDate < today) {
+      throw new Error("Cannot cancel past bookings");
+    }
+    
+    // For today's bookings, check if the time is not in the past
+    if (booking.appointmentDate === today) {
+      const currentTime = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+      if (booking.appointmentTime <= currentTime) {
+        throw new Error("Cannot cancel bookings that have already started");
+      }
+    }
+    
+    // Update booking status
+    const updatedBooking = { ...booking, status: "cancelled" as const };
+    await bookingsKV.setItem(booking.id, updatedBooking);
+    
+    // Free the slot if it exists
+    if (booking.slotId) {
+      const slot = await availabilityKV.getItem(booking.slotId);
+      if (slot) {
+        const updatedSlot: Availability = {
+          ...slot,
+          status: "free",
+          reservedByBookingId: undefined,
+        };
+        await availabilityKV.setItem(slot.id, updatedSlot);
+      }
+    }
+    
+    // Invalidate the token
+    await cancellationKV.removeItem(validToken.id);
+    
+    return {
+      success: true,
+      message: "Booking cancelled successfully",
+      formattedDate: formatDateGerman(booking.appointmentDate),
+    };
+  });
+
+export const router = {
+  createToken,
+  getBookingByToken,
+  cancelByToken,
+};

src/server/rpc/index.ts

@@ -3,6 +3,7 @@ import { router as treatments } from "./treatments";
 import { router as bookings } from "./bookings";
 import { router as auth } from "./auth";
 import { router as availability } from "./availability";
+import { router as cancellation } from "./cancellation";
 
 export const router = {
   demo,
@@ -10,4 +11,5 @@ export const router = {
   bookings,
   auth,
   availability,
+  cancellation,
 };