@fleetbase/fleetops-engine 0.6.70 → 0.6.72

package/server/src/Http/Filter/ProofFilter.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Filter;
+
+use Fleetbase\Http\Filter\Filter;
+
+class ProofFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        $this->builder->where('company_uuid', $this->session->get('company'));
+    }
+
+    public function queryForPublic()
+    {
+        $this->queryForInternal();
+    }
+}

package/server/src/Http/Filter/RouteFilter.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Filter;
+
+use Fleetbase\Http\Filter\Filter;
+
+class RouteFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        $this->builder->where('company_uuid', $this->session->get('company'));
+    }
+
+    public function queryForPublic()
+    {
+        $this->queryForInternal();
+    }
+}

package/server/src/Http/Filter/TelematicFilter.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Filter;
+
+use Fleetbase\Http\Filter\Filter;
+
+class TelematicFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        $this->builder->where('company_uuid', $this->session->get('company'));
+    }
+
+    public function queryForPublic()
+    {
+        $this->queryForInternal();
+    }
+
+    public function query(?string $searchQuery)
+    {
+        $this->builder->search($searchQuery);
+    }
+}

package/server/src/Http/Filter/WarrantyFilter.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Filter;
+
+use Fleetbase\Http\Filter\Filter;
+
+class WarrantyFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        $this->builder->where('company_uuid', $this->session->get('company'));
+    }
+
+    public function queryForPublic()
+    {
+        $this->queryForInternal();
+    }
+
+    public function query(?string $searchQuery)
+    {
+        $this->builder->search($searchQuery);
+    }
+}

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

@@ -20,7 +20,8 @@ class CancelOrderRequest extends FleetbaseRequest
     public function rules(): array
     {
         return [
-            'order' => 'required|exists:orders,uuid',
+            'order'  => 'required|exists:orders,uuid',
+            'reason' => 'nullable|string|max:1000',
         ];
     }
 }

package/server/src/Http/Resources/v1/Concerns/ResolvesPublicRelationFields.php

@@ -3,6 +3,8 @@
 namespace Fleetbase\FleetOps\Http\Resources\v1\Concerns;
 
 use Fleetbase\Support\Http;
+use Fleetbase\Support\RequestRelations;
+use Illuminate\Database\Eloquent\Model;
 use Illuminate\Http\Resources\MissingValue;
 
 /**
@@ -30,6 +32,13 @@ trait ResolvesPublicRelationFields
      * model actually defines are kept — a parent's expansion must never reach
      * this model's loader, where it raises RelationNotFoundException.
      *
+     * The result is handed to `loadMissing()`, and Eloquent loads a name by
+     * calling it as a method on a blank model, so a name that is merely a
+     * method (`with=saveInstance`) would run it. When core's RequestRelations
+     * is available an Eloquent model keeps only declared relations, each
+     * segment named as the model's method (`service_area` → `serviceArea`).
+     * Older core releases without it keep the root-method check below.
+     *
      * @return array<int, string>
      */
     protected function requestedRelations($request): array
@@ -46,6 +55,10 @@ trait ResolvesPublicRelationFields
 
         $with = array_values(array_filter(array_map('strval', $with), 'strlen'));
 
+        if ($this->resource instanceof Model && class_exists(RequestRelations::class)) {
+            return RequestRelations::eagerLoads($this->resource, $with);
+        }
+
         return array_values(array_filter($with, fn (string $relation): bool => $this->definesRelation($relation)));
     }
 
@@ -77,7 +90,7 @@ trait ResolvesPublicRelationFields
      * loaded on the public endpoints, so the key was absent unless `with` named
      * it. Absent stays absent; it never becomes a string.
      *
-     * @param array<int, string> $with camelCased relations the caller asked for
+     * @param array<int, string> $with the relation paths requestedRelations() kept, named as the model's methods
      */
     protected function publicRelationObject(string $relation, array $with, \Closure $resource): mixed
     {

package/server/src/Http/Resources/v1/Index/Customer.php

@@ -2,8 +2,12 @@
 
 namespace Fleetbase\FleetOps\Http\Resources\v1\Index;
 
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\Customer as CustomerModel;
+use Fleetbase\FleetOps\Models\Vendor;
 use Fleetbase\Http\Resources\FleetbaseResource;
 use Fleetbase\Support\Http;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
 
 /**
  * Lightweight Customer resource for index views.
@@ -28,6 +32,20 @@ class Customer extends FleetbaseResource
             'name'         => $this->name,
             'phone'        => $this->phone ?? null,
             'email'        => $this->email ?? null,
+            'photo_url'    => $this->resource instanceof Vendor ? $this->logo_url : ($this->photo_url ?? null),
         ];
     }
+
+    /**
+     * Eager loads the file each customer type's `photo_url` reads (a contact's
+     * photo, a vendor's logo), so listing orders does not query once per row.
+     */
+    public static function withPhoto(MorphTo $relation): MorphTo
+    {
+        return $relation->morphWith([
+            Contact::class       => ['photo'],
+            CustomerModel::class => ['photo'],
+            Vendor::class        => ['logo'],
+        ]);
+    }
 }

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

@@ -94,12 +94,12 @@ class Order extends FleetbaseResource
 
             // Latest status only, not full array
             'latest_status'        => $this->whenLoaded('trackingStatuses', function () {
-                $latest = $this->trackingStatuses->first();
+                $latest = $this->latestTrackingStatus();
 
                 return $latest ? $latest->status : 'created';
             }),
             'latest_status_code'   => $this->whenLoaded('trackingStatuses', function () {
-                $latest = $this->trackingStatuses->first();
+                $latest = $this->latestTrackingStatus();
 
                 return $latest ? $latest->code : null;
             }),
@@ -127,4 +127,13 @@ class Order extends FleetbaseResource
             ],
         ];
     }
+
+    /**
+     * The newest loaded tracking status. The relation has no order, so the
+     * statuses are sorted here, newest insert first within the same second.
+     */
+    protected function latestTrackingStatus(): mixed
+    {
+        return $this->trackingStatuses->sortBy([['created_at', 'desc'], ['id', 'desc']])->first();
+    }
 }

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

@@ -0,0 +1,153 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Resources\v1;
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Support\Utils;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/**
+ * What the public Track Order page gets for a tracking number.
+ *
+ * The lookup has no session, so whoever holds the tracking number sees this.
+ * It carries only what `order-tracking-lookup` renders: status, the tracking
+ * timeline, ETA and progress, the stop coordinates the map routes between,
+ * and the item list. Notes, meta, internal ids, files, rates, and customer
+ * and facilitator details stay out. The driver's position is included only
+ * while the order is under way.
+ *
+ * It extends `JsonResource`, not `FleetbaseResource`, so transformers that
+ * other extensions register for resources cannot add fields to it. Records are
+ * keyed by public id, which Ember Data needs to build them, so the page never
+ * learns an internal uuid.
+ */
+class PublicOrderTracking extends JsonResource
+{
+    /**
+     * Never wrapped, whatever another resource set the shared wrapper to.
+     *
+     * @var string|null
+     */
+    public static $wrap;
+
+    /**
+     * Statuses after which the order is no longer under way.
+     */
+    public const FINISHED_STATUSES = ['completed', 'canceled', 'cancelled'];
+
+    /**
+     * Transform the resource into an array.
+     *
+     * @param \Illuminate\Http\Request $request
+     */
+    public function toArray($request): array
+    {
+        /** @var Order $order */
+        $order          = $this->resource;
+        $trackingNumber = $order->trackingNumber;
+        $tracker        = is_array($order->tracker_data) ? $order->tracker_data : [];
+
+        return [
+            'uuid'                => $order->public_id,
+            'tracking'            => data_get($trackingNumber, 'tracking_number'),
+            'status'              => $order->status,
+            'has_driver_assigned' => (bool) $order->has_driver_assigned,
+            'tracking_number'     => $trackingNumber ? [
+                'uuid'            => $trackingNumber->public_id,
+                'tracking_number' => $trackingNumber->tracking_number,
+            ] : null,
+            'tracking_statuses'   => collect($order->trackingStatuses)->map(fn ($status) => [
+                'uuid'       => $status->public_id,
+                'status'     => $status->status,
+                'details'    => $status->details,
+                'created_at' => $status->created_at,
+            ])->values()->all(),
+            'payload'             => $this->payload($order->payload),
+            'tracker_data'        => $this->trackerData($tracker, static::isInProgress($order)),
+            'created_at'          => $order->created_at,
+        ];
+    }
+
+    /**
+     * Whether the order is under way: started, and not yet completed or canceled.
+     */
+    public static function isInProgress(Order $order): bool
+    {
+        return (bool) $order->started && !in_array(strtolower((string) $order->status), static::FINISHED_STATUSES, true);
+    }
+
+    /**
+     * The stops the map routes between and the items the page lists.
+     */
+    protected function payload($payload): ?array
+    {
+        if (!$payload) {
+            return null;
+        }
+
+        return [
+            'uuid'      => $payload->public_id,
+            'pickup'    => $this->place($payload->pickup),
+            'dropoff'   => $this->place($payload->dropoff),
+            'waypoints' => collect($payload->waypoints)->map(fn ($place) => $this->place($place))->values()->all(),
+            'entities'  => collect($payload->entities)->map(fn ($entity) => [
+                'uuid'        => $entity->public_id,
+                'name'        => $entity->name,
+                'description' => $entity->description,
+                'tracking'    => data_get($entity, 'tracking'),
+                'price'       => $entity->price,
+                'currency'    => $entity->currency,
+                'photo_url'   => data_get($entity, 'photo_url'),
+            ])->values()->all(),
+        ];
+    }
+
+    /**
+     * A stop as the map needs it: its coordinates, with no address or contact.
+     */
+    protected function place($place): ?array
+    {
+        if (!$place) {
+            return null;
+        }
+
+        return [
+            'uuid'     => $place->public_id,
+            'location' => Utils::castPoint($place->location),
+        ];
+    }
+
+    /**
+     * The tracker fields the page reads; the driver's position only while under way.
+     */
+    protected function trackerData(array $tracker, bool $inProgress): array
+    {
+        return [
+            'driver'      => [
+                'location' => $inProgress ? data_get($tracker, 'driver.location') : null,
+            ],
+            'progress'    => [
+                'percentage'      => data_get($tracker, 'progress.percentage'),
+                'completed_stops' => data_get($tracker, 'progress.completed_stops'),
+            ],
+            'eta'         => [
+                'active_stop_seconds' => data_get($tracker, 'eta.active_stop_seconds'),
+                'completion_at'       => data_get($tracker, 'eta.completion_at'),
+            ],
+            'active_stop' => $this->stop(data_get($tracker, 'active_stop')),
+            'next_stop'   => $this->stop(data_get($tracker, 'next_stop')),
+        ];
+    }
+
+    /**
+     * A stop the page names under "Current/Next Destination".
+     */
+    protected function stop($stop): ?array
+    {
+        if (!is_array($stop)) {
+            return null;
+        }
+
+        return ['address' => data_get($stop, 'address')];
+    }
+}

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

@@ -2,6 +2,7 @@
 
 namespace Fleetbase\FleetOps\Http\Resources\v1;
 
+use Fleetbase\FleetOps\Support\TrackingCode;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\Http\Resources\FleetbaseResource;
 use Fleetbase\Support\Http;
@@ -30,47 +31,20 @@ class TrackingNumber extends FleetbaseResource
             'status'          => $this->last_status,
             'status_code'     => $this->last_status_code,
             'qr_code'         => $this->qr_code,
-            // The raw text encoded inside qr_code, exposed ONLY in debug mode.
-            //
-            // qr_code is a base64 PNG generated from owner_uuid (TrackingNumber::newBarcode),
-            // and the endpoints that consume a scanned code match on that uuid. A client
-            // scans the image to obtain it; an automated contract run cannot, so debug
-            // builds publish the value beside the image rather than the API growing a
-            // decode endpoint or handing out uuids generally.
-            //
-            // `when()` omits the key entirely when false — it is absent, not null — so a
-            // production response is byte-identical to before.
-            'qr_code_content' => $this->when(static::exposesQrCodeContent(), fn () => $this->owner_uuid),
+            // A value that scans as this tracking number: the QR content current labels
+            // print (see TrackingCode). It names the tracking number and the subject's
+            // public id, both already in this resource, so it is safe to publish, and lets
+            // clients that print their own labels, or cannot decode a PNG, use the code.
+            // Labels printed before it encode the owner uuid; resolvers accept both.
+            'qr_code_content' => $this->when($this->tracking_number, fn () => TrackingCode::qrContent($this->tracking_number, Utils::get($this->owner, 'public_id'))),
             'barcode'         => $this->barcode,
-            'url'             => Utils::consoleUrl('track-order', ['order' => $this->tracking_number]),
+            'url'             => $this->when($this->tracking_number, fn () => TrackingCode::pageUrl($this->tracking_number, $this->company_uuid)),
             'type'            => Utils::getTypeFromClassName($this->owner_type),
             'updated_at'      => $this->updated_at,
             'created_at'      => $this->created_at,
         ];
     }
 
-    /**
-     * Whether the QR code's decoded content may be published.
-     *
-     * Debug mode only, and fails closed: any failure to determine the debug state — no
-     * container, an application without the accessor — answers false rather than
-     * defaulting to exposure.
-     */
-    protected static function exposesQrCodeContent(): bool
-    {
-        try {
-            $app = app();
-
-            if (!is_object($app) || !method_exists($app, 'hasDebugModeEnabled')) {
-                return false;
-            }
-
-            return (bool) $app->hasDebugModeEnabled();
-        } catch (\Throwable $e) {
-            return false;
-        }
-    }
-
     /**
      * Transform the resource into an webhook payload.
      *

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

@@ -17,19 +17,23 @@ class Zone extends FleetbaseResource
     public function toArray($request)
     {
         return $this->withCustomFields([
-            'id'                => $this->when(Http::isInternalRequest(), $this->id, $this->public_id),
-            'public_id'         => $this->when(Http::isInternalRequest(), $this->public_id),
-            'uuid'              => $this->when(Http::isInternalRequest(), $this->uuid),
-            'service_area_uuid' => $this->when(Http::isInternalRequest(), $this->service_area_uuid),
-            'name'              => $this->name,
-            'description'       => $this->description,
-            'center'            => $this->location,
-            'border'            => $this->border,
-            'color'             => $this->color,
-            'stroke_color'      => $this->stroke_color,
-            'status'            => $this->status,
-            'updated_at'        => $this->updated_at,
-            'created_at'        => $this->created_at,
+            'id'                      => $this->when(Http::isInternalRequest(), $this->id, $this->public_id),
+            'public_id'               => $this->when(Http::isInternalRequest(), $this->public_id),
+            'uuid'                    => $this->when(Http::isInternalRequest(), $this->uuid),
+            'service_area_uuid'       => $this->when(Http::isInternalRequest(), $this->service_area_uuid),
+            'name'                    => $this->name,
+            'description'             => $this->description,
+            'center'                  => $this->location,
+            'border'                  => $this->border,
+            'color'                   => $this->color,
+            'stroke_color'            => $this->stroke_color,
+            'trigger_on_entry'        => $this->trigger_on_entry,
+            'trigger_on_exit'         => $this->trigger_on_exit,
+            'dwell_threshold_minutes' => $this->dwell_threshold_minutes,
+            'speed_limit_kmh'         => $this->speed_limit_kmh,
+            'status'                  => $this->status,
+            'updated_at'              => $this->updated_at,
+            'created_at'              => $this->created_at,
         ]);
     }
 
@@ -41,16 +45,20 @@ class Zone extends FleetbaseResource
     public function toWebhookPayload()
     {
         return [
-            'id'           => $this->public_id,
-            'name'         => $this->name,
-            'description'  => $this->description,
-            'center'       => $this->location,
-            'border'       => $this->border,
-            'color'        => $this->color,
-            'stroke_color' => $this->stroke_color,
-            'status'       => $this->status,
-            'updated_at'   => $this->updated_at,
-            'created_at'   => $this->created_at,
+            'id'                      => $this->public_id,
+            'name'                    => $this->name,
+            'description'             => $this->description,
+            'center'                  => $this->location,
+            'border'                  => $this->border,
+            'color'                   => $this->color,
+            'stroke_color'            => $this->stroke_color,
+            'trigger_on_entry'        => $this->trigger_on_entry,
+            'trigger_on_exit'         => $this->trigger_on_exit,
+            'dwell_threshold_minutes' => $this->dwell_threshold_minutes,
+            'speed_limit_kmh'         => $this->speed_limit_kmh,
+            'status'                  => $this->status,
+            'updated_at'              => $this->updated_at,
+            'created_at'              => $this->created_at,
         ];
     }
 }

package/server/src/Jobs/FinalizeApiOrderCreation.php

@@ -38,7 +38,9 @@ class FinalizeApiOrderCreation implements ShouldQueue
         $order->setPreliminaryDistanceAndTime();
         $order->purchaseServiceQuote($serviceQuote);
 
-        if ($this->shouldDispatch) {
+        // The order may have been dispatched or started while this job waited in the
+        // queue; dispatching it again would move its status backwards.
+        if ($this->shouldDispatch && $order->isAwaitingDispatch()) {
             $order->dispatchWithActivity();
         }
 

package/server/src/Jobs/ProcessAllocationJob.php

@@ -6,7 +6,7 @@ use Fleetbase\FleetOps\Models\Driver;
 use Fleetbase\FleetOps\Models\Order;
 use Fleetbase\FleetOps\Models\Vehicle;
 use Fleetbase\FleetOps\Orchestration\OrchestrationEngineRegistry;
-use Fleetbase\Models\Setting;
+use Fleetbase\FleetOps\Orchestration\Support\OrchestratorSettings;
 use Illuminate\Bus\Queueable;
 use Illuminate\Contracts\Queue\ShouldQueue;
 use Illuminate\Foundation\Bus\Dispatchable;
@@ -69,9 +69,17 @@ class ProcessAllocationJob implements ShouldQueue
             return;
         }
 
-        $engine = $registry->resolve($this->engineId());
+        $result = $registry->allocateWithFallback($this->engineId(), $orders, $vehicles, $this->allocationOptions());
 
-        $result = $engine->allocate($orders, $vehicles, $this->allocationOptions());
+        if (!empty($result['summary']['fallback_reason'])) {
+            $this->logInfo(sprintf(
+                '[ProcessAllocationJob] Used the %s engine instead of %s for company %s: %s',
+                $result['summary']['engine'],
+                $result['summary']['requested_engine'],
+                $this->companyUuid,
+                $result['summary']['fallback_reason']
+            ));
+        }
 
         foreach ($result['assignments'] as $assignment) {
             $order  = $this->findOrderByPublicId($assignment['order_id']);
@@ -125,14 +133,16 @@ class ProcessAllocationJob implements ShouldQueue
 
     protected function engineId(): string
     {
-        return Setting::lookup('fleetops.orchestrator_engine', 'greedy');
+        return OrchestratorSettings::engineForCompany($this->companyUuid);
     }
 
     protected function allocationOptions(): array
     {
+        $settings = OrchestratorSettings::forCompany($this->companyUuid);
+
         return [
-            'max_travel_time'  => Setting::lookup('fleetops.allocation_max_travel_time', 3600),
-            'balance_workload' => Setting::lookup('fleetops.allocation_balance_workload', false),
+            'max_travel_time'  => (int) $settings['max_travel_time_seconds'],
+            'balance_workload' => (bool) $settings['balance_workload'],
         ];
     }
 

package/server/src/Jobs/PublishTrackingUpdate.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Fleetbase\FleetOps\Jobs;
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Support\TrackingPublisher;
+use Fleetbase\FleetOps\Support\TrackingUpdate;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Support\Facades\Cache;
+
+/**
+ * Builds and publishes an order's public tracking updates off the request path.
+ *
+ * Location jobs publish the position only, except that at most once per ETA interval they
+ * publish the full update instead so that customers' ETAs follow the vehicle.
+ */
+class PublishTrackingUpdate implements ShouldQueue
+{
+    use Dispatchable;
+    use InteractsWithQueue;
+    use Queueable;
+
+    public $tries   = 1;
+    public $timeout = 60;
+
+    public function __construct(public string $orderUuid, public string $reason = TrackingUpdate::REASON_STATUS, public ?string $dbConnection = null)
+    {
+    }
+
+    public function handle(TrackingPublisher $publisher): int
+    {
+        $order = Order::on($this->dbConnection)->where('uuid', $this->orderUuid)->first();
+        if (!$order) {
+            return 0;
+        }
+
+        if ($this->reason !== TrackingUpdate::REASON_LOCATION) {
+            return $publisher->publishOrder($order, $this->reason);
+        }
+
+        if (Cache::add('fleetops:tracking:eta:' . $order->uuid, 1, TrackingPublisher::ETA_INTERVAL)) {
+            return $publisher->publishOrder($order, TrackingUpdate::REASON_ETA);
+        }
+
+        return $publisher->publishLocation($order);
+    }
+}