@fleetbase/fleetops-engine 0.6.58 → 0.6.60

package/server/src/Console/Commands/ProcessMaintenanceTriggers.php

@@ -50,7 +50,7 @@ class ProcessMaintenanceTriggers extends Command
 
         $sandbox = (bool) $this->option('sandbox');
         $dryRun  = (bool) $this->option('dry-run');
-        $conn    = $sandbox ? 'sandbox' : 'mysql';
+        $conn    = $this->connectionName($sandbox);
 
         $this->info('Processing maintenance schedule triggers' . ($dryRun ? ' [DRY RUN]' : '') . ' at ' . Carbon::now()->toDateTimeString());
 
@@ -59,56 +59,25 @@ class ProcessMaintenanceTriggers extends Command
         // ------------------------------------------------------------------
         // Load all active schedules that have at least one threshold set
         // ------------------------------------------------------------------
-        $schedules = MaintenanceSchedule::on($conn)
-            ->withoutGlobalScopes()
-            ->where('status', 'active')
-            ->where(function ($q) {
-                $q->whereNotNull('next_due_date')
-                  ->orWhereNotNull('next_due_odometer')
-                  ->orWhereNotNull('next_due_engine_hours');
-            })
-            ->whereNull('deleted_at')
-            ->with('subject')
-            ->get();
+        $schedules = $this->schedules($conn);
 
         foreach ($schedules as $schedule) {
-            $subject         = $schedule->subject;
-            $currentOdometer = null;
-            $currentEngHours = null;
-
-            // Resolve current readings from the subject asset if it is a vehicle
-            if ($subject instanceof Vehicle) {
-                $currentOdometer = $subject->odometer;
-                $currentEngHours = $subject->engine_hours;
-            }
+            $subject                             = $schedule->subject;
+            [$currentOdometer, $currentEngHours] = $this->currentReadingsFromSubject($subject);
 
             if (!$schedule->isDue($currentOdometer, $currentEngHours)) {
                 continue;
             }
 
             // Build a human-readable reason string for logging
-            $reasons = [];
-            if ($schedule->next_due_date && now()->gte($schedule->next_due_date)) {
-                $reasons[] = 'date due ' . $schedule->next_due_date->toDateString();
-            }
-            if ($schedule->next_due_odometer && $currentOdometer !== null && $currentOdometer >= $schedule->next_due_odometer) {
-                $reasons[] = "odometer {$currentOdometer} >= {$schedule->next_due_odometer}";
-            }
-            if ($schedule->next_due_engine_hours && $currentEngHours !== null && $currentEngHours >= $schedule->next_due_engine_hours) {
-                $reasons[] = "engine hours {$currentEngHours} >= {$schedule->next_due_engine_hours}";
-            }
+            $reasons = $this->triggerReasons($schedule, $currentOdometer, $currentEngHours);
 
             $this->line("Triggered: schedule {$schedule->public_id} ({$schedule->name}) — " . implode(', ', $reasons));
 
             if (!$dryRun) {
                 // Check if a pending work order already exists for this schedule
                 // to avoid duplicates on repeated runs before the WO is completed
-                $existingOpen = WorkOrder::on($conn)
-                    ->withoutGlobalScopes()
-                    ->where('schedule_uuid', $schedule->uuid)
-                    ->whereIn('status', ['open', 'in_progress'])
-                    ->whereNull('deleted_at')
-                    ->exists();
+                $existingOpen = $this->openWorkOrderExists($conn, $schedule);
 
                 if ($existingOpen) {
                     $this->line('  → Skipped: open work order already exists for this schedule.');
@@ -117,10 +86,10 @@ class ProcessMaintenanceTriggers extends Command
 
                 // Auto-generate a work order from the schedule defaults
                 // Generate a sequential WO code: WO-YYYYMMDD-XXXX
-                $woCount = WorkOrder::on($conn)->withoutGlobalScopes()->whereNull('deleted_at')->count() + 1;
-                $woCode  = 'WO-' . now()->format('Ymd') . '-' . str_pad($woCount, 4, '0', STR_PAD_LEFT);
+                $woCount = $this->workOrderCount($conn) + 1;
+                $woCode  = $this->workOrderCode($woCount, now());
 
-                $workOrder = WorkOrder::on($conn)->create([
+                $workOrder = $this->createWorkOrder($conn, [
                     'company_uuid'    => $schedule->company_uuid,
                     'schedule_uuid'   => $schedule->uuid,
                     'subject'         => $schedule->name,
@@ -140,12 +109,95 @@ class ProcessMaintenanceTriggers extends Command
 
                 $this->line("  → Created work order {$workOrder->public_id}");
 
-                event('maintenance.triggered', [$schedule, $workOrder]);
+                $this->dispatchTriggeredEvent($schedule, $workOrder);
             }
 
             $triggered++;
         }
 
-        $this->info("Processed {$triggered} schedule trigger(s)" . ($dryRun ? ' (dry run — no work orders created)' : '.'));
+        $this->info($this->processedSummary($triggered, $dryRun));
+    }
+
+    protected function connectionName(bool $sandbox): string
+    {
+        return $sandbox ? 'sandbox' : 'mysql';
+    }
+
+    protected function schedules(string $conn)
+    {
+        return MaintenanceSchedule::on($conn)
+            ->withoutGlobalScopes()
+            ->where('status', 'active')
+            ->where(function ($q) {
+                $q->whereNotNull('next_due_date')
+                  ->orWhereNotNull('next_due_odometer')
+                  ->orWhereNotNull('next_due_engine_hours');
+            })
+            ->whereNull('deleted_at')
+            ->with('subject')
+            ->get();
+    }
+
+    protected function openWorkOrderExists(string $conn, MaintenanceSchedule $schedule): bool
+    {
+        return WorkOrder::on($conn)
+            ->withoutGlobalScopes()
+            ->where('schedule_uuid', $schedule->uuid)
+            ->whereIn('status', ['open', 'in_progress'])
+            ->whereNull('deleted_at')
+            ->exists();
+    }
+
+    protected function workOrderCount(string $conn): int
+    {
+        return WorkOrder::on($conn)->withoutGlobalScopes()->whereNull('deleted_at')->count();
+    }
+
+    protected function createWorkOrder(string $conn, array $attributes): WorkOrder
+    {
+        return WorkOrder::on($conn)->create($attributes);
+    }
+
+    protected function dispatchTriggeredEvent(MaintenanceSchedule $schedule, WorkOrder $workOrder): void
+    {
+        event('maintenance.triggered', [$schedule, $workOrder]);
+    }
+
+    protected function currentReadingsFromSubject(mixed $subject): array
+    {
+        if ($subject instanceof Vehicle) {
+            return [$subject->odometer, $subject->engine_hours];
+        }
+
+        return [null, null];
+    }
+
+    protected function triggerReasons(object $schedule, mixed $currentOdometer = null, mixed $currentEngHours = null): array
+    {
+        $reasons = [];
+
+        if ($schedule->next_due_date && now()->gte($schedule->next_due_date)) {
+            $reasons[] = 'date due ' . $schedule->next_due_date->toDateString();
+        }
+
+        if ($schedule->next_due_odometer && $currentOdometer !== null && $currentOdometer >= $schedule->next_due_odometer) {
+            $reasons[] = "odometer {$currentOdometer} >= {$schedule->next_due_odometer}";
+        }
+
+        if ($schedule->next_due_engine_hours && $currentEngHours !== null && $currentEngHours >= $schedule->next_due_engine_hours) {
+            $reasons[] = "engine hours {$currentEngHours} >= {$schedule->next_due_engine_hours}";
+        }
+
+        return $reasons;
+    }
+
+    protected function workOrderCode(int $count, \DateTimeInterface $now): string
+    {
+        return 'WO-' . $now->format('Ymd') . '-' . str_pad($count, 4, '0', STR_PAD_LEFT);
+    }
+
+    protected function processedSummary(int $triggered, bool $dryRun): string
+    {
+        return "Processed {$triggered} schedule trigger(s)" . ($dryRun ? ' (dry run — no work orders created)' : '.');
     }
 }

package/server/src/Console/Commands/PurgeUnpurchasedServiceQuotes.php

@@ -32,19 +32,14 @@ class PurgeUnpurchasedServiceQuotes extends Command
     {
         $thresholdDate = now()->subHours(48);
 
-        Schema::disableForeignKeyConstraints();
-        DB::beginTransaction();
+        $this->disableForeignKeyConstraints();
+        $this->beginTransaction();
 
         try {
             // Get service quotes that are expired and have not been purchased
-            $deletedCount = ServiceQuote::where('created_at', '<', $thresholdDate)
-                ->whereNotIn('uuid', function ($query) {
-                    $query->select('service_quote_uuid')->from('purchase_rates')->whereNotNull('service_quote_uuid');
-                })
-                ->withTrashed()
-                ->forceDelete();
+            $deletedCount = $this->purgeServiceQuotes($thresholdDate);
 
-            DB::commit();
+            $this->commit();
 
             if ($deletedCount > 0) {
                 $this->info("Successfully deleted {$deletedCount} unpurchased service quotes.");
@@ -52,15 +47,50 @@ class PurgeUnpurchasedServiceQuotes extends Command
                 $this->info('No unpurchased service quotes found for deletion.');
             }
         } catch (\Exception $e) {
-            DB::rollBack();
-            Schema::enableForeignKeyConstraints();
+            $this->rollBack();
+            $this->enableForeignKeyConstraints();
             $this->error('Error deleting unpurchased service quotes: ' . $e->getMessage());
 
             return Command::FAILURE;
         }
 
-        Schema::enableForeignKeyConstraints();
+        $this->enableForeignKeyConstraints();
 
         return Command::SUCCESS;
     }
+
+    protected function disableForeignKeyConstraints(): void
+    {
+        Schema::disableForeignKeyConstraints();
+    }
+
+    protected function enableForeignKeyConstraints(): void
+    {
+        Schema::enableForeignKeyConstraints();
+    }
+
+    protected function beginTransaction(): void
+    {
+        DB::beginTransaction();
+    }
+
+    protected function commit(): void
+    {
+        DB::commit();
+    }
+
+    protected function rollBack(): void
+    {
+        DB::rollBack();
+    }
+
+    protected function purgeServiceQuotes($thresholdDate): int
+    {
+        return ServiceQuote::where('created_at', '<', $thresholdDate)
+            ->whereNotIn('uuid', function ($query) {
+                $query->select('service_quote_uuid')->from('purchase_rates')->whereNotNull('service_quote_uuid');
+            })
+            ->withTrashed()
+            ->forceDelete();
+    }
 }

package/server/src/Console/Commands/ReplayVehicleLocations.php

@@ -44,7 +44,7 @@ class ReplayVehicleLocations extends Command
         $sleep           = $this->option('sleep') ? (int) $this->option('sleep') : null;
 
         // Validate file exists
-        if (!file_exists($filePath)) {
+        if (!$this->fileExists($filePath)) {
             $this->error("File not found: {$filePath}");
 
             return Command::FAILURE;
@@ -69,32 +69,22 @@ class ReplayVehicleLocations extends Command
             $this->warn('Sleep delays disabled - sending all events immediately');
         }
 
-        // Load and parse JSON data
         $this->info('Loading location data...');
-        $jsonContent    = file_get_contents($filePath);
-        $locationEvents = json_decode($jsonContent, true);
-
-        if (json_last_error() !== JSON_ERROR_NONE) {
-            $this->error('Failed to parse JSON: ' . json_last_error_msg());
+        [$locationEvents, $parseError] = $this->loadLocationEventsFromFile($filePath);
+        if ($parseError) {
+            $this->error($parseError);
 
             return Command::FAILURE;
         }
 
-        if (!is_array($locationEvents) || empty($locationEvents)) {
+        if (empty($locationEvents)) {
             $this->error('Invalid or empty location data');
 
             return Command::FAILURE;
         }
 
-        // Filter by vehicle if specified
-        if ($vehicleFilter) {
-            $locationEvents = array_filter($locationEvents, function ($event) use ($vehicleFilter) {
-                return isset($event['data']['id']) && $event['data']['id'] === $vehicleFilter;
-            });
-            $locationEvents = array_values($locationEvents); // Re-index array
-        }
-
-        $totalEvents = count($locationEvents);
+        $locationEvents = $this->filterEventsForVehicle($locationEvents, $vehicleFilter);
+        $totalEvents    = count($locationEvents);
 
         if ($totalEvents === 0) {
             $this->warn('No events found matching the criteria');
@@ -102,22 +92,19 @@ class ReplayVehicleLocations extends Command
             return Command::SUCCESS;
         }
 
-        // Apply limit if specified
-        if ($limit && $limit < $totalEvents) {
-            $locationEvents = array_slice($locationEvents, 0, $limit);
-            $totalEvents    = $limit;
-        }
+        $locationEvents = $this->applyEventLimit($locationEvents, $limit);
+        $totalEvents    = count($locationEvents);
 
         $this->info("Total events to process: {$totalEvents}");
         $this->newLine();
 
         // Initialize SocketCluster client
-        $socketClusterClient = new SocketClusterService();
+        $socketClusterClient = $this->socketClusterClient();
 
         // Statistics tracking
         $successCount      = 0;
         $errorCount        = 0;
-        $startTime         = microtime(true);
+        $startTime         = $this->currentMicrotime();
         $previousTimestamp = null;
 
         // Process each location event
@@ -128,7 +115,7 @@ class ReplayVehicleLocations extends Command
             $createdAt   = $event['created_at'] ?? null;
 
             // Get vehicle record
-            $vehicle = Vehicle::where('public_id', $vehicleId)->first();
+            $vehicle = $this->vehicleForPublicId($vehicleId);
             if (!$vehicle) {
                 continue;
             }
@@ -136,24 +123,19 @@ class ReplayVehicleLocations extends Command
             // Calculate sleep duration based on timestamp difference
             if (!$skipSleep && $previousTimestamp !== null && $createdAt !== null) {
                 try {
-                    $currentTime   = Carbon::parse($createdAt);
-                    $previousTime  = Carbon::parse($previousTimestamp);
-                    $diffInSeconds = $currentTime->diffInSeconds($previousTime);
-
-                    // Apply speed multiplier
-                    $sleepDuration = $diffInSeconds / $speedMultiplier;
+                    [$diffInSeconds, $sleepDuration] = $this->calculateReplayDelay($previousTimestamp, $createdAt, $speedMultiplier);
 
                     if ($sleep) {
                         $this->info("[{$eventNumber}/{$totalEvents}] Waiting {$sleep}s (real: {$diffInSeconds}s)...");
-                        sleep((int) $sleep);
+                        $this->sleepSeconds((int) $sleep);
                     } elseif ($sleepDuration > 0) {
                         $this->info("[{$eventNumber}/{$totalEvents}] Waiting {$sleepDuration}s (real: {$diffInSeconds}s)...");
-                        sleep((int) $sleepDuration);
+                        $this->sleepSeconds((int) $sleepDuration);
 
                         // Handle fractional seconds
                         $fractional = $sleepDuration - floor($sleepDuration);
                         if ($fractional > 0) {
-                            usleep((int) ($fractional * 1000000));
+                            $this->sleepMicroseconds((int) ($fractional * 1000000));
                         }
                     }
                 } catch (\Exception $e) {
@@ -164,37 +146,22 @@ class ReplayVehicleLocations extends Command
             // Update previous timestamp
             $previousTimestamp = $createdAt;
 
-            // Prepare channel names
-            $channels = ["vehicle.{$vehicleId}", "vehicle.{$vehicle->uuid}"];
+            $channels = $this->channelsForVehicle($vehicleId, $vehicle);
 
             foreach ($channels as $channel) {
                 // Send event via SocketCluster
                 try {
                     $sent = $socketClusterClient->send($channel, $event);
 
-                    $location = $event['data']['location']['coordinates'] ?? ['N/A', 'N/A'];
-                    $speed    = $event['data']['speed'] ?? 'N/A';
-                    $heading  = $event['data']['heading'] ?? 'N/A';
-
-                    $this->line(sprintf(
-                        "[{$eventNumber}/{$totalEvents}] ✓ Sent event %s for vehicle %s | Channel: %s | Coords: [%.6f, %.6f] | Speed: %s | Heading: %s | Time: %s",
-                        $eventId,
-                        $vehicleId,
-                        $channel,
-                        $location[0],
-                        $location[1],
-                        $speed,
-                        $heading,
-                        $createdAt ?? 'N/A'
-                    ));
+                    $this->line($this->formatSentLine($eventNumber, $totalEvents, $eventId, $vehicleId, $channel, $event, $createdAt));
 
                     $successCount++;
-                } catch (\WebSocket\ConnectionException $e) {
-                    $this->error("[{$eventNumber}/{$totalEvents}] ✗ Connection error for event {$eventId}: {$e->getMessage()}");
-                    $errorCount++;
                 } catch (\WebSocket\TimeoutException $e) {
                     $this->error("[{$eventNumber}/{$totalEvents}] ✗ Timeout error for event {$eventId}: {$e->getMessage()}");
                     $errorCount++;
+                } catch (\WebSocket\ConnectionException $e) {
+                    $this->error("[{$eventNumber}/{$totalEvents}] ✗ Connection error for event {$eventId}: {$e->getMessage()}");
+                    $errorCount++;
                 } catch (\Throwable $e) {
                     $this->error("[{$eventNumber}/{$totalEvents}] ✗ Error for event {$eventId}: {$e->getMessage()}");
                     $errorCount++;
@@ -203,7 +170,7 @@ class ReplayVehicleLocations extends Command
         }
 
         // Summary
-        $endTime  = microtime(true);
+        $endTime  = $this->currentMicrotime();
         $duration = round($endTime - $startTime, 2);
 
         $this->newLine();
@@ -222,4 +189,102 @@ class ReplayVehicleLocations extends Command
 
         return $errorCount > 0 ? Command::FAILURE : Command::SUCCESS;
     }
+
+    protected function loadLocationEventsFromFile(string $filePath): array
+    {
+        $locationEvents = json_decode(file_get_contents($filePath), true);
+
+        if (json_last_error() !== JSON_ERROR_NONE) {
+            return [[], 'Failed to parse JSON: ' . json_last_error_msg()];
+        }
+
+        if (!is_array($locationEvents)) {
+            return [[], null];
+        }
+
+        return [$locationEvents, null];
+    }
+
+    protected function fileExists(string $filePath): bool
+    {
+        return file_exists($filePath);
+    }
+
+    protected function socketClusterClient(): mixed
+    {
+        return new SocketClusterService();
+    }
+
+    protected function vehicleForPublicId(string $vehicleId): ?Vehicle
+    {
+        return Vehicle::where('public_id', $vehicleId)->first();
+    }
+
+    protected function sleepSeconds(int $seconds): void
+    {
+        sleep($seconds);
+    }
+
+    protected function sleepMicroseconds(int $microseconds): void
+    {
+        usleep($microseconds);
+    }
+
+    protected function currentMicrotime(): float
+    {
+        return microtime(true);
+    }
+
+    protected function filterEventsForVehicle(array $locationEvents, ?string $vehicleFilter): array
+    {
+        if (!$vehicleFilter) {
+            return array_values($locationEvents);
+        }
+
+        return array_values(array_filter($locationEvents, function ($event) use ($vehicleFilter) {
+            return isset($event['data']['id']) && $event['data']['id'] === $vehicleFilter;
+        }));
+    }
+
+    protected function applyEventLimit(array $locationEvents, ?int $limit): array
+    {
+        if ($limit && $limit < count($locationEvents)) {
+            return array_slice($locationEvents, 0, $limit);
+        }
+
+        return $locationEvents;
+    }
+
+    protected function calculateReplayDelay(string $previousTimestamp, string $createdAt, float $speedMultiplier): array
+    {
+        $currentTime   = Carbon::parse($createdAt);
+        $previousTime  = Carbon::parse($previousTimestamp);
+        $diffInSeconds = $currentTime->diffInSeconds($previousTime);
+
+        return [$diffInSeconds, $diffInSeconds / $speedMultiplier];
+    }
+
+    protected function channelsForVehicle(string $vehicleId, Vehicle $vehicle): array
+    {
+        return ["vehicle.{$vehicleId}", "vehicle.{$vehicle->uuid}"];
+    }
+
+    protected function formatSentLine(int $eventNumber, int $totalEvents, string $eventId, string $vehicleId, string $channel, array $event, ?string $createdAt): string
+    {
+        $location = $event['data']['location']['coordinates'] ?? ['N/A', 'N/A'];
+        $speed    = $event['data']['speed'] ?? 'N/A';
+        $heading  = $event['data']['heading'] ?? 'N/A';
+
+        return sprintf(
+            "[{$eventNumber}/{$totalEvents}] ✓ Sent event %s for vehicle %s | Channel: %s | Coords: [%.6f, %.6f] | Speed: %s | Heading: %s | Time: %s",
+            $eventId,
+            $vehicleId,
+            $channel,
+            $location[0],
+            $location[1],
+            $speed,
+            $heading,
+            $createdAt ?? 'N/A'
+        );
+    }
 }

package/server/src/Console/Commands/SendDriverNotification.php

@@ -51,7 +51,7 @@ class SendDriverNotification extends Command
         }
 
         // Attempt to find the order
-        $order = Order::where('public_id', $orderId)->first();
+        $order = $this->findOrder($orderId);
         if (!$order) {
             $this->error('Order not found!');
 
@@ -88,11 +88,11 @@ class SendDriverNotification extends Command
             // Handle order ping notification which requires distance of pickup point from driver
             if ($event === 'ping') {
                 $destination = $order->payload->getPickupOrFirstWaypoint();
-                $matrix      = Utils::calculateDrivingDistanceAndTime($order->driverAssigned->location, $destination);
-                $order->driverAssigned->notify(new $notificationClass($order, $matrix->distance));
+                $matrix      = $this->calculateDrivingDistanceAndTime($order->driverAssigned->location, $destination);
+                $this->notifyDriver($order->driverAssigned, $notificationClass, $order, $matrix->distance);
             } else {
                 // Trigger notification
-                $order->driverAssigned->notify(new $notificationClass($order));
+                $this->notifyDriver($order->driverAssigned, $notificationClass, $order);
             }
         } catch (\Exception $e) {
             $this->error($e->getMessage());
@@ -104,4 +104,25 @@ class SendDriverNotification extends Command
 
         return 0;
     }
+
+    protected function findOrder(string $orderId): ?Order
+    {
+        return Order::where('public_id', $orderId)->first();
+    }
+
+    protected function calculateDrivingDistanceAndTime(mixed $origin, mixed $destination): object
+    {
+        return Utils::calculateDrivingDistanceAndTime($origin, $destination);
+    }
+
+    protected function notifyDriver($driver, string $notificationClass, Order $order, mixed $distance = null): void
+    {
+        if ($distance !== null) {
+            $driver->notify(new $notificationClass($order, $distance));
+
+            return;
+        }
+
+        $driver->notify(new $notificationClass($order));
+    }
 }

package/server/src/Console/Commands/SendMaintenanceReminders.php

@@ -6,6 +6,7 @@ use Fleetbase\FleetOps\Mail\MaintenanceScheduleReminder;
 use Fleetbase\FleetOps\Models\MaintenanceSchedule;
 use Illuminate\Console\Command;
 use Illuminate\Support\Carbon;
+use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Mail;
 
@@ -54,15 +55,7 @@ class SendMaintenanceReminders extends Command
         //   - a non-null next_due_date (reminders are date-based only)
         //   - a non-null reminder_offsets JSON array
         //   - a default_assignee configured
-        $schedules = MaintenanceSchedule::on($conn)
-            ->withoutGlobalScopes()
-            ->where('status', 'active')
-            ->whereNotNull('next_due_date')
-            ->whereNotNull('reminder_offsets')
-            ->whereNotNull('default_assignee_uuid')
-            ->whereNull('deleted_at')
-            ->with(['subject', 'defaultAssignee'])
-            ->get();
+        $schedules = $this->schedules($conn);
 
         foreach ($schedules as $schedule) {
             $offsets     = $schedule->reminder_offsets;
@@ -95,12 +88,7 @@ class SendMaintenanceReminders extends Command
                 }
 
                 // Check whether we already sent this reminder for this cycle
-                $alreadySent = DB::connection($conn)
-                    ->table('maintenance_schedule_reminders')
-                    ->where('schedule_uuid', $schedule->uuid)
-                    ->where('offset_days', $offsetDays)
-                    ->where('due_date_snapshot', $dueDateSnapshot)
-                    ->exists();
+                $alreadySent = $this->reminderAlreadySent($conn, $schedule, $offsetDays, $dueDateSnapshot);
 
                 if ($alreadySent) {
                     continue;
@@ -109,14 +97,8 @@ class SendMaintenanceReminders extends Command
                 $this->line("Sending reminder: schedule {$schedule->public_id} ({$schedule->name}) — {$offsetDays} days before {$dueDateSnapshot} → {$email}");
 
                 if (!$dryRun) {
-                    Mail::to($email)->send(new MaintenanceScheduleReminder($schedule, $offsetDays));
-
-                    DB::connection($conn)->table('maintenance_schedule_reminders')->insert([
-                        'schedule_uuid'     => $schedule->uuid,
-                        'offset_days'       => $offsetDays,
-                        'due_date_snapshot' => $dueDateSnapshot,
-                        'sent_at'           => Carbon::now(),
-                    ]);
+                    $this->sendReminder($email, $schedule, $offsetDays);
+                    $this->recordReminder($conn, $schedule, $offsetDays, $dueDateSnapshot);
                 }
 
                 $sent++;
@@ -125,4 +107,42 @@ class SendMaintenanceReminders extends Command
 
         $this->info("Sent {$sent} reminder(s)" . ($dryRun ? ' (dry run — no emails sent)' : '.'));
     }
+
+    protected function schedules(string $conn): Collection
+    {
+        return MaintenanceSchedule::on($conn)
+            ->withoutGlobalScopes()
+            ->where('status', 'active')
+            ->whereNotNull('next_due_date')
+            ->whereNotNull('reminder_offsets')
+            ->whereNotNull('default_assignee_uuid')
+            ->whereNull('deleted_at')
+            ->with(['subject', 'defaultAssignee'])
+            ->get();
+    }
+
+    protected function reminderAlreadySent(string $conn, MaintenanceSchedule $schedule, int $offsetDays, string $dueDateSnapshot): bool
+    {
+        return DB::connection($conn)
+            ->table('maintenance_schedule_reminders')
+            ->where('schedule_uuid', $schedule->uuid)
+            ->where('offset_days', $offsetDays)
+            ->where('due_date_snapshot', $dueDateSnapshot)
+            ->exists();
+    }
+
+    protected function sendReminder(string $email, MaintenanceSchedule $schedule, int $offsetDays): void
+    {
+        Mail::to($email)->send(new MaintenanceScheduleReminder($schedule, $offsetDays));
+    }
+
+    protected function recordReminder(string $conn, MaintenanceSchedule $schedule, int $offsetDays, string $dueDateSnapshot): void
+    {
+        DB::connection($conn)->table('maintenance_schedule_reminders')->insert([
+            'schedule_uuid'     => $schedule->uuid,
+            'offset_days'       => $offsetDays,
+            'due_date_snapshot' => $dueDateSnapshot,
+            'sent_at'           => Carbon::now(),
+        ]);
+    }
 }