Improve time tracking stability

- Address race condition in startTimeTracking by introducing duplicate guard and safer insertion
- Ensure stopTimeTracking handles duplicates by closing all active entries
- Add related logging to aid debugging and prevent duplicate time entries

X-Lovable-Edit-ID: edt-6cd44d04-2f9c-4386-8b1e-9c1c84e43d5a

Author: lovable-dev[bot]

src/lib/database.ts

@@ -122,12 +122,27 @@ export async function startTimeTracking(
   operatorId: string,
   tenantId: string
 ) {
-  // Check for existing active time entries for this operator
+  // Check for existing active time entries for this operation specifically
+  const { data: existingForOperation } = await supabase
+    .from("time_entries")
+    .select("id")
+    .eq("operation_id", operationId)
+    .eq("operator_id", operatorId)
+    .is("end_time", null);
+
+  // Prevent duplicate entries for same operation (race condition protection)
+  if (existingForOperation && existingForOperation.length > 0) {
+    console.log("Time entry already exists for this operation, skipping duplicate");
+    return; // Silently succeed - entry already exists
+  }
+
+  // Check for existing active time entries for this operator on OTHER operations
   const { data: activeEntries } = await supabase
     .from("time_entries")
     .select("id, operation_id, operations(operation_name)")
     .eq("operator_id", operatorId)
     .eq("tenant_id", tenantId)
+    .neq("operation_id", operationId) // Exclude current operation
     .is("end_time", null);
 
   if (activeEntries && activeEntries.length > 0) {
@@ -169,7 +184,19 @@ export async function startTimeTracking(
   const startedAt = new Date().toISOString();
   const isNewStart = operation.status === "not_started";
 
-  // Create time entry
+  // Create time entry - use a lock by checking again right before insert
+  const { data: doubleCheck } = await supabase
+    .from("time_entries")
+    .select("id")
+    .eq("operation_id", operationId)
+    .eq("operator_id", operatorId)
+    .is("end_time", null);
+
+  if (doubleCheck && doubleCheck.length > 0) {
+    console.log("Time entry created by concurrent request, skipping");
+    return;
+  }
+
   const { error: timeError } = await supabase.from("time_entries").insert({
     operation_id: operationId,
     operator_id: operatorId,
@@ -274,16 +301,34 @@ export async function startTimeTracking(
 }
 
 export async function stopTimeTracking(operationId: string, operatorId: string) {
-  // Find active time entry
-  const { data: entry } = await supabase
+  // Find active time entries (may be multiple due to race conditions)
+  const { data: entries } = await supabase
     .from("time_entries")
     .select("id, start_time, is_paused")
     .eq("operation_id", operationId)
     .eq("operator_id", operatorId)
     .is("end_time", null)
-    .single();
+    .order("start_time", { ascending: false });
 
-  if (!entry) throw new Error("No active time entry found");
+  if (!entries || entries.length === 0) throw new Error("No active time entry found");
+
+  // Use the most recent entry
+  const entry = entries[0];
+
+  // If there are duplicates, close them all
+  if (entries.length > 1) {
+    console.log(`Found ${entries.length} duplicate time entries, closing all`);
+    const now = new Date();
+    for (let i = 1; i < entries.length; i++) {
+      const dupEntry = entries[i];
+      const startTime = new Date(dupEntry.start_time);
+      const duration = Math.round((now.getTime() - startTime.getTime()) / 1000);
+      await supabase
+        .from("time_entries")
+        .update({ end_time: now.toISOString(), duration })
+        .eq("id", dupEntry.id);
+    }
+  }
 
   // If paused, close the current pause
   if (entry.is_paused) {

src/pages/admin/StuckTimeEntries.tsx

@@ -1,10 +1,9 @@
-import { useState } from "react";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { supabase } from "@/integrations/supabase/client";
 import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
 import { Badge } from "@/components/ui/badge";
-import { Clock, Square, AlertTriangle } from "lucide-react";
+import { Clock, Square, AlertTriangle, Loader2 } from "lucide-react";
 import { toast } from "sonner";
 import { format } from "date-fns";
 
@@ -43,7 +42,7 @@ export default function StuckTimeEntries() {
       if (error) throw error;
       return data;
     },
-    refetchInterval: 5000, // Refresh every 5 seconds
+    refetchInterval: 5000,
   });
 
   // Mutation to force stop a time entry
@@ -80,19 +79,73 @@ export default function StuckTimeEntries() {
     },
   });
 
+  // Mutation to stop all entries
+  const stopAllMutation = useMutation({
+    mutationFn: async () => {
+      if (!stuckEntries || stuckEntries.length === 0) return 0;
+      
+      const now = new Date();
+      let stoppedCount = 0;
+
+      for (const entry of stuckEntries) {
+        const startTime = new Date(entry.start_time);
+        const durationSeconds = Math.floor((now.getTime() - startTime.getTime()) / 1000);
+
+        const { error } = await supabase
+          .from("time_entries")
+          .update({
+            end_time: now.toISOString(),
+            duration: durationSeconds,
+          })
+          .eq("id", entry.id);
+
+        if (!error) stoppedCount++;
+      }
+      
+      return stoppedCount;
+    },
+    onSuccess: (count) => {
+      queryClient.invalidateQueries({ queryKey: ["stuck-time-entries"] });
+      toast.success(`Stopped ${count} time entries`);
+    },
+    onError: (error: Error) => {
+      toast.error(`Failed to stop entries: ${error.message}`);
+    },
+  });
+
   if (isLoading) {
     return (
-      <div className="p-6">
-        <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary" />
+      <div className="p-6 flex items-center justify-center">
+        <Loader2 className="h-8 w-8 animate-spin text-primary" />
       </div>
     );
   }
 
   return (
     <div className="p-6 space-y-4">
-      <div className="flex items-center gap-2">
-        <AlertTriangle className="h-6 w-6 text-yellow-500" />
-        <h1 className="text-2xl font-bold">Stuck Time Entries</h1>
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-2">
+          <AlertTriangle className="h-6 w-6 text-yellow-500" />
+          <h1 className="text-2xl font-bold">Stuck Time Entries</h1>
+          {stuckEntries && stuckEntries.length > 0 && (
+            <Badge variant="destructive">{stuckEntries.length}</Badge>
+          )}
+        </div>
+        {stuckEntries && stuckEntries.length > 1 && (
+          <Button
+            variant="destructive"
+            onClick={() => stopAllMutation.mutate()}
+            disabled={stopAllMutation.isPending}
+            className="gap-2"
+          >
+            {stopAllMutation.isPending ? (
+              <Loader2 className="h-4 w-4 animate-spin" />
+            ) : (
+              <Square className="h-4 w-4" />
+            )}
+            Stop All ({stuckEntries.length})
+          </Button>
+        )}
       </div>
 
       <p className="text-muted-foreground">