@fleetbase/fleetops-engine 0.6.48 → 0.6.50

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

@@ -0,0 +1,279 @@
+<?php
+
+namespace Fleetbase\FleetOps\Console\Commands;
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Position;
+use Fleetbase\FleetOps\Notifications\LateDeparture;
+use Fleetbase\FleetOps\Notifications\ProlongedStoppage;
+use Fleetbase\FleetOps\Notifications\RouteDeviation;
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Fleetbase\Models\Setting;
+use Fleetbase\Support\NotificationRegistry;
+use Illuminate\Console\Command;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\Cache;
+
+class ProcessOperationalAlerts extends Command
+{
+    protected $signature = 'fleetops:process-operational-alerts
+        {--days=2 : Only include orders created in the last N days}
+        {--chunk=250 : How many orders to process per chunk}
+        {--no-lock : Skip process locking}
+        {--dry : Dry run without updating notification markers}';
+
+    protected $description = 'Evaluate FleetOps operational alerts for late departures, route deviations, and prolonged stoppages.';
+
+    public function handle(): int
+    {
+        $days     = max(1, (int) $this->option('days'));
+        $perChunk = max(50, (int) $this->option('chunk'));
+        $dryRun   = (bool) $this->option('dry');
+        $useLock  = !$this->option('no-lock');
+        $lock     = null;
+
+        if ($useLock) {
+            $lock = Cache::lock('fleetops:process-operational-alerts', 600);
+            if (!$lock->get()) {
+                $this->warn('Another operational alert run appears to be in progress.');
+
+                return self::SUCCESS;
+            }
+        }
+
+        try {
+            $cutoff = Carbon::now()->subDays($days);
+            $query  = $this->ordersQuery($cutoff);
+            $total  = (clone $query)->count('id');
+
+            if ($total === 0) {
+                $this->info('No qualifying orders found.');
+
+                return self::SUCCESS;
+            }
+
+            $triggered = 0;
+
+            $query->orderBy('id')->chunkById($perChunk, function ($orders) use ($dryRun, &$triggered) {
+                $orders->loadMissing(['driverAssigned', 'vehicleAssigned', 'route']);
+
+                foreach ($orders as $order) {
+                    session(['company' => $order->company_uuid]);
+                    $settings = $this->alertSettings();
+
+                    if ($this->processLateDeparture($order, $settings, $dryRun)) {
+                        $triggered++;
+                    }
+
+                    if ($this->processRouteDeviation($order, $settings, $dryRun)) {
+                        $triggered++;
+                    }
+
+                    if ($this->processProlongedStoppage($order, $settings, $dryRun)) {
+                        $triggered++;
+                    }
+                }
+            });
+
+            $this->info(($dryRun ? '[Dry Run] ' : '') . "Operational alerts triggered: {$triggered}");
+
+            return self::SUCCESS;
+        } finally {
+            if ($lock) {
+                $lock->release();
+            }
+        }
+    }
+
+    protected function ordersQuery(Carbon $cutoff)
+    {
+        return Order::query()
+            ->withoutGlobalScopes()
+            ->whereNotIn('status', ['completed', 'canceled'])
+            ->whereNull('deleted_at')
+            ->whereNotNull('company_uuid')
+            ->where('created_at', '>=', $cutoff);
+    }
+
+    protected function processLateDeparture(Order $order, array $settings, bool $dryRun): bool
+    {
+        if (!data_get($settings, 'late_departures.enabled')) {
+            return false;
+        }
+
+        if (!$order->scheduled_at || $order->started_at || $order->started) {
+            return false;
+        }
+
+        $graceMinutes = (int) data_get($settings, 'late_departures.grace_period_minutes', 15);
+        if (Carbon::parse($order->scheduled_at)->addMinutes($graceMinutes)->isFuture()) {
+            return false;
+        }
+
+        return $this->notifyOnce($order, 'late_departure', LateDeparture::class, [
+            'scheduled_at'         => $order->scheduled_at,
+            'grace_period_minutes' => $graceMinutes,
+        ], $dryRun);
+    }
+
+    protected function processRouteDeviation(Order $order, array $settings, bool $dryRun): bool
+    {
+        if (!data_get($settings, 'route_deviations.enabled')) {
+            return false;
+        }
+
+        $latestPosition = $this->latestPositionForOrder($order);
+        if (!$latestPosition?->coordinates) {
+            return false;
+        }
+
+        $routePoints = $this->routePoints($order);
+        if (count($routePoints) < 2) {
+            return false;
+        }
+
+        $thresholdMeters = (int) data_get($settings, 'route_deviations.distance_threshold_meters', 500);
+        $distanceMeters  = $this->minimumDistanceToRoute($latestPosition->coordinates, $routePoints);
+
+        if ($distanceMeters <= $thresholdMeters) {
+            return false;
+        }
+
+        return $this->notifyOnce($order, 'route_deviation', RouteDeviation::class, [
+            'distance_meters'           => round($distanceMeters, 2),
+            'distance_threshold_meters' => $thresholdMeters,
+            'position_id'               => $latestPosition->uuid,
+        ], $dryRun);
+    }
+
+    protected function processProlongedStoppage(Order $order, array $settings, bool $dryRun): bool
+    {
+        if (!data_get($settings, 'prolonged_stoppages.enabled')) {
+            return false;
+        }
+
+        if (!$order->started_at && !$order->started) {
+            return false;
+        }
+
+        $latestPosition = $this->latestPositionForOrder($order);
+        if (!$latestPosition || ((float) $latestPosition->speed) > 1) {
+            return false;
+        }
+
+        $thresholdMinutes = (int) data_get($settings, 'prolonged_stoppages.duration_threshold_minutes', 30);
+        if (Carbon::parse($latestPosition->created_at)->addMinutes($thresholdMinutes)->isFuture()) {
+            return false;
+        }
+
+        return $this->notifyOnce($order, 'prolonged_stoppage', ProlongedStoppage::class, [
+            'duration_threshold_minutes' => $thresholdMinutes,
+            'position_id'                => $latestPosition->uuid,
+            'stopped_since'              => $latestPosition->created_at,
+        ], $dryRun);
+    }
+
+    protected function notifyOnce(Order $order, string $key, string $notificationClass, array $context, bool $dryRun): bool
+    {
+        $metaKey = "operational_alerts.{$key}.notified_at";
+        if ($order->getMeta($metaKey)) {
+            return false;
+        }
+
+        NotificationRegistry::notify($notificationClass, $order, $context);
+
+        if (!$dryRun) {
+            $order->setMeta("operational_alerts.{$key}", [
+                'notified_at' => Carbon::now()->toDateTimeString(),
+                'context'     => $context,
+            ]);
+            $order->saveQuietly();
+        }
+
+        return true;
+    }
+
+    protected function latestPositionForOrder(Order $order): ?Position
+    {
+        return Position::where('company_uuid', $order->company_uuid)
+            ->where('order_uuid', $order->uuid)
+            ->latest()
+            ->first();
+    }
+
+    protected function routePoints(Order $order): array
+    {
+        $details = data_get($order, 'route.details', []);
+
+        return $this->collectPoints($details);
+    }
+
+    protected function collectPoints(mixed $value): array
+    {
+        if (!is_array($value)) {
+            return [];
+        }
+
+        if ($point = $this->pointFromPair($value)) {
+            return [$point];
+        }
+
+        $points = [];
+        foreach ($value as $item) {
+            foreach ($this->collectPoints($item) as $point) {
+                $points[] = $point;
+            }
+        }
+
+        return $points;
+    }
+
+    protected function pointFromPair(array $value): ?Point
+    {
+        if (count($value) !== 2 || !is_numeric($value[0]) || !is_numeric($value[1])) {
+            return null;
+        }
+
+        $first  = (float) $value[0];
+        $second = (float) $value[1];
+
+        if (abs($first) <= 90 && abs($second) <= 180) {
+            return new Point($first, $second);
+        }
+
+        if (abs($first) <= 180 && abs($second) <= 90) {
+            return new Point($second, $first);
+        }
+
+        return null;
+    }
+
+    protected function minimumDistanceToRoute(Point $position, array $routePoints): float
+    {
+        return collect($routePoints)
+            ->map(fn (Point $point) => Utils::vincentyGreatCircleDistance($position, $point))
+            ->min() ?? 0;
+    }
+
+    protected function alertSettings(): array
+    {
+        $settings = Setting::lookupCompany('tracking', []);
+        $alerts   = data_get($settings, 'alerts', []);
+
+        return [
+            'late_departures' => [
+                'enabled'              => (bool) data_get($alerts, 'late_departures.enabled', true),
+                'grace_period_minutes' => (int) data_get($alerts, 'late_departures.grace_period_minutes', 15),
+            ],
+            'route_deviations' => [
+                'enabled'                   => (bool) data_get($alerts, 'route_deviations.enabled', true),
+                'distance_threshold_meters' => (int) data_get($alerts, 'route_deviations.distance_threshold_meters', 500),
+            ],
+            'prolonged_stoppages' => [
+                'enabled'                    => (bool) data_get($alerts, 'prolonged_stoppages.enabled', true),
+                'duration_threshold_minutes' => (int) data_get($alerts, 'prolonged_stoppages.duration_threshold_minutes', 30),
+            ],
+        ];
+    }
+}

package/server/src/Exceptions/CustomerUserConflictException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Fleetbase\FleetOps\Exceptions;
+
+use Fleetbase\Models\User;
+
+class CustomerUserConflictException extends UserAlreadyExistsException
+{
+    public function __construct(string $message = '', ?User $user = null, int $code = 0, ?\Throwable $previous = null)
+    {
+        parent::__construct($message, $user, $code, $previous);
+    }
+}

package/server/src/Http/Controllers/Api/v1/ContactController.php

@@ -39,6 +39,10 @@ class ContactController extends Controller
         }
 
         try {
+            $contactCandidate               = new Contact($input);
+            $contactCandidate->company_uuid = session('company');
+            $contactCandidate->assertCustomerIdentityIsAvailable();
+
             // create the contact
             $contact = Contact::updateOrCreate(
                 [
@@ -106,8 +110,19 @@ class ContactController extends Controller
             }
         }
 
-        // update the contact
-        $contact->update($input);
+        try {
+            // update the contact
+            $contactCandidate = $contact->replicate();
+            $contactCandidate->forceFill($contact->getAttributes());
+            $contactCandidate->exists = $contact->exists;
+            $contactCandidate->forceFill($input);
+            $contactCandidate->assertCustomerIdentityIsAvailable();
+
+            $contact->update($input);
+        } catch (\Exception $e) {
+            return response()->apiError($e->getMessage());
+        }
+
         $contact->flushAttributesCache();
 
         // response the contact resource