Merge pull request #17 from emanuellcs/fix-finance

Fix finance

Author: spacobellas

actions/appointments.ts

@@ -3,102 +3,51 @@
 import { revalidatePath } from "next/cache";
 import { getSupabaseAdmin } from "@/lib/supabase/admin";
 import { parseSupabaseError } from "@/lib/error-handler";
-import { Appointment, SaleStatus } from "@/types";
+import { Appointment, SaleStatus, AppointmentStatus } from "@/types";
 import { supabaseAppointmentToAppointment } from "@/lib/utils/mapping";
-import { createSaleAction } from "./finance";
 
 /**
- * Creates a new appointment.
+ * Creates a new appointment atomically with its sale using an RPC.
+ * Resolves Rule 1 (Atomicity) and Rule 2 (Commission Tracking).
  */
 export async function createAppointmentAction(
   appointment: Omit<Appointment, "id" | "created_at">,
 ) {
   try {
     const supabase = getSupabaseAdmin();
 
-    // 1. Create the appointment
-    const payload = {
-      client_id: parseInt(appointment.clientId),
-      professional_id: appointment.professionalId,
-      start_time: appointment.startTime,
-      end_time: appointment.endTime,
-      status: appointment.status,
-      notes: appointment.notes || null,
+    const rpcPayload = {
+      p_client_id: parseInt(appointment.clientId),
+      p_professional_id: appointment.professionalId,
+      p_start_time: appointment.startTime,
+      p_end_time: appointment.endTime,
+      p_notes: appointment.notes || null,
+      p_service_variants:
+        appointment.serviceVariants?.map((sv) => ({
+          service_variant_id: parseInt(sv.serviceVariantId),
+          quantity: sv.quantity,
+        })) || [],
     };
 
-    const { data: appointmentData, error: appointmentError } = await supabase
-      .from("appointments")
-      .insert([payload])
-      .select(`*, clients(full_name)`)
-      .single();
+    // Rule 1: Use atomic RPC to prevent "ghost appointments"
+    const { data, error } = await supabase.rpc(
+      "create_appointment_with_sale",
+      rpcPayload,
+    );
 
-    if (appointmentError) {
+    if (error) {
       return {
         success: false,
-        error: parseSupabaseError(appointmentError).description,
+        error: parseSupabaseError(error).description,
       };
     }
 
-    const appointmentId = appointmentData.id;
-
-    // 2. Create appointment services and calculate total price
-    let totalAmount = 0;
-    const items: Array<{
-      serviceVariantId: string;
-      quantity: number;
-      unitPrice: number;
-      subtotal: number;
-      professionalId: string;
-    }> = [];
-
-    if (appointment.serviceVariants && appointment.serviceVariants.length > 0) {
-      for (const sv of appointment.serviceVariants) {
-        // Fetch price for each variant
-        const { data: variantData } = await supabase
-          .from("service_variants")
-          .select("price")
-          .eq("id", parseInt(sv.serviceVariantId))
-          .single();
-
-        const unitPrice = variantData?.price || 0;
-        const subtotal = unitPrice * sv.quantity;
-        totalAmount += subtotal;
-
-        items.push({
-          serviceVariantId: sv.serviceVariantId,
-          quantity: sv.quantity,
-          unitPrice: unitPrice,
-          subtotal: subtotal,
-          professionalId: appointment.professionalId,
-        });
-
-        // Insert into appointment_services
-        await supabase.from("appointment_services").insert([
-          {
-            appointment_id: appointmentId,
-            service_variant_id: parseInt(sv.serviceVariantId),
-            quantity: sv.quantity,
-          },
-        ]);
-      }
-
-      // 3. Create a pending sale automatically
-      await createSaleAction({
-        clientId: appointment.clientId,
-        appointmentId: String(appointmentId),
-        items: items,
-        totalAmount: totalAmount,
-        status: SaleStatus.PENDING,
-        notes: `Gerada automaticamente do agendamento #${appointmentId}`,
-      });
-    }
-
     revalidatePath("/agenda");
     revalidatePath("/financeiro");
 
     return {
       success: true,
-      data: supabaseAppointmentToAppointment(appointmentData),
+      data: supabaseAppointmentToAppointment(data),
     };
   } catch (error: unknown) {
     console.error("Error in createAppointmentAction:", error);
@@ -107,7 +56,8 @@ export async function createAppointmentAction(
 }
 
 /**
- * Updates an existing appointment.
+ * Updates an existing appointment and syncs related sale status.
+ * Resolves Rule 3 (End-of-day reconciliation).
  */
 export async function updateAppointmentAction(
   id: string,
@@ -146,7 +96,19 @@ export async function updateAppointmentAction(
       return { success: false, error: parseSupabaseError(error).description };
     }
 
+    // Rule 3 Sync: If appointment is cancelled, cancel the associated sale
+    if (appointment.status === AppointmentStatus.CANCELLED) {
+      await supabase
+        .from("sales")
+        .update({
+          status: SaleStatus.CANCELLED,
+          updated_at: new Date().toISOString(),
+        })
+        .eq("appointment_id", parseInt(id));
+    }
+
     revalidatePath("/agenda");
+    revalidatePath("/financeiro");
     return { success: true, data: supabaseAppointmentToAppointment(data) };
   } catch (error: unknown) {
     console.error("Error in updateAppointmentAction:", error);

actions/finance.ts

@@ -144,12 +144,13 @@ export async function createSaleAction(sale: NewSale) {
 
 /**
  * Helper to check if a sale is fully paid and update its status.
+ * Now also updates related appointments to 'completed'.
  */
 async function syncSaleStatus(supabase: any, saleId: number) {
   // Fetch fresh data including payments
   const { data: sale } = await supabase
     .from("sales")
-    .select("total_amount, payments(amount, status)")
+    .select("total_amount, appointment_id, payments(amount, status)")
     .eq("id", saleId)
     .single();
 
@@ -170,6 +171,17 @@ async function syncSaleStatus(supabase: any, saleId: number) {
       updated_at: new Date().toISOString(),
     })
     .eq("id", saleId);
+
+  // Issue A & B Fix: Sync appointment status
+  if (sale.appointment_id && newStatus === "paid") {
+    await supabase
+      .from("appointments")
+      .update({
+        status: "completed",
+        updated_at: new Date().toISOString(),
+      })
+      .eq("id", sale.appointment_id);
+  }
 }
 
 /**
@@ -296,3 +308,102 @@ export async function updatePaymentStatusAction(
     return { success: false, error: "Falha ao atualizar status do pagamento." };
   }
 }
+
+/**
+ * Updates a sale's generic data (total, notes, status, etc).
+ */
+export async function updateSaleAction(id: string, updates: Partial<Sale>) {
+  try {
+    const supabase = getSupabaseAdmin();
+    const payload: any = { updated_at: new Date().toISOString() };
+    if (updates.totalAmount !== undefined)
+      payload.total_amount = updates.totalAmount;
+    if (updates.notes !== undefined) payload.notes = updates.notes;
+    if (updates.status !== undefined) payload.status = updates.status;
+
+    const { data, error } = await supabase
+      .from("sales")
+      .update(payload)
+      .eq("id", parseInt(id))
+      .select(
+        `*, client:clients(full_name), professional:professionals!sales_professional_id_fkey(full_name), items:sale_items(*, professional:professionals(full_name), variant:service_variants(variant_name, service:services(name))), payments(*)`,
+      )
+      .single();
+
+    if (error) {
+      return { success: false, error: parseSupabaseError(error).description };
+    }
+
+    revalidatePath("/financeiro");
+    revalidatePath("/relatorios");
+    return { success: true, data: supabaseSaleToSale(data) };
+  } catch (error: any) {
+    console.error("Error in updateSaleAction:", error);
+    return { success: false, error: "Falha ao atualizar venda." };
+  }
+}
+
+/**
+ * Process a manual payment from physical POS (Issue C, D, Fatal Flaw).
+ * Resolves Rule 2 (Commission Tracking) by ensuring professional_id is persisted.
+ */
+export async function processManualPaymentAction(
+  saleId: number,
+  paymentMethod: string,
+  amount: number,
+  professionalId?: string,
+) {
+  try {
+    const supabase = getSupabaseAdmin();
+
+    // Rule 2 Fix: Resolve professional_id from the sale if not provided
+    // This ensures commission tracking is maintained even if manual payment is registered without explicit prof ID
+    let resolvedProfId = professionalId;
+    if (!resolvedProfId) {
+      const { data: saleRow } = await supabase
+        .from("sales")
+        .select("professional_id")
+        .eq("id", saleId)
+        .single();
+      resolvedProfId = saleRow?.professional_id;
+    }
+
+    // Issue D: Track WHO got paid and WHEN
+    const payload: any = {
+      sale_id: saleId,
+      amount: amount,
+      payment_method: paymentMethod,
+      status: "paid",
+      paid_at: new Date().toISOString(),
+      professional_id: resolvedProfId || null,
+    };
+
+    const { error } = await supabase.from("payments").insert([payload]);
+
+    if (error) {
+      return { success: false, error: parseSupabaseError(error).description };
+    }
+
+    // Fatal Flaw: Sum all successful payments and conditionally update status
+    await syncSaleStatus(supabase, saleId);
+
+    // Fetch fresh sale data to determine if fully paid
+    const { data: freshSale } = await supabase
+      .from("sales")
+      .select("status")
+      .eq("id", saleId)
+      .single();
+
+    revalidatePath("/financeiro");
+    revalidatePath("/agenda");
+    revalidatePath("/relatorios");
+
+    return {
+      success: true,
+      isFullyPaid: freshSale?.status === "paid",
+    };
+  } catch (error: any) {
+    console.error("Error in processManualPaymentAction:", error);
+    return { success: false, error: "Falha ao processar pagamento." };
+  }
+}