@fleetbase/fleetops-engine 0.6.45 → 0.6.46

package/server/src/Models/Order.php

@@ -1732,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;
@@ -1740,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.
      *
@@ -1753,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();

package/server/src/Models/Place.php

@@ -335,24 +335,8 @@ class Place extends Model
 
         // Before saving or returning this instance check the database for a duplicate address
         // it cannot have any owner, and must belong to this session
-        if ($companyUuid = session('company')) {
-            $duplicate = static::where([
-                'company_uuid' => $companyUuid,
-                'street1'      => $instance->street1,
-                'city'         => $instance->city,
-                'country'      => $instance->country,
-            ])
-            ->when(
-                $instance->postal_code !== null,
-                fn ($q) => $q->where('postal_code', $instance->postal_code),
-                fn ($q) => $q->whereNull('postal_code')
-            )
-            ->whereNull('owner_uuid')
-            ->first();
-
-            if ($duplicate) {
-                return $duplicate;
-            }
+        if ($duplicate = static::findExistingSharedPlace($instance->toArray())) {
+            return $duplicate;
         }
 
         if ($saveInstance) {
@@ -400,7 +384,7 @@ class Place extends Model
     /**
      * Create a new Place instance from a geocoding lookup.
      *
-     * @return \Fleetbase\Models\Place|null
+     * @return array
      */
     public static function getValuesFromGeocodingLookup(string $address): array
     {
@@ -413,6 +397,163 @@ class Place extends Model
         return static::getGoogleAddressArray($results->first());
     }
 
+    /**
+     * Compose a fuller geocoding query from structured place attributes.
+     */
+    public static function composeGeocodingQuery(array $place): ?string
+    {
+        $parts = [];
+
+        foreach (['street1', 'street2', 'city', 'province', 'postal_code', 'country'] as $field) {
+            $value = static::normalizePlaceValue(data_get($place, $field));
+            if ($value) {
+                $parts[] = $value;
+            }
+        }
+
+        if (empty($parts)) {
+            return null;
+        }
+
+        return implode(', ', array_values(array_unique($parts)));
+    }
+
+    /**
+     * Normalize a place field value for matching and persistence.
+     */
+    public static function normalizePlaceValue($value): ?string
+    {
+        if (!is_scalar($value)) {
+            return null;
+        }
+
+        $value = trim((string) $value);
+
+        return $value !== '' ? $value : null;
+    }
+
+    /**
+     * Merge explicit structured place attributes with geocoded fallbacks.
+     * Explicit values always win.
+     */
+    public static function mergeStructuredPlaceAttributes(array $place, array $geocoded = []): array
+    {
+        $place = array_merge($geocoded, $place);
+
+        foreach (['name', 'street1', 'street2', 'city', 'province', 'postal_code', 'country', 'phone'] as $field) {
+            $normalized = static::normalizePlaceValue(data_get($place, $field));
+            if ($normalized !== null) {
+                $place[$field] = $normalized;
+            } elseif (array_key_exists($field, $place)) {
+                $place[$field] = null;
+            }
+        }
+
+        if (!empty($place['location'])) {
+            $place['location'] = Utils::getPointFromMixed($place['location']) ?? $place['location'];
+        }
+
+        return array_filter($place, fn ($value) => $value !== '');
+    }
+
+    /**
+     * Find an existing shared place using normalized address identity.
+     */
+    public static function findExistingSharedPlace(array $place): ?Place
+    {
+        if (data_get($place, 'owner_uuid')) {
+            return null;
+        }
+
+        $companyUuid = data_get($place, 'company_uuid', session('company'));
+        $street1     = static::normalizePlaceValue(data_get($place, 'street1'));
+        $city        = static::normalizePlaceValue(data_get($place, 'city'));
+        $country     = static::normalizePlaceValue(data_get($place, 'country'));
+
+        if (!$companyUuid || !$street1 || !$city || !$country) {
+            return null;
+        }
+
+        $postalCode = static::normalizePlaceValue(data_get($place, 'postal_code'));
+        $street2    = static::normalizePlaceValue(data_get($place, 'street2'));
+        $location   = Utils::getPointFromMixed(data_get($place, 'location'));
+
+        $existingPlace = static::query()
+            ->where('company_uuid', $companyUuid)
+            ->whereNull('owner_uuid')
+            ->whereNull('deleted_at')
+            ->where('street1', $street1)
+            ->where('city', $city)
+            ->where('country', $country)
+            ->when(
+                $postalCode !== null,
+                fn ($query) => $query->where('postal_code', $postalCode)
+            )
+            ->when(
+                $postalCode === null,
+                fn ($query) => $query->whereNull('postal_code')
+            )
+            ->when(
+                $street2 !== null,
+                fn ($query) => $query->where('street2', $street2)
+            )
+            ->first();
+
+        if ($existingPlace) {
+            return $existingPlace;
+        }
+
+        if (!$location instanceof SpatialPoint) {
+            return null;
+        }
+
+        return static::query()
+                ->where('company_uuid', $companyUuid)
+                ->whereNull('owner_uuid')
+                ->whereNull('deleted_at')
+                ->where('street1', $street1)
+                ->where('city', $city)
+                ->where('country', $country)
+                ->whereRaw('ST_Equals(location, ST_GeomFromText(?))', [
+                    sprintf('POINT(%s %s)', $location->getLng(), $location->getLat()),
+                ])
+                ->first();
+    }
+
+    /**
+     * Update safe missing fields on an existing shared place.
+     */
+    public static function hydrateSharedPlace(Place $existingPlace, array $values): Place
+    {
+        $updates = [];
+
+        foreach (['name', 'street2', 'province', 'postal_code', 'neighborhood', 'district', 'building', 'phone'] as $field) {
+            $current = static::normalizePlaceValue($existingPlace->{$field});
+            $next    = static::normalizePlaceValue(data_get($values, $field));
+
+            if ($current === null && $next !== null) {
+                $updates[$field] = $next;
+            }
+        }
+
+        $existingLocation = Utils::getPointFromMixed($existingPlace->location);
+        $location         = Utils::getPointFromMixed(data_get($values, 'location'));
+        $hasZeroLocation  = $existingLocation instanceof SpatialPoint
+            && $existingLocation->getLat() == 0.0
+            && $existingLocation->getLng() == 0.0;
+
+        if (($existingLocation === null || $hasZeroLocation) && $location instanceof SpatialPoint) {
+            $updates['location'] = $location;
+        }
+
+        if (!empty($updates)) {
+            $existingPlace->fill($updates);
+            $existingPlace->save();
+        }
+
+        return $existingPlace;
+    }
+
     /**
      * Create a new Place instance from a geocoding lookup.
      *
@@ -571,31 +712,33 @@ class Place extends Model
             }
 
             // Get public_id if supplied if set
-            $id = data_get($place, 'id') || data_get($place, 'public_id');
+            $id = data_get($place, 'id') ?: data_get($place, 'public_id');
 
             // If $place has a valid uuid and a matching Place object exists, return the uuid
             if (Utils::isPublicId($id) && $existingPlace = static::where('public_id', $id)->first()) {
                 return $existingPlace;
             }
 
-            // If has $attributes['address']
-            $address = data_get($place, 'address');
-            if ($address) {
-                return static::create(array_merge($place, static::getValuesFromGeocodingLookup($address)));
+            $query = static::composeGeocodingQuery($place)
+                ?? static::normalizePlaceValue(data_get($place, 'address'))
+                ?? static::normalizePlaceValue(data_get($place, 'street1'));
+
+            $geocoded = [];
+            if ($query) {
+                $geocoded = static::getValuesFromGeocodingLookup($query);
             }
 
-            // Perform google lookup to fill street1
-            $street1 = data_get($place, 'street1');
-            if ($street1) {
-                return static::create(array_merge($place, static::getValuesFromGeocodingLookup($street1)));
+            $values = static::mergeStructuredPlaceAttributes($place, $geocoded);
+
+            if ($existingPlace = static::findExistingSharedPlace($values)) {
+                return static::hydrateSharedPlace($existingPlace, $values);
             }
 
-            // Otherwise, create a new Place owith the given attributes
-            if (empty($place['location'])) {
-                $place['location'] = new SpatialPoint(0, 0);
+            if (empty($values['location'])) {
+                $values['location'] = new SpatialPoint(0, 0);
             }
 
-            return static::create($place);
+            return static::create($values);
         }
         // If $place is a GoogleAddress object
         elseif ($place instanceof \Geocoder\Provider\GoogleMaps\Model\GoogleAddress) {
@@ -655,7 +798,11 @@ class Place extends Model
                 }
             }
 
-            $values = $place;
+            $values = is_array($place) ? $place : (array) $place;
+
+            if ($existingPlace = static::findExistingSharedPlace($values)) {
+                return $existingPlace->uuid;
+            }
 
             // create a new place
             return static::insertGetUuid((array) $values);
@@ -703,21 +850,8 @@ class Place extends Model
             $values['location'] = Utils::parsePointToWkt($values['location']);
         }
 
-        // check if place already exists
-        $existing = DB::table($instance->getTable())
-            ->select(['uuid'])->where([
-                'company_uuid' => session('company'),
-                'name'         => $values['name'] ?? null,
-                'street1'      => $values['street1'] ?? null,
-            ])
-            ->whereNull('deleted_at')
-            ->first();
-
-        if ($existing) {
-            unset($values['uuid'], $values['created_at'], $values['_key'], $values['company_uuid']);
-            static::where('uuid', $existing->uuid)->update($values);
-
-            return $existing->uuid;
+        if ($existing = static::findExistingSharedPlace($values)) {
+            return static::hydrateSharedPlace($existing, $values)->uuid;
         }
 
         if (isset($values['meta']) && (is_object($values['meta']) || is_array($values['meta']))) {

package/server/src/Models/ServiceRate.php

@@ -229,7 +229,7 @@ class ServiceRate extends Model
      */
     public function isAlgorithm(): bool
     {
-        return $this->rate_calculation_method === 'algo';
+        return $this->rate_calculation_method === 'algo' || $this->rate_calculation_method === 'algorithm';
     }
 
     /**
@@ -677,7 +677,7 @@ class ServiceRate extends Model
      *
      * @return array an array containing the calculated quote and line items
      */
-    public function quoteFromPreliminaryData($entities = [], $waypoints = [], ?int $totalDistance = 0, ?int $totalTime = 0, ?bool $isCashOnDelivery = false)
+    public function quoteFromPreliminaryData($entities = [], $waypoints = [], ?int $totalDistance = 0, ?int $totalTime = 0, ?bool $isCashOnDelivery = false, ?int $endpointCount = null)
     {
         $lines    = collect();
         $subTotal = data_get($this, 'base_fee', 0);
@@ -739,6 +739,7 @@ class ServiceRate extends Model
         }
 
         if ($this->isAlgorithm()) {
+            $resolvedEndpointCount = $endpointCount ?? $this->inferEndpointCountFromStops($waypoints);
             $rateFee = $this->normalizeCalculatedMoney(Algo::exec(
                 $this->algorithm,
                 $this->buildAlgorithmVariables(
@@ -746,7 +747,7 @@ class ServiceRate extends Model
                     $waypoints,
                     $totalDistance,
                     $totalTime,
-                    $this->inferEndpointCountFromStops($waypoints)
+                    $resolvedEndpointCount
                 ),
                 true
             ));