@fleetbase/fleetops-engine 0.6.44 → 0.6.46

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

@@ -184,9 +184,17 @@ class SettingController extends Controller
      */
     public function saveRoutingSettings(Request $request)
     {
-        $router = $request->input('router');
-        $unit   = $request->input('unit', 'km');
-        Setting::configureCompany('routing', ['router' => $router, 'unit' => $unit]);
+        $displayEngine      = $request->input('display_engine', $request->input('router', 'osrm'));
+        $optimizationEngine = $request->input('optimization_engine', $displayEngine);
+        $unit               = $request->input('unit', 'km');
+        Setting::configureCompany('routing', [
+            'router'                      => $displayEngine,
+            'display_engine'              => $displayEngine,
+            'optimization_engine'         => $optimizationEngine,
+            'routing_display_engine'      => $displayEngine,
+            'routing_optimization_engine' => $optimizationEngine,
+            'unit'                        => $unit,
+        ]);
 
         return response()->json([
             'status'  => 'ok',
@@ -203,6 +211,14 @@ class SettingController extends Controller
     {
         $routingSettings = Setting::lookupCompany('routing', ['router' => 'osrm', 'unit' => 'km']);
 
+        $displayEngine = data_get($routingSettings, 'display_engine', data_get($routingSettings, 'routing_display_engine', data_get($routingSettings, 'router', 'osrm')));
+        $optimizationEngine = data_get($routingSettings, 'optimization_engine', data_get($routingSettings, 'routing_optimization_engine', $displayEngine));
+        $routingSettings['router'] = $displayEngine;
+        $routingSettings['display_engine'] = $displayEngine;
+        $routingSettings['optimization_engine'] = $optimizationEngine;
+        $routingSettings['routing_display_engine'] = $displayEngine;
+        $routingSettings['routing_optimization_engine'] = $optimizationEngine;
+
         // always default to km if no unit is set
         if (!isset($routingSettings['unit'])) {
             $routingSettings['unit'] = 'km';
@@ -211,6 +227,93 @@ class SettingController extends Controller
         return response()->json($routingSettings);
     }
 
+    /**
+     * Retrieve and return the map provider settings for the current company.
+     *
+     * The Google Maps API key is sourced exclusively from the system-level
+     * services configuration managed by the core-api admin settings panel
+     * (services.google_maps.api_key). FleetOps never stores or manages the
+     * key independently — it simply reads it from the shared system config
+     * and passes it to the frontend so the Google Maps adapter can initialise.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function getMapSettings()
+    {
+        $defaults = [
+            'mapProvider' => 'leaflet',
+        ];
+
+        $systemMapSettings = Setting::lookup('fleet-ops.map-settings', []);
+        $mapSettings = Setting::lookupFromCompany('fleet-ops.map-settings', $defaults);
+        $mapSettings['mapProvider'] = data_get($mapSettings, 'mapProvider') ?: data_get($systemMapSettings, 'mapProvider', 'leaflet');
+
+        // Source the Google Maps API key from the system-level services config
+        // that is managed by the core-api admin settings panel. This ensures a
+        // single source of truth and avoids duplicating key management.
+        $mapSettings['googleMapsApiKey'] = config('services.google_maps.api_key', env('GOOGLE_MAPS_API_KEY', ''));
+        $mapSettings['googleMapsMapId'] = data_get($systemMapSettings, 'googleMapsMapId', '');
+
+        return response()->json($mapSettings);
+    }
+
+    /**
+     * Persist the map provider settings for the current company.
+     *
+     * The Google Maps API key is managed entirely through the core-api admin
+     * settings panel (Settings → Services → Google Maps) and is therefore
+     * never accepted or stored by this endpoint. Only the provider selection
+     * and display preferences are persisted here.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function saveMapSettings(Request $request)
+    {
+        $settings = $request->input('settings', []);
+
+        // The API key is managed at the system level via core-api — strip it
+        // from the payload in case a client accidentally sends it.
+        unset($settings['googleMapsApiKey']);
+
+        // Validate provider value
+        $allowedProviders = ['leaflet', 'google'];
+        if (isset($settings['mapProvider']) && !in_array($settings['mapProvider'], $allowedProviders)) {
+            $settings['mapProvider'] = 'leaflet';
+        }
+
+        Setting::configureCompany('fleet-ops.map-settings', $settings);
+
+        return response()->json($this->getMapSettings()->getData(true));
+    }
+
+    public function getAdminMapSettings()
+    {
+        $defaults = [
+            'mapProvider' => 'leaflet',
+            'googleMapsMapId' => '',
+        ];
+
+        return response()->json(Setting::lookup('fleet-ops.map-settings', $defaults));
+    }
+
+    public function saveAdminMapSettings(Request $request)
+    {
+        $allowedProviders = ['leaflet', 'google'];
+        $mapProvider = $request->input('mapProvider', 'leaflet');
+        if (!in_array($mapProvider, $allowedProviders)) {
+            $mapProvider = 'leaflet';
+        }
+
+        $settings = [
+            'mapProvider' => $mapProvider,
+            'googleMapsMapId' => (string) $request->input('googleMapsMapId', ''),
+        ];
+
+        Setting::configure('fleet-ops.map-settings', $settings);
+
+        return response()->json($this->getAdminMapSettings()->getData(true));
+    }
+
     /**
      * Retrieve driver scheduling settings for the current company.
      *

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

@@ -44,10 +44,11 @@ class OrderFilter extends Filter
         // eager load main relationships to reduce N+1 overhead
         $this->builder->with([
             'payload.entities',
-            'payload.waypoints',
             'payload.pickup',
             'payload.dropoff',
             'payload.return',
+            'payload.firstWaypointMarker.place',
+            'payload.lastWaypointMarker.place',
             'trackingNumber',
             'trackingStatuses',
             'driverAssigned' => function ($query) {

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/Resources/v1/Index/Payload.php

@@ -19,6 +19,8 @@ class Payload extends FleetbaseResource
     public function toArray($request): array
     {
         $isInternal = Http::isInternalRequest();
+        $pickup = $this->index_pickup_place;
+        $dropoff = $this->index_dropoff_place;
 
         return [
             'id'           => $this->when($isInternal, $this->id, $this->public_id),
@@ -30,24 +32,24 @@ class Payload extends FleetbaseResource
             'return_uuid'  => $this->when($isInternal, $this->return_uuid),
 
             // Minimal pickup - only what's displayed in the table
-            'pickup'     => $this->whenLoaded('pickup', function () {
-                return new Place($this->pickup);
+            'pickup'     => $this->when($pickup, function () use ($pickup) {
+                return new Place($pickup);
             }),
 
             // Minimal dropoff - only what's displayed in the table
-            'dropoff'    => $this->whenLoaded('dropoff', function () {
-                return new Place($this->dropoff);
+            'dropoff'    => $this->when($dropoff, function () use ($dropoff) {
+                return new Place($dropoff);
             }),
 
             // Entity count instead of full entities
             'entities_count' => $this->whenLoaded('entities', function () {
                 return $this->entities->count();
-            }),
+            }, $this->entities()->count()),
 
-            // Waypoint count instead of full waypoints
+            // Waypoint count for lightweight route-shape summaries.
             'waypoints_count' => $this->whenLoaded('waypoints', function () {
                 return $this->waypoints->count();
-            }),
+            }, $this->waypoints()->count()),
 
             'type'       => $this->type,
             'created_at' => $this->created_at,

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

@@ -2,6 +2,7 @@
 
 namespace Fleetbase\FleetOps\Http\Resources\v1;
 
+use Fleetbase\FleetOps\Models\Contact as ContactModel;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\Http\Resources\Comment;
 use Fleetbase\Http\Resources\File;
@@ -45,7 +46,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),
@@ -57,7 +57,7 @@ class Order extends FleetbaseResource
                 $orderConfigPublicId
             ),
             'customer'             => $this->whenLoaded('customer', function () {
-                return $this->setCustomerType($this->transformMorphResource($this->customer));
+                return $this->setCustomerType($this->transformOrderCustomerResource($this->customer));
             }),
             'payload'              => new Payload($this->payload),
             'facilitator'          => $this->whenLoaded('facilitator', function () {
@@ -170,6 +170,24 @@ class Order extends FleetbaseResource
         return (new \Illuminate\Http\Resources\Json\JsonResource($model))->resolve();
     }
 
+    /**
+     * Transform the order customer resource without nesting the customer's user relationship.
+     *
+     * @param \Illuminate\Database\Eloquent\Model|null $model
+     *
+     * @return array|null
+     */
+    protected function transformOrderCustomerResource($model)
+    {
+        $resolved = $this->transformMorphResource($model);
+
+        if ($model instanceof ContactModel && is_array($resolved)) {
+            unset($resolved['user']);
+        }
+
+        return $resolved;
+    }
+
     /**
      * Transform the resource into an webhook payload.
      *

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/Models/Entity.php

@@ -168,6 +168,13 @@ class Entity extends Model
         ])->render();
     }
 
+    public function setTypeAttribute(?string $type = null): void
+    {
+        $type = is_string($type) ? trim($type) : $type;
+
+        $this->attributes['type'] = filled($type) ? Str::snake($type) : null;
+    }
+
     /**
      * @var BelongsTo
      */

package/server/src/Models/Order.php

@@ -1055,9 +1055,7 @@ class Order extends Model
             'meta'               => $meta,
         ]);
 
-        $this->purchase_rate_uuid = $purchasedRate->uuid;
-
-        return $this->save();
+        return $this->attachPurchaseRate($purchasedRate);
     }
 
     /**
@@ -1096,14 +1094,48 @@ class Order extends Model
                 'meta'               => $meta,
             ]);
 
-            return $this->updateQuietly([
-                'purchase_rate_uuid' => $purchasedRate->uuid,
-            ]);
+            return $this->attachPurchaseRate($purchasedRate);
         }
 
         return false;
     }
 
+    /**
+     * Attach a purchase rate to the order and void any superseded transaction.
+     */
+    public function attachPurchaseRate(PurchaseRate $purchaseRate): bool
+    {
+        $oldTransaction = $this->transaction_uuid
+            ? Transaction::where('uuid', $this->transaction_uuid)->first()
+            : null;
+
+        $attached = (bool) $this->updateQuietly([
+            'purchase_rate_uuid' => $purchaseRate->uuid,
+            'transaction_uuid'   => $purchaseRate->transaction_uuid,
+        ]);
+
+        if ($attached) {
+            $this->setRelation('purchaseRate', $purchaseRate);
+
+            if ($purchaseRate->transaction_uuid) {
+                $this->setRelation('transaction', Transaction::where('uuid', $purchaseRate->transaction_uuid)->first());
+            }
+
+            if (
+                $oldTransaction instanceof Transaction
+                && $oldTransaction->uuid !== $purchaseRate->transaction_uuid
+                && !$oldTransaction->trashed()
+            ) {
+                $oldTransaction->update([
+                    'status'    => Transaction::STATUS_VOIDED,
+                    'voided_at' => now(),
+                ]);
+            }
+        }
+
+        return $attached;
+    }
+
     /**
      * Creates a transaction for the order without a service quote.
      * This method is used when an order is made without selecting a specific service quote.
@@ -1122,7 +1154,7 @@ class Order extends Model
                 'gateway_transaction_id' => Transaction::generateNumber(),
                 'gateway'                => 'internal',
                 'amount'                 => 0,
-                'currency'               => data_get($this->company, 'country') ? Utils::getCurrenyFromCountryCode(data_get($this->company, 'country')) : 'SGD',
+                'currency'               => Utils::getCompanyTransactionCurrency($this->company ?? $this->company_uuid),
                 'description'            => 'Dispatch order',
                 'type'                   => 'dispatch',
                 'status'                 => 'success',
@@ -1700,6 +1732,16 @@ class Order extends Model
 
         if (Str::isUuid($this->order_config_uuid)) {
             $orderConfig = OrderConfig::where('uuid', $this->order_config_uuid)->withTrashed()->first();
+            if ($orderConfig instanceof OrderConfig) {
+                $orderConfig->setOrderContext($this);
+
+                return $orderConfig;
+            }
+        }
+
+        $company = $this->relationLoaded('company') ? $this->company : $this->company()->first();
+        $orderConfig = OrderConfig::defaultOrCreate($company);
+        if ($orderConfig instanceof OrderConfig) {
             $orderConfig->setOrderContext($this);
 
             return $orderConfig;
@@ -1708,6 +1750,37 @@ class Order extends Model
         return null;
     }
 
+    /**
+     * Ensure the order has a persisted order config and normalized type.
+     */
+    public function ensureOrderConfig(): ?OrderConfig
+    {
+        $orderConfig = $this->config();
+
+        if (!$orderConfig) {
+            return null;
+        }
+
+        $updates = [];
+
+        if ($this->order_config_uuid !== $orderConfig->uuid) {
+            $updates['order_config_uuid'] = $orderConfig->uuid;
+        }
+
+        if (empty($this->type) || $this->type === 'default' || $this->type !== $orderConfig->key) {
+            $updates['type'] = $orderConfig->key;
+        }
+
+        if (!empty($updates)) {
+            $this->fill($updates);
+            $this->save();
+        }
+
+        $this->setRelation('orderConfig', $orderConfig);
+
+        return $orderConfig;
+    }
+
     /**
      * Retrieves the flow configuration from the order config.
      *
@@ -1721,7 +1794,7 @@ class Order extends Model
     public function getConfigFlow(): array
     {
         $orderConfig = $this->config();
-        if (is_array($orderConfig->flow)) {
+        if ($orderConfig && is_array($orderConfig->flow)) {
             return $orderConfig->flow;
         }
 

package/server/src/Models/OrderConfig.php

@@ -5,6 +5,7 @@ namespace Fleetbase\FleetOps\Models;
 use Fleetbase\Casts\Json;
 use Fleetbase\FleetOps\Casts\OrderConfigEntities;
 use Fleetbase\FleetOps\Flow\Activity;
+use Fleetbase\FleetOps\Support\FleetOps;
 use Fleetbase\Models\Company;
 use Fleetbase\Models\Model;
 use Fleetbase\Support\Auth;
@@ -498,4 +499,18 @@ class OrderConfig extends Model
     {
         return static::where(['namespace' => 'system:order-config:transport', 'company_uuid' => $company ? $company->uuid : session('company')])->first();
     }
+
+    /**
+     * Get the default transport config, creating it for the company if needed.
+     */
+    public static function defaultOrCreate(?Company $company = null): ?self
+    {
+        $company ??= Company::where('uuid', session('company'))->first();
+
+        if (!$company) {
+            return static::default($company);
+        }
+
+        return static::default($company) ?? FleetOps::createTransportConfig($company);
+    }
 }

package/server/src/Models/Payload.php

@@ -137,6 +137,26 @@ class Payload extends Model
         return $this->hasMany(Waypoint::class)->with(['place']);
     }
 
+    /**
+     * The first waypoint marker for lightweight index fallback.
+     */
+    public function firstWaypointMarker()
+    {
+        return $this->hasOne(Waypoint::class, 'payload_uuid', 'uuid')
+            ->oldestOfMany('order')
+            ->with(['place']);
+    }
+
+    /**
+     * The last waypoint marker for lightweight index fallback.
+     */
+    public function lastWaypointMarker()
+    {
+        return $this->hasOne(Waypoint::class, 'payload_uuid', 'uuid')
+            ->latestOfMany('order')
+            ->with(['place']);
+    }
+
     public function getTotalEntitiesAttribute()
     {
         return $this->entities()->count();
@@ -534,48 +554,104 @@ class Payload extends Model
             return $this;
         }
 
-        $placeIds = [];
+        $this->loadMissing('waypointMarkers');
+        $keptWaypointIds = [];
+        $availableWaypointMarkers = $this->waypointMarkers()->get();
 
-        // collect all place ids to insert
         foreach ($waypoints as $index => $attributes) {
+            $raw = $attributes;
+            $type = data_get($raw, 'type', 'dropoff');
+            $customerUuidIn = data_get($raw, 'customer_uuid');
+            $customerPubIdIn = data_get($raw, 'customer_id');
+            $customerType = data_get($raw, 'customer_type', 'fleetops:contact');
+
             if (Utils::isset($attributes, 'place') && is_array(Utils::get($attributes, 'place'))) {
                 $attributes = Utils::get($attributes, 'place');
             }
 
-            if (is_array($attributes) && array_key_exists('place_uuid', $attributes)) {
-                $placeIds[] = $attributes['place_uuid'];
+            $placeUuid = null;
+
+            if (
+                is_array($attributes)
+                && isset($attributes['place_uuid'])
+                && Place::where('uuid', $attributes['place_uuid'])->exists()
+            ) {
+                $placeUuid = $attributes['place_uuid'];
+            } elseif (
+                is_array($attributes)
+                && isset($attributes['uuid'])
+                && ($resolvedUuid = Place::where('uuid', $attributes['uuid'])->value('uuid'))
+            ) {
+                $placeUuid = $resolvedUuid;
+            } elseif (
+                is_array($attributes)
+                && isset($attributes['id'])
+                && ($resolvedUuid = Place::where('public_id', $attributes['id'])->value('uuid'))
+            ) {
+                $placeUuid = $resolvedUuid;
             } else {
-                $placeUuid  = Place::insertFromMixed($attributes);
-                $placeIds[] = $placeUuid;
+                $place = Place::createFromMixed($attributes);
+
+                if ($place instanceof Place && isset($attributes['uuid']) && $place->uuid !== $attributes['uuid']) {
+                    $place->updateMeta('search_uuid', $attributes['uuid']);
+                }
+
+                $placeUuid = $place->uuid;
             }
-        }
 
-        /** @return \Illuminate\Database\Eloquent\Collection $waypointMakers */
-        $waypointMakers = $this->waypointMarkers()->get();
+            $customerUuid = null;
+            $customerTypeNamespace = null;
 
-        // remove all waypoints that are not included in the placeids
-        $waypointMakers = $waypointMakers->filter(function ($waypointMarker) use ($placeIds) {
-            if (!in_array($waypointMarker->place_uuid, $placeIds)) {
-                $waypointMarker->delete();
+            if ($customerType) {
+                $customerTypeNamespace = Utils::getMutationType($customerType);
+                $customerModel = app($customerTypeNamespace);
+
+                if ($customerUuidIn && $customerModel->where('uuid', $customerUuidIn)->exists()) {
+                    $customerUuid = $customerUuidIn;
+                }
+
+                if (!$customerUuid && $customerPubIdIn) {
+                    $maybeUuid = $customerModel->where('public_id', $customerPubIdIn)->value('uuid');
+                    if ($maybeUuid) {
+                        $customerUuid = $maybeUuid;
+                    } else {
+                        $customerTypeNamespace = null;
+                    }
+                }
+
+                if (!$customerUuid) {
+                    $customerTypeNamespace = null;
+                }
             }
 
-            return in_array($waypointMarker->place_uuid, $placeIds);
-        });
+            $values = [
+                'payload_uuid'   => $this->uuid,
+                'place_uuid'     => $placeUuid,
+                'order'          => $index,
+                'type'           => $type,
+                'customer_uuid'  => $customerUuid,
+                'customer_type'  => $customerTypeNamespace,
+            ];
+
+            $existingWaypointMarker = $availableWaypointMarkers
+                ->first(fn ($waypointMarker) => $waypointMarker->place_uuid === $placeUuid && !in_array($waypointMarker->uuid, $keptWaypointIds));
+
+            if ($existingWaypointMarker) {
+                $existingWaypointMarker->update($values);
+                $keptWaypointIds[] = $existingWaypointMarker->uuid;
+                continue;
+            }
 
-        // update or create waypoint markers
-        foreach ($placeIds as $placeId) {
-            Waypoint::updateOrCreate(
-                [
-                    'payload_uuid' => $this->uuid,
-                    'place_uuid'   => $placeId,
-                ],
-                [
-                    'payload_uuid' => $this->uuid,
-                    'place_uuid'   => $placeId,
-                ]
-            );
+            $waypointRecord = Waypoint::create($values);
+            $keptWaypointIds[] = $waypointRecord->uuid;
         }
 
+        $this->waypointMarkers()
+            ->whereNotIn('uuid', $keptWaypointIds)
+            ->get()
+            ->each
+            ->delete();
+
         return $this->refresh()->load(['waypoints']);
     }
 
@@ -673,6 +749,34 @@ class Payload extends Model
         return null;
     }
 
+    /**
+     * Get the lightweight pickup fallback for index resources.
+     */
+    public function getIndexPickupPlaceAttribute(): ?Place
+    {
+        if ($this->pickup instanceof Place) {
+            return $this->pickup;
+        }
+
+        $this->loadMissing('firstWaypointMarker.place');
+
+        return data_get($this, 'firstWaypointMarker.place');
+    }
+
+    /**
+     * Get the lightweight dropoff fallback for index resources.
+     */
+    public function getIndexDropoffPlaceAttribute(): ?Place
+    {
+        if ($this->dropoff instanceof Place) {
+            return $this->dropoff;
+        }
+
+        $this->loadMissing('lastWaypointMarker.place');
+
+        return data_get($this, 'lastWaypointMarker.place');
+    }
+
     public function getPickupRegion(): string
     {
         $pickup = $this->getPickupOrCurrentWaypoint();