@fleetbase/fleetops-engine 0.6.44 → 0.6.46

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';
     }
 
     /**
@@ -369,11 +369,37 @@ class ServiceRate extends Model
             return $this;
         }
 
+        // Normalize duplicate parcel rows by fee shape and keep the latest submitted value.
+        $serviceRateParcelFees = collect($serviceRateParcelFees)
+            ->filter(fn ($fee) => is_array($fee))
+            ->map(function ($fee) {
+                return collect($fee)->except(['created_at', 'updated_at'])->toArray();
+            })
+            ->keyBy(function ($fee) {
+                return implode(':', [
+                    data_get($fee, 'size'),
+                    data_get($fee, 'length'),
+                    data_get($fee, 'width'),
+                    data_get($fee, 'height'),
+                    data_get($fee, 'dimensions_unit'),
+                    data_get($fee, 'weight'),
+                    data_get($fee, 'weight_unit'),
+                ]);
+            })
+            ->values()
+            ->toArray();
+
+        $submittedUuids = collect($serviceRateParcelFees)
+            ->pluck('uuid')
+            ->filter()
+            ->values()
+            ->all();
+
         $iterate = count($serviceRateParcelFees);
 
         for ($i = 0; $i < $iterate; $i++) {
             // if already has uuid then we just update the record and remove from insert array
-            if (isset($serviceRateParcelFees[$i]['uuid'])) {
+            if (!empty($serviceRateParcelFees[$i]['uuid'])) {
                 $id                   = $serviceRateParcelFees[$i]['uuid'];
                 $updateableAttributes = collect($serviceRateParcelFees[$i])->except(['uuid', 'created_at', 'updated_at'])->toArray();
 
@@ -391,7 +417,18 @@ class ServiceRate extends Model
         }
 
         $serviceRateParcelFees = collect($serviceRateParcelFees)->filter()->values()->toArray();
-        ServiceRateParcelFee::bulkInsert($serviceRateParcelFees);
+
+        $existingParcelFeesQuery = ServiceRateParcelFee::where('service_rate_uuid', $this->uuid);
+
+        if (!empty($submittedUuids)) {
+            $existingParcelFeesQuery->whereNotIn('uuid', $submittedUuids)->delete();
+        } else {
+            $existingParcelFeesQuery->delete();
+        }
+
+        if (!empty($serviceRateParcelFees)) {
+            ServiceRateParcelFee::bulkInsert($serviceRateParcelFees);
+        }
 
         return $this;
     }
@@ -640,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);
@@ -688,13 +725,13 @@ class ServiceRate extends Model
         }
 
         if ($this->isPerMeter()) {
-            $perMeterDistance = $this->per_meter_unit === 'km' ? round($totalDistance / 1000) : $totalDistance;
-            $rateFee          = $perMeterDistance * $this->per_meter_flat_rate_fee;
+            $perMeterDistance = $this->normalizeDistanceForUnit($totalDistance, $this->per_meter_unit);
+            $rateFee          = $this->normalizeCalculatedMoney($perMeterDistance * $this->per_meter_flat_rate_fee);
             $subTotal += $rateFee;
 
             $lines->push([
                 'details'          => 'Service Fee',
-                'amount'           => Utils::numbersOnly($rateFee),
+                'amount'           => $rateFee,
                 'formatted_amount' => Utils::moneyFormat($rateFee, $this->currency),
                 'currency'         => $this->currency,
                 'code'             => 'BASE_FEE',
@@ -702,20 +739,24 @@ class ServiceRate extends Model
         }
 
         if ($this->isAlgorithm()) {
-            $rateFee = Algo::exec(
+            $resolvedEndpointCount = $endpointCount ?? $this->inferEndpointCountFromStops($waypoints);
+            $rateFee = $this->normalizeCalculatedMoney(Algo::exec(
                 $this->algorithm,
-                [
-                    'distance' => $totalDistance,
-                    'time'     => $totalTime,
-                ],
+                $this->buildAlgorithmVariables(
+                    $entities,
+                    $waypoints,
+                    $totalDistance,
+                    $totalTime,
+                    $resolvedEndpointCount
+                ),
                 true
-            );
+            ));
 
-            $subTotal += Utils::numbersOnly($rateFee);
+            $subTotal += $rateFee;
 
             $lines->push([
                 'details'          => 'Service Fee',
-                'amount'           => Utils::numbersOnly($rateFee),
+                'amount'           => $rateFee,
                 'formatted_amount' => Utils::moneyFormat($rateFee, $this->currency),
                 'currency'         => $this->currency,
                 'code'             => 'BASE_FEE',
@@ -758,9 +799,10 @@ class ServiceRate extends Model
                 }
 
                 $subTotal += $serviceParcelFee->fee;
+                $parcelFeeName = ucwords(str_replace(['_', '-'], ' ', data_get($serviceParcelFee, 'size', 'parcel')));
 
                 $lines->push([
-                    'details'          => $serviceParcelFee->name . ' parcel fee',
+                    'details'          => $parcelFeeName . ' parcel fee',
                     'amount'           => Utils::numbersOnly($serviceParcelFee->fee),
                     'formatted_amount' => Utils::moneyFormat($serviceParcelFee->fee, $this->currency),
                     'currency'         => $this->currency,
@@ -777,7 +819,7 @@ class ServiceRate extends Model
             if ($this->hasCodFlatFee()) {
                 $subTotal += $codFee = $this->cod_flat_fee;
             } elseif ($this->hasCodPercentageFee()) {
-                $subTotal += $codFee = Utils::calculatePercentage($this->cod_percent, $baseRate);
+                $subTotal += $codFee = $this->normalizeCalculatedMoney(Utils::calculatePercentage($this->cod_percent, $baseRate));
             }
 
             $lines->push([
@@ -794,7 +836,7 @@ class ServiceRate extends Model
             if ($this->hasPeakHoursFlatFee()) {
                 $subTotal += $peakHoursFee = $this->peak_hours_flat_fee;
             } elseif ($this->hasPeakHoursPercentageFee()) {
-                $subTotal += $peakHoursFee = Utils::calculatePercentage($this->peak_hours_percent, $baseRate);
+                $subTotal += $peakHoursFee = $this->normalizeCalculatedMoney(Utils::calculatePercentage($this->peak_hours_percent, $baseRate));
             }
 
             $lines->push([
@@ -872,13 +914,13 @@ class ServiceRate extends Model
         }
 
         if ($this->isPerMeter()) {
-            $perMeterDistance = $this->per_meter_unit === 'km' ? round($totalDistance / 1000) : $totalDistance;
-            $rateFee          = $perMeterDistance * $this->per_meter_flat_rate_fee;
+            $perMeterDistance = $this->normalizeDistanceForUnit($totalDistance, $this->per_meter_unit);
+            $rateFee          = $this->normalizeCalculatedMoney($perMeterDistance * $this->per_meter_flat_rate_fee);
             $subTotal += $rateFee;
 
             $lines->push([
                 'details'          => 'Service Fee',
-                'amount'           => Utils::numbersOnly($rateFee),
+                'amount'           => $rateFee,
                 'formatted_amount' => Utils::moneyFormat($rateFee, $this->currency),
                 'currency'         => $this->currency,
                 'code'             => 'BASE_FEE',
@@ -886,20 +928,23 @@ class ServiceRate extends Model
         }
 
         if ($this->isAlgorithm()) {
-            $rateFee = Algo::exec(
+            $rateFee = $this->normalizeCalculatedMoney(Algo::exec(
                 $this->algorithm,
-                [
-                    'distance' => $totalDistance,
-                    'time'     => $totalTime,
-                ],
+                $this->buildAlgorithmVariables(
+                    $payload->entities->all(),
+                    $waypoints->all(),
+                    $totalDistance,
+                    $totalTime,
+                    (int) ($payload->pickup ? 1 : 0) + (int) ($payload->dropoff ? 1 : 0)
+                ),
                 true
-            );
+            ));
 
-            $subTotal += Utils::numbersOnly($rateFee);
+            $subTotal += $rateFee;
 
             $lines->push([
                 'details'          => 'Service Fee',
-                'amount'           => Utils::numbersOnly($rateFee),
+                'amount'           => $rateFee,
                 'formatted_amount' => Utils::moneyFormat($rateFee, $this->currency),
                 'currency'         => $this->currency,
                 'code'             => 'BASE_FEE',
@@ -942,9 +987,10 @@ class ServiceRate extends Model
                 }
 
                 $subTotal += $serviceParcelFee->fee;
+                $parcelFeeName = ucwords(str_replace(['_', '-'], ' ', data_get($serviceParcelFee, 'size', 'parcel')));
 
                 $lines->push([
-                    'details'          => $serviceParcelFee->name . ' parcel fee',
+                    'details'          => $parcelFeeName . ' parcel fee',
                     'amount'           => Utils::numbersOnly($serviceParcelFee->fee),
                     'formatted_amount' => Utils::moneyFormat($serviceParcelFee->fee, $this->currency),
                     'currency'         => $this->currency,
@@ -961,7 +1007,7 @@ class ServiceRate extends Model
             if ($this->hasCodFlatFee()) {
                 $subTotal += $codFee = $this->cod_flat_fee;
             } elseif ($this->hasCodPercentageFee()) {
-                $subTotal += $codFee = Utils::calculatePercentage($this->cod_percent, $baseRate);
+                $subTotal += $codFee = $this->normalizeCalculatedMoney(Utils::calculatePercentage($this->cod_percent, $baseRate));
             }
 
             $lines->push([
@@ -978,7 +1024,7 @@ class ServiceRate extends Model
             if ($this->hasPeakHoursFlatFee()) {
                 $subTotal += $peakHoursFee = $this->peak_hours_flat_fee;
             } elseif ($this->hasPeakHoursPercentageFee()) {
-                $subTotal += $peakHoursFee = Utils::calculatePercentage($this->peak_hours_percent, $baseRate);
+                $subTotal += $peakHoursFee = $this->normalizeCalculatedMoney(Utils::calculatePercentage($this->peak_hours_percent, $baseRate));
             }
 
             $lines->push([
@@ -993,6 +1039,53 @@ class ServiceRate extends Model
         return [$subTotal, $lines];
     }
 
+    protected function normalizeDistanceForUnit(?int $distanceInMeters = 0, ?string $unit = 'm'): float|int
+    {
+        $distanceInMeters = (float) ($distanceInMeters ?? 0);
+
+        return match ($unit) {
+            'km'    => $distanceInMeters / 1000,
+            'ft'    => $distanceInMeters / 0.3048,
+            'yd'    => $distanceInMeters / 0.9144,
+            'mi'    => $distanceInMeters / 1609.344,
+            default => $distanceInMeters,
+        };
+    }
+
+    protected function normalizeCalculatedMoney($amount = 0): int
+    {
+        return (int) round((float) ($amount ?? 0));
+    }
+
+    protected function buildAlgorithmVariables($entities = [], $stops = [], ?int $totalDistance = 0, ?int $totalTime = 0, int $endpointCount = 0): array
+    {
+        $entityCollection = collect($entities)->filter();
+        $stopCount        = collect($stops)->filter()->count();
+        $endpointCount    = max(0, min($endpointCount, $stopCount));
+        $waypointCount    = max($stopCount - $endpointCount, 0);
+
+        return Algo::normalizeVariables([
+            'distance_m' => $totalDistance ?? 0,
+            'time_s'     => $totalTime ?? 0,
+            'stops'      => $stopCount,
+            'waypoints'  => $waypointCount,
+            'parcels'    => $entityCollection->where('type', 'parcel')->count(),
+            'entities'   => $entityCollection->count(),
+            'base_fee'   => Utils::numbersOnly($this->base_fee ?? 0),
+        ]);
+    }
+
+    protected function inferEndpointCountFromStops($stops = []): int
+    {
+        $stopCount = collect($stops)->filter()->count();
+
+        if ($stopCount <= 1) {
+            return $stopCount;
+        }
+
+        return 2;
+    }
+
     /**
      * Find the ServiceRateFee based on the total distance.
      *

package/server/src/Observers/PurchaseRateObserver.php

@@ -2,7 +2,6 @@
 
 namespace Fleetbase\FleetOps\Observers;
 
-use Fleetbase\FleetOps\Models\Order;
 use Fleetbase\FleetOps\Models\PurchaseRate;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\Models\Company;
@@ -25,7 +24,8 @@ class PurchaseRateObserver
         $company = Company::where('uuid', session('company', $purchaseRate->company_uuid))->first();
 
         // get currency to use
-        $currency = data_get($purchaseRate, 'serviceQuote.currency', $company->country ? Utils::getCurrenyFromCountryCode($company->country) : 'SGD');
+        $currency = data_get($purchaseRate, 'serviceQuote.currency')
+            ?: Utils::getCompanyTransactionCurrency($company ?? $purchaseRate->company_uuid);
 
         // create transaction and transaction items
         $transaction = Transaction::create([
@@ -41,9 +41,6 @@ class PurchaseRateObserver
             'status'                 => 'success',
         ]);
 
-        // Update order with transaction id
-        Order::where('payload_uuid', $purchaseRate->payload_uuid)->update(['transaction_uuid' => $transaction->uuid]);
-
         if (isset($purchaseRate->serviceQuote)) {
             $purchaseRate->serviceQuote->items->each(function ($serviceQuoteItem) use ($transaction, $currency) {
                 TransactionItem::create([
@@ -57,5 +54,6 @@ class PurchaseRateObserver
         }
 
         $purchaseRate->transaction_uuid = $transaction->uuid;
+        $purchaseRate->status           = $purchaseRate->status ?: Transaction::STATUS_SUCCESS;
     }
 }