@fleetbase/fleetops-engine 0.6.43 → 0.6.45

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

@@ -41,10 +41,19 @@ class PurchaseRateController extends Controller
 
         // order assignment
         if ($request->has('order')) {
-            $input['order_uuid'] = Utils::getUuid('orders', [
+            $orderUuid = Utils::getUuid('orders', [
                 'public_id'    => $request->input('order'),
                 'company_uuid' => session('company'),
             ]);
+
+            $order = Order::where('uuid', $orderUuid)->first();
+
+            if ($order instanceof Order) {
+                $input['payload_uuid']   = $order->payload_uuid;
+                $input['customer_uuid']  = $order->customer_uuid;
+                $input['customer_type']  = $order->customer_type;
+                $input['company_uuid']   = $order->company_uuid ?? $input['company_uuid'];
+            }
         } elseif ($createOrder) {
             // create order from service quote
             $serviceQuote = ServiceQuote::where('uuid', $input['service_quote_uuid'])->orWhere('public_id', $request->input('service_quote'))->first();
@@ -70,9 +79,8 @@ class PurchaseRateController extends Controller
         // create the purchaseRate
         $purchaseRate = PurchaseRate::create($input);
 
-        // set purchase rate to order
         if ($order instanceof Order) {
-            $order->update(['purchase_rate_uuid' => $purchaseRate->uuid]);
+            $order->attachPurchaseRate($purchaseRate);
         }
 
         // response the driver resource

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

@@ -24,7 +24,7 @@ class ServiceAreaController extends Controller
     public function create(CreateServiceAreaRequest $request)
     {
         // get request input
-        $input = $request->only(['name', 'type', 'status']);
+        $input = $request->only(['name', 'type', 'status', 'country', 'color', 'stroke_color', 'trigger_on_entry', 'trigger_on_exit', 'dwell_threshold_minutes', 'speed_limit_kmh']);
 
         // get radius for creating service area border - default to 500 meters
         $radius = (int) $request->input('radius', 500);
@@ -98,7 +98,7 @@ class ServiceAreaController extends Controller
         }
 
         // get request input
-        $input = $request->only(['name', 'type', 'status']);
+        $input = $request->only(['name', 'type', 'status', 'country', 'color', 'stroke_color', 'trigger_on_entry', 'trigger_on_exit', 'dwell_threshold_minutes', 'speed_limit_kmh']);
 
         // get radius for creating service area border - default to 500 meters
         $radius = $request->input('radius', 500);

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

@@ -98,6 +98,7 @@ class ServiceQuoteController extends Controller
                     'amount'            => $subTotal,
                     'currency'          => $serviceRate->currency,
                 ]);
+                $quote->setRelation('serviceRate', $serviceRate);
 
                 $items = $lines->map(function ($line) use ($quote) {
                     return ServiceQuoteItem::create([
@@ -143,6 +144,7 @@ class ServiceQuoteController extends Controller
                 'amount'            => $subTotal,
                 'currency'          => $serviceRate->currency,
             ]);
+            $quote->setRelation('serviceRate', $serviceRate);
 
             $items = $lines->map(function ($line) use ($quote) {
                 return ServiceQuoteItem::create([
@@ -288,6 +290,7 @@ class ServiceQuoteController extends Controller
                     'amount'            => $subTotal,
                     'currency'          => $serviceRate->currency,
                 ]);
+                $quote->setRelation('serviceRate', $serviceRate);
 
                 // set preliminary data to meta
                 $quote->updateMeta('preliminary_data', $preliminaryData);
@@ -335,6 +338,7 @@ class ServiceQuoteController extends Controller
                 'amount'            => $subTotal,
                 'currency'          => $serviceRate->currency,
             ]);
+            $quote->setRelation('serviceRate', $serviceRate);
 
             // set preliminary data to meta
             $quote->updateMeta('preliminary_data', $preliminaryData);

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

@@ -30,6 +30,8 @@ class ServiceRateController extends Controller
             'rate_calculation_method',
             'currency',
             'base_fee',
+            'max_distance_unit',
+            'max_distance',
             'per_meter_unit',
             'per_meter_flat_rate_fee',
             'meter_fees',
@@ -119,7 +121,10 @@ class ServiceRateController extends Controller
             'rate_calculation_method',
             'currency',
             'base_fee',
-            'per_km_flat_rate_fee',
+            'max_distance_unit',
+            'max_distance',
+            'per_meter_unit',
+            'per_meter_flat_rate_fee',
             'meter_fees',
             'meter_fees.*.distance',
             'meter_fees.*.fee',

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

@@ -2,17 +2,23 @@
 
 namespace Fleetbase\FleetOps\Http\Controllers\Api\v1;
 
+use Fleetbase\FleetOps\Events\GeofenceEntered;
+use Fleetbase\FleetOps\Events\GeofenceExited;
 use Fleetbase\FleetOps\Events\VehicleLocationChanged;
 use Fleetbase\FleetOps\Http\Requests\CreateVehicleRequest;
 use Fleetbase\FleetOps\Http\Requests\UpdateVehicleRequest;
 use Fleetbase\FleetOps\Http\Resources\v1\DeletedResource;
 use Fleetbase\FleetOps\Http\Resources\v1\Vehicle as VehicleResource;
+use Fleetbase\FleetOps\Jobs\CheckGeofenceDwell;
 use Fleetbase\FleetOps\Models\Driver;
 use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Support\GeofenceIntersectionService;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\Http\Controllers\Controller;
 use Fleetbase\LaravelMysqlSpatial\Types\Point;
 use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\DB;
 
 class VehicleController extends Controller
 {
@@ -276,6 +282,88 @@ class VehicleController extends Controller
 
         broadcast(new VehicleLocationChanged($vehicle));
 
+        try {
+            $newLocation     = new Point($latitude, $longitude);
+            $geofenceService = app(GeofenceIntersectionService::class);
+            $this->processVehicleGeofenceCrossings($vehicle, $newLocation, $geofenceService->detectVehicleCrossings($vehicle, $newLocation));
+        } catch (\Throwable $geofenceException) {
+            if (app()->bound('sentry')) {
+                app('sentry')->captureException($geofenceException);
+            }
+        }
+
         return new VehicleResource($vehicle);
     }
+
+    private function processVehicleGeofenceCrossings(Vehicle $vehicle, Point $newLocation, array $crossings): void
+    {
+        foreach ($crossings as $crossing) {
+            $geofence     = $crossing['geofence'];
+            $geofenceType = $crossing['geofence_type'];
+
+            if ($crossing['type'] === 'entered') {
+                if (!$geofence->trigger_on_entry && empty($geofence->dwell_threshold_minutes)) {
+                    continue;
+                }
+
+                DB::table('vehicle_geofence_states')->upsert(
+                    [
+                        'vehicle_uuid'  => $vehicle->uuid,
+                        'geofence_uuid' => $geofence->uuid,
+                        'geofence_type' => $geofenceType,
+                        'is_inside'     => true,
+                        'entered_at'    => now(),
+                        'exited_at'     => null,
+                        'dwell_job_id'  => null,
+                        'created_at'    => now(),
+                        'updated_at'    => now(),
+                    ],
+                    ['vehicle_uuid', 'geofence_uuid'],
+                    ['is_inside', 'entered_at', 'exited_at', 'dwell_job_id', 'updated_at']
+                );
+
+                if ($geofence->trigger_on_entry) {
+                    event(new GeofenceEntered($vehicle, $geofence, $geofenceType, $newLocation));
+                }
+
+                if ($geofence->dwell_threshold_minutes > 0) {
+                    $dwellJob = CheckGeofenceDwell::dispatch(
+                        $vehicle->uuid,
+                        $geofence->uuid,
+                        $geofenceType,
+                        'vehicle'
+                    )->delay(now()->addMinutes($geofence->dwell_threshold_minutes));
+
+                    DB::table('vehicle_geofence_states')
+                        ->where('vehicle_uuid', $vehicle->uuid)
+                        ->where('geofence_uuid', $geofence->uuid)
+                        ->update(['dwell_job_id' => (string) $dwellJob]);
+                }
+            } elseif ($crossing['type'] === 'exited') {
+                $state = DB::table('vehicle_geofence_states')
+                    ->where('vehicle_uuid', $vehicle->uuid)
+                    ->where('geofence_uuid', $geofence->uuid)
+                    ->first();
+
+                $dwellMinutes = null;
+                if ($state && $state->entered_at) {
+                    $dwellMinutes = (int) Carbon::parse($state->entered_at)->diffInMinutes(now());
+                }
+
+                DB::table('vehicle_geofence_states')
+                    ->where('vehicle_uuid', $vehicle->uuid)
+                    ->where('geofence_uuid', $geofence->uuid)
+                    ->update([
+                        'is_inside'    => false,
+                        'exited_at'    => now(),
+                        'dwell_job_id' => null,
+                        'updated_at'   => now(),
+                    ]);
+
+                if ($geofence->trigger_on_exit) {
+                    event(new GeofenceExited($vehicle, $geofence, $geofenceType, $newLocation, $dwellMinutes));
+                }
+            }
+        }
+    }
 }

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

@@ -24,7 +24,7 @@ class ZoneController extends Controller
     public function create(CreateZoneRequest $request)
     {
         // get request input
-        $input = $request->only(['name', 'border', 'status', 'description', 'color', 'stroke_color']);
+        $input = $request->only(['name', 'border', 'status', 'description', 'color', 'stroke_color', 'trigger_on_entry', 'trigger_on_exit', 'dwell_threshold_minutes', 'speed_limit_kmh']);
 
         // get radius for creating zone border - default to 500 meters
         $radius = $request->input('radius', 500);
@@ -97,7 +97,7 @@ class ZoneController extends Controller
         }
 
         // get request input
-        $input = $request->only(['name', 'border', 'status', 'description', 'color', 'stroke_color']);
+        $input = $request->only(['name', 'border', 'status', 'description', 'color', 'stroke_color', 'trigger_on_entry', 'trigger_on_exit', 'dwell_threshold_minutes', 'speed_limit_kmh']);
 
         // get radius for creating zone border - default to 500 meters
         $radius = $request->input('radius', 500);

package/server/src/Http/Controllers/Internal/v1/GeofenceController.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1;
+
+class GeofenceController extends \Fleetbase\FleetOps\Http\Controllers\Api\v1\GeofenceController
+{
+}

package/server/src/Http/Requests/CreateServiceAreaRequest.php

@@ -46,10 +46,14 @@ class CreateServiceAreaRequest extends FleetbaseRequest
 
                 return false;
             })],
-            'parent'    => ['nullable', 'exists:service_areas,public_id'],
-            'location'  => ['nullable', new ResolvablePoint()],
-            'latitude'  => ['nullable', 'required_with:longitude'],
-            'longitude' => ['nullable', 'required_with:latitude'],
+            'parent'                  => ['nullable', 'exists:service_areas,public_id'],
+            'location'                => ['nullable', new ResolvablePoint()],
+            'latitude'                => ['nullable', 'required_with:longitude'],
+            'longitude'               => ['nullable', 'required_with:latitude'],
+            'trigger_on_entry'        => ['nullable', 'boolean'],
+            'trigger_on_exit'         => ['nullable', 'boolean'],
+            'dwell_threshold_minutes' => ['nullable', 'integer', 'min:1', 'max:10080'],
+            'speed_limit_kmh'         => ['nullable', 'integer', 'min:1', 'max:1000'],
         ];
     }
 }

package/server/src/Http/Requests/CreateServiceRateRequest.php

@@ -31,10 +31,10 @@ class CreateServiceRateRequest extends FleetbaseRequest
             'service_type'                  => [Rule::requiredIf($this->isMethod('POST')), 'string'],
             'service_area'                  => [Rule::exists('service_areas', 'public_id')->whereNull('deleted_at')],
             'zone'                          => [Rule::exists('zones', 'public_id')->whereNull('deleted_at')],
-            'rate_calculation_method'       => [Rule::requiredIf($this->isMethod('POST')), 'string', 'in:fixed_meter,fixed_rate,per_meter,per_drop,algo'],
+            'rate_calculation_method'       => [Rule::requiredIf($this->isMethod('POST')), 'string', 'in:fixed_meter,fixed_rate,per_meter,per_drop,algo,parcel'],
             'currency'                      => ['required', 'size:3'],
             'base_fee'                      => ['numeric'],
-            'per_meter_unit'                => ['required_if:rate_calculation_method,per_meter', 'string', 'in:km,m'],
+            'per_meter_unit'                => ['required_if:rate_calculation_method,per_meter', 'string', 'in:km,m,ft,yd,mi'],
             'per_meter_flat_rate_fee'       => ['required_if:rate_calculation_method,per_meter', 'numeric'],
             'meter_fees'                    => [Rule::requiredIf(function () {
                 return in_array($this->input('rate_calculation_method'), ['fixed_meter', 'fixed_rate']);

package/server/src/Http/Requests/CreateZoneRequest.php

@@ -45,10 +45,14 @@ class CreateZoneRequest extends FleetbaseRequest
 
                 return false;
             })],
-            'location'     => ['nullable', new ResolvablePoint()],
-            'latitude'     => ['nullable', 'required_with:longitude'],
-            'longitude'    => ['nullable', 'required_with:latitude'],
-            'status'       => ['nullable', 'in:active,inactive'],
+            'location'                => ['nullable', new ResolvablePoint()],
+            'latitude'                => ['nullable', 'required_with:longitude'],
+            'longitude'               => ['nullable', 'required_with:latitude'],
+            'status'                  => ['nullable', 'in:active,inactive'],
+            'trigger_on_entry'        => ['nullable', 'boolean'],
+            'trigger_on_exit'         => ['nullable', 'boolean'],
+            'dwell_threshold_minutes' => ['nullable', 'integer', 'min:1', 'max:10080'],
+            'speed_limit_kmh'         => ['nullable', 'integer', 'min:1', 'max:1000'],
         ];
     }
 }

package/server/src/Http/Resources/v1/Order.php

@@ -45,7 +45,6 @@ class Order extends FleetbaseResource
             'tracking_number_uuid' => $this->when($isInternal, $this->tracking_number_uuid),
             'driver_assigned_uuid' => $this->when($isInternal, $this->driver_assigned_uuid),
             'vehicle_assigned_uuid'=> $this->when($isInternal, $this->vehicle_assigned_uuid),
-            'service_quote_uuid'   => $this->when($isInternal, $this->service_quote_uuid),
             'has_driver_assigned'  => $this->when($isInternal, $this->has_driver_assigned),
             'is_scheduled'         => $this->when($isInternal, $this->is_scheduled),
             'order_config_uuid'    => $this->when($isInternal, $this->order_config_uuid),

package/server/src/Http/Resources/v1/ServiceQuote.php

@@ -23,8 +23,8 @@ class ServiceQuote extends FleetbaseResource
             'public_id'         => $this->when(Http::isInternalRequest(), $this->public_id),
             'service_rate_uuid' => $this->when(Http::isInternalRequest(), $this->service_rate_uuid),
             'payload_uuid'      => $this->when(Http::isInternalRequest(), $this->payload_uuid),
-            'service_rate_name' => data_get($this, 'serviceRate.name'),
-            'service_name'      => data_get($this, 'serviceRate.name'),
+            'service_rate_name' => data_get($this, 'serviceRate.service_name'),
+            'service_name'      => data_get($this, 'serviceRate.service_name'),
             'service_rate'      => $this->when(Http::isPublicRequest(), data_get($this, 'serviceRate.public_id')),
             'facilitator'       => $this->when(Http::isPublicRequest(), data_get($this, 'integratedVendor.public_id')),
             'items'             => ServiceQuoteItem::collection($this->items),

package/server/src/Jobs/CheckGeofenceDwell.php

@@ -0,0 +1,139 @@
+<?php
+
+namespace Fleetbase\FleetOps\Jobs;
+
+use Fleetbase\FleetOps\Events\GeofenceDwelled;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\ServiceArea;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Models\Zone;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+
+/**
+ * CheckGeofenceDwell.
+ *
+ * A delayed queue job dispatched when a driver enters a geofence that has
+ * a dwell_threshold_minutes configured. The job is delayed by that number
+ * of minutes. When it runs, it checks whether the driver is still inside
+ * the geofence. If so, it fires the GeofenceDwelled event.
+ *
+ * If the driver exits before the job runs, the dwell_job_id in the state
+ * table is cleared, but the job still runs and exits silently because the
+ * state record will show is_inside = false.
+ *
+ * This job runs on the dedicated 'geofence' queue and has tries = 1 because
+ * dwell checks should not be retried — a failed check is simply missed.
+ */
+class CheckGeofenceDwell implements ShouldQueue
+{
+    use Dispatchable;
+    use InteractsWithQueue;
+    use Queueable;
+    use SerializesModels;
+
+    /**
+     * The number of times the job may be attempted.
+     * Dwell checks are fire-and-forget; retrying would produce false events.
+     */
+    public int $tries = 1;
+
+    /**
+     * The number of seconds the job can run before timing out.
+     */
+    public int $timeout = 30;
+
+    /**
+     * The UUID of the driver to check.
+     */
+    protected string $driverUuid;
+
+    /**
+     * The UUID of the geofence to check.
+     */
+    protected string $geofenceUuid;
+
+    /**
+     * The type of geofence: 'zone' or 'service_area'.
+     */
+    protected string $geofenceType;
+
+    /**
+     * The subject type for the dwell check: 'driver' or 'vehicle'.
+     */
+    protected string $subjectType;
+
+    /**
+     * Create a new CheckGeofenceDwell job.
+     *
+     * @param string $geofenceType 'zone' | 'service_area'
+     */
+    public function __construct(string $subjectUuid, string $geofenceUuid, string $geofenceType, string $subjectType = 'driver')
+    {
+        $this->driverUuid   = $subjectUuid;
+        $this->geofenceUuid = $geofenceUuid;
+        $this->geofenceType = $geofenceType;
+        $this->subjectType  = $subjectType;
+        $this->onQueue('geofence');
+    }
+
+    /**
+     * Execute the job.
+     */
+    public function handle(): void
+    {
+        // Check if the driver is still inside the geofence
+        $stateTable    = $this->subjectType === 'vehicle' ? 'vehicle_geofence_states' : 'driver_geofence_states';
+        $subjectColumn = $this->subjectType === 'vehicle' ? 'vehicle_uuid' : 'driver_uuid';
+
+        $state = DB::table($stateTable)
+            ->where($subjectColumn, $this->driverUuid)
+            ->where('geofence_uuid', $this->geofenceUuid)
+            ->where('is_inside', true)
+            ->first();
+
+        if (!$state) {
+            // Driver has already exited; dwell event should not fire
+            return;
+        }
+
+        // Load the driver
+        $subject = $this->subjectType === 'vehicle'
+            ? Vehicle::where('uuid', $this->driverUuid)->withoutGlobalScopes()->first()
+            : Driver::where('uuid', $this->driverUuid)->withoutGlobalScopes()->first();
+
+        if (!$subject) {
+            Log::warning('CheckGeofenceDwell: Subject not found', [
+                'subject_uuid' => $this->driverUuid,
+                'subject_type' => $this->subjectType,
+            ]);
+
+            return;
+        }
+
+        // Load the geofence model
+        $geofence = $this->geofenceType === 'service_area'
+            ? ServiceArea::where('uuid', $this->geofenceUuid)->first()
+            : Zone::where('uuid', $this->geofenceUuid)->first();
+
+        if (!$geofence) {
+            Log::warning('CheckGeofenceDwell: Geofence not found', [
+                'geofence_uuid' => $this->geofenceUuid,
+                'geofence_type' => $this->geofenceType,
+            ]);
+
+            return;
+        }
+
+        // Parse the entry timestamp
+        $enteredAt = \Carbon\Carbon::parse($state->entered_at);
+
+        // Fire the dwell event
+        event(new GeofenceDwelled($subject, $geofence, $this->geofenceType, $enteredAt));
+    }
+}

package/server/src/Listeners/HandleGeofenceDwelled.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Fleetbase\FleetOps\Listeners;
+
+use Fleetbase\FleetOps\Events\GeofenceDwelled;
+use Fleetbase\FleetOps\Models\GeofenceEventLog;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Support\Str;
+
+/**
+ * HandleGeofenceDwelled.
+ *
+ * Handles the business logic triggered when a driver has dwelled inside
+ * a geofence for the configured threshold duration:
+ *   1. Writes a record to the geofence_events_log table with the dwell duration.
+ */
+class HandleGeofenceDwelled implements ShouldQueue
+{
+    use InteractsWithQueue;
+
+    /**
+     * The number of times the job may be attempted.
+     */
+    public int $tries = 3;
+
+    /**
+     * Handle the event.
+     */
+    public function handle(GeofenceDwelled $event): void
+    {
+        $driver  = $event->driver;
+        $vehicle = $event->vehicle;
+        $order   = $driver?->getCurrentOrder();
+        $subject = $event->subjectType === 'vehicle' ? $vehicle : $driver;
+
+        GeofenceEventLog::create([
+            'uuid'                   => Str::uuid()->toString(),
+            'company_uuid'           => $event->getCompanyUuid(),
+            'driver_uuid'            => $driver?->uuid,
+            'vehicle_uuid'           => $vehicle?->uuid,
+            'order_uuid'             => $order?->uuid,
+            'subject_uuid'           => $subject?->uuid,
+            'subject_type'           => $event->subjectType,
+            'subject_name'           => $event->subjectType === 'vehicle' ? ($vehicle?->display_name ?? $vehicle?->plate_number) : $driver?->name,
+            'geofence_uuid'          => $event->geofence->uuid,
+            'geofence_type'          => $event->geofenceType,
+            'geofence_name'          => $event->geofence->name,
+            'event_type'             => 'dwelled',
+            'latitude'               => null,
+            'longitude'              => null,
+            'dwell_duration_minutes' => $event->dwellDurationMinutes,
+            'occurred_at'            => $event->timestamp,
+        ]);
+    }
+}