@fleetbase/fleetops-engine 0.6.49 → 0.6.50

package/server/src/Models/Contact.php

@@ -3,6 +3,7 @@
 namespace Fleetbase\FleetOps\Models;
 
 use Fleetbase\Casts\Json;
+use Fleetbase\FleetOps\Exceptions\CustomerUserConflictException;
 use Fleetbase\FleetOps\Exceptions\UserAlreadyExistsException;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\Models\CompanyUser;
@@ -319,7 +320,12 @@ class Contact extends Model
         // Check if user already exist with email or phone number
         $existingUser = null;
         if ($contact->email || $contact->phone) {
-            $existingUser = User::where('company_uuid', $contact->company_uuid)
+            $existingUser = User::where(function ($query) use ($contact) {
+                $query->where('company_uuid', $contact->company_uuid)
+                    ->orWhereHas('companyUsers', function ($query) use ($contact) {
+                        $query->where('company_uuid', $contact->company_uuid);
+                    });
+            })
                 ->where(function ($query) use ($contact) {
                     if ($contact->email) {
                         $query->where('email', $contact->email);
@@ -335,15 +341,15 @@ class Contact extends Model
         }
 
         if ($existingUser) {
+            if ($contact->isCustomer()) {
+                $contact->assertCustomerUserCanBeAssigned($existingUser);
+            }
+
             // Check if existing user belongs to another contact
             $existingUserContact = Contact::where(['user_uuid' => $existingUser->uuid, 'company_uuid' => $contact->company_uuid])->whereHas('user')->first();
             if ($existingUserContact) {
                 throw new UserAlreadyExistsException('User already exists, try to assigning the user to this contact.', $existingUser);
             } else {
-                if ($contact->isCustomer()) {
-                    $contact->normalizeCustomerUser($existingUser);
-                }
-
                 // Assign the user to this contact instead
                 $contact->setAttribute('user_uuid', $existingUser->uuid);
                 if ($update) {
@@ -423,13 +429,7 @@ class Contact extends Model
             return null;
         }
 
-        if ($user->type !== 'customer') {
-            if ($quiet) {
-                $user->forceFill(['type' => 'customer'])->saveQuietly();
-            } else {
-                $user->setType('customer');
-            }
-        }
+        $this->assertCustomerUserCanBeAssigned($user);
 
         $this->loadMissing('company');
         if ($this->company) {
@@ -463,7 +463,7 @@ class Contact extends Model
     public function repairCustomerTypeInvariant(bool $quiet = false): ?User
     {
         if (!$this->isCustomer()) {
-            $this->forceFill(['type' => 'customer'])->saveQuietly();
+            return $this->getUser();
         }
 
         $user = $this->getUser();
@@ -512,8 +512,17 @@ class Contact extends Model
         // Load company
         $this->loadMissing('company');
 
-        if ($this->isCustomer() && $user->type !== 'customer') {
-            $user->setType('customer');
+        if ($this->isCustomer()) {
+            $this->assertCustomerUserCanBeAssigned($user);
+
+            $existingUserContact = static::where(['user_uuid' => $user->uuid, 'company_uuid' => $this->company_uuid])
+                ->whereNot('uuid', $this->uuid)
+                ->whereHas('user')
+                ->first();
+
+            if ($existingUserContact) {
+                throw new UserAlreadyExistsException('User already exists, try to assigning the user to this contact.', $user);
+            }
         }
 
         // Assing to company
@@ -551,6 +560,74 @@ class Contact extends Model
         return $this;
     }
 
+    public function assertCustomerIdentityIsAvailable(): void
+    {
+        if (!$this->isCustomer()) {
+            return;
+        }
+
+        $assignedUser = $this->getAssignedUserWithoutTypeScope();
+        if ($assignedUser) {
+            $this->assertCustomerUserCanBeAssigned($assignedUser);
+        }
+
+        $matchedUser = $this->findExistingUserByIdentity();
+        if ($matchedUser && $matchedUser->uuid !== $this->user_uuid) {
+            $this->assertCustomerUserCanBeAssigned($matchedUser);
+        }
+    }
+
+    public function assertCustomerUserCanBeAssigned(User $user): void
+    {
+        if ($user->type === 'customer') {
+            return;
+        }
+
+        throw new CustomerUserConflictException(static::customerUserConflictMessage($user), $user);
+    }
+
+    public static function customerUserConflictMessage(?User $user = null): string
+    {
+        $field = $user?->email ? 'email' : ($user?->phone ? 'phone number' : 'user account');
+
+        return 'This ' . $field . ' belongs to an existing staff user and cannot be used for a customer account.';
+    }
+
+    private function findExistingUserByIdentity(): ?User
+    {
+        if (!$this->email && !$this->phone) {
+            return null;
+        }
+
+        return User::where(function ($query) {
+            $query->where('company_uuid', $this->company_uuid)
+                ->orWhereHas('companyUsers', function ($query) {
+                    $query->where('company_uuid', $this->company_uuid);
+                });
+        })
+            ->where(function ($query) {
+                if ($this->email) {
+                    $query->where('email', $this->email);
+                }
+
+                if ($this->phone) {
+                    $method = $this->email ? 'orWhere' : 'where';
+                    $query->{$method}('phone', Utils::formatPhoneNumber($this->phone));
+                }
+            })
+            ->whereNull('deleted_at')
+            ->first();
+    }
+
+    private function getAssignedUserWithoutTypeScope(): ?User
+    {
+        if (!Str::isUuid($this->user_uuid)) {
+            return null;
+        }
+
+        return User::where('uuid', $this->user_uuid)->first();
+    }
+
     public function syncWithUser(): bool
     {
         $updates = [];

package/server/src/Models/Customer.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace Fleetbase\FleetOps\Models;
+
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Support\Str;
+
+/**
+ * Fleet-Ops customer.
+ *
+ * A thin specialization of {@see Contact} that is scoped to rows with
+ * `type='customer'` and forces that type on create. This is what the public
+ * customer API surface (`/v1/customers/...`) operates on.
+ *
+ * Mirrors {@see \Fleetbase\Storefront\Models\Customer} but lives directly in
+ * FleetOps so that customer auth + customer-scoped orders work without the
+ * Storefront publishable-key + Store/Network gating.
+ */
+class Customer extends Contact
+{
+    /**
+     * The key to use in the payload responses.
+     */
+    protected string $payloadKey = 'customer';
+
+    /**
+     * Boot the model.
+     */
+    protected static function boot()
+    {
+        parent::boot();
+
+        static::creating(function ($model) {
+            $model->type = 'customer';
+        });
+
+        static::addGlobalScope('type', function (Builder $builder) {
+            $builder->where('type', 'customer');
+        });
+    }
+
+    /**
+     * Orders owned by this customer.
+     */
+    public function orders(): HasMany
+    {
+        return $this->hasMany(Order::class, 'customer_uuid')
+            ->whereNull('deleted_at')
+            ->withoutGlobalScopes();
+    }
+
+    /**
+     * Find a customer by either a `customer_xxx` or `contact_xxx` public id.
+     */
+    public static function findFromCustomerId(string $publicId): ?self
+    {
+        if (Str::startsWith($publicId, 'customer')) {
+            $publicId = Str::replaceFirst('customer', 'contact', $publicId);
+        }
+
+        return static::where('public_id', $publicId)->first();
+    }
+}

package/server/src/Models/Driver.php

@@ -119,6 +119,15 @@ class Driver extends Model
         'time_window_end',
     ];
 
+    /**
+     * Set attributes and defaults.
+     *
+     * @var array
+     */
+    protected $attributes = [
+        'status' => 'available',
+    ];
+
     /**
      * The attributes that are guarded and not mass assignable.
      *
@@ -595,9 +604,9 @@ class Driver extends Model
     /**
      * Set the driver status attribute.
      */
-    public function setStatusAttribute(?string $status = 'active'): void
+    public function setStatusAttribute(?string $status = 'available'): void
     {
-        $this->attributes['status'] = $status;
+        $this->attributes['status'] = $status === null || $status === 'active' ? 'available' : $status;
     }
 
     /**
@@ -854,7 +863,7 @@ class Driver extends Model
             'user_uuid'              => $user->uuid,
             'drivers_license_number' => $driversLicenseNumber,
             'country'                => $country,
-            'status'                 => 'active',
+            'status'                 => 'available',
             'location'               => Utils::parsePointToWkt(new Point(0, 0)),
         ]);
 

package/server/src/Models/Entity.php

@@ -2,9 +2,9 @@
 
 namespace Fleetbase\FleetOps\Models;
 
-use Barryvdh\DomPDF\Facade\Pdf;
 use Fleetbase\Casts\Json;
 use Fleetbase\Casts\PolymorphicType;
+use Fleetbase\FleetOps\Support\LabelPdf;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\FleetOps\Traits\HasTrackingNumber;
 use Fleetbase\FleetOps\Traits\PayloadAccessors;
@@ -142,7 +142,7 @@ class Entity extends Model
      */
     public function pdfLabel()
     {
-        return Pdf::loadHTML($this->label());
+        return LabelPdf::fromHtml($this->label());
     }
 
     /**

package/server/src/Models/Order.php

@@ -2,7 +2,6 @@
 
 namespace Fleetbase\FleetOps\Models;
 
-use Barryvdh\DomPDF\Facade\Pdf;
 use Fleetbase\Casts\Json;
 use Fleetbase\Casts\PolymorphicType;
 use Fleetbase\FleetOps\Events\OrderCanceled;
@@ -10,6 +9,7 @@ use Fleetbase\FleetOps\Events\OrderCompleted;
 use Fleetbase\FleetOps\Events\OrderDispatched;
 use Fleetbase\FleetOps\Events\OrderDriverAssigned;
 use Fleetbase\FleetOps\Flow\Activity;
+use Fleetbase\FleetOps\Support\LabelPdf;
 use Fleetbase\FleetOps\Support\OrderTracker;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\FleetOps\Traits\HasTrackingNumber;
@@ -275,7 +275,32 @@ class Order extends Model
      */
     public function pdfLabel()
     {
-        return Pdf::loadHTML($this->label());
+        return LabelPdf::fromHtml($this->label());
+    }
+
+    public function attachFiles($uploads): self
+    {
+        $ids = collect($uploads)
+            ->map(function ($upload) {
+                if (is_string($upload)) {
+                    return $upload;
+                }
+
+                return data_get($upload, 'uuid') ?? data_get($upload, 'id');
+            })
+            ->filter()
+            ->unique()
+            ->values();
+
+        if ($ids->isEmpty()) {
+            return $this;
+        }
+
+        \Fleetbase\Models\File::whereIn('uuid', $ids)->get()->each(function ($file) {
+            $file->setKey($this);
+        });
+
+        return $this;
     }
 
     /**
@@ -1991,11 +2016,11 @@ class Order extends Model
             return collect();
         }
 
-        $drivers = Driver::where(['status' => 'active', 'online' => 1])
+        $drivers = Driver::where(['status' => 'available', 'online' => 1])
             ->whereHas('company', function ($q) {
                 $q->whereHas('users', function ($q) {
                     $q->whereHas('driver', function ($q) {
-                        $q->where(['status' => 'active', 'online' => 1]);
+                        $q->where(['status' => 'available', 'online' => 1]);
                         $q->whereNull('deleted_at');
                     });
                 });

package/server/src/Models/Payload.php

@@ -61,7 +61,23 @@ class Payload extends Model
      *
      * @var array
      */
-    protected $fillable = ['_key', 'company_uuid', 'pickup_uuid', 'dropoff_uuid', 'return_uuid', 'current_waypoint_uuid', 'meta', 'payment_method', 'cod_amount', 'cod_currency', 'cod_payment_method', 'type'];
+    protected $fillable = [
+        '_key',
+        'company_uuid',
+        'pickup_uuid',
+        'pickup_tracking_number_uuid',
+        'dropoff_uuid',
+        'dropoff_tracking_number_uuid',
+        'return_uuid',
+        'return_tracking_number_uuid',
+        'current_waypoint_uuid',
+        'meta',
+        'payment_method',
+        'cod_amount',
+        'cod_currency',
+        'cod_payment_method',
+        'type',
+    ];
 
     /**
      * The attributes that should be cast to native types.

package/server/src/Models/ServiceRate.php

@@ -216,6 +216,14 @@ class ServiceRate extends Model
         return $this->rate_calculation_method === 'per_meter';
     }
 
+    /**
+     * Check if the rate calculation method is "multi_zone_distance".
+     */
+    public function isMultiZoneDistance(): bool
+    {
+        return $this->rate_calculation_method === 'multi_zone_distance';
+    }
+
     /**
      * Check if the rate calculation method is "per_drop".
      */
@@ -329,6 +337,16 @@ class ServiceRate extends Model
             return $this;
         }
 
+        $serviceRateFees = collect($serviceRateFees)
+            ->map(fn ($fee) => $this->normalizeServiceRateFeePayload($fee))
+            ->filter()
+            ->values()
+            ->toArray();
+
+        if (!$serviceRateFees) {
+            return $this;
+        }
+
         $iterate = count($serviceRateFees);
 
         for ($i = 0; $i < $iterate; $i++) {
@@ -356,6 +374,43 @@ class ServiceRate extends Model
         return $this;
     }
 
+    /**
+     * Normalize embedded service-rate fee payloads before persistence.
+     */
+    public function normalizeServiceRateFeePayload($fee): ?array
+    {
+        if (!is_array($fee)) {
+            return null;
+        }
+
+        $fee['service_area_uuid'] ??= data_get($fee, 'service_area.uuid');
+        $fee['zone_uuid'] ??= data_get($fee, 'zone.uuid');
+
+        if (Utils::castBoolean($fee['is_fallback'] ?? false)) {
+            $fee['service_area_uuid'] = null;
+            $fee['zone_uuid']         = null;
+        }
+
+        return collect($fee)
+            ->only([
+                'uuid',
+                'service_rate_uuid',
+                'service_area_uuid',
+                'zone_uuid',
+                'label',
+                'priority',
+                'is_fallback',
+                'distance',
+                'distance_unit',
+                'min',
+                'max',
+                'unit',
+                'fee',
+                'currency',
+            ])
+            ->toArray();
+    }
+
     /**
      * Set the service rate parcel fees for the current object.
      *
@@ -506,7 +561,7 @@ class ServiceRate extends Model
     public static function getServicableForPlaces($places = [], $service = null, $currency = null, ?\Closure $queryCallback = null): array
     {
         $reader            = new GeoJSONReader();
-        $serviceRatesQuery = static::with(['zone', 'serviceArea', 'rateFees', 'parcelFees']);
+        $serviceRatesQuery = static::with(['zone', 'serviceArea', 'rateFees.zone', 'rateFees.serviceArea', 'parcelFees']);
 
         if ($currency) {
             $serviceRatesQuery->whereRaw('lower(currency) = ?', [strtolower($currency)]);
@@ -738,6 +793,12 @@ class ServiceRate extends Model
             ]);
         }
 
+        if ($this->isMultiZoneDistance()) {
+            [$multiZoneFee, $multiZoneLines] = $this->quoteMultiZoneDistance($waypoints, $totalDistance);
+            $subTotal += $multiZoneFee;
+            $lines = $lines->merge($multiZoneLines);
+        }
+
         if ($this->isAlgorithm()) {
             $resolvedEndpointCount = $endpointCount ?? $this->inferEndpointCountFromStops($waypoints);
             $rateFee               = $this->normalizeCalculatedMoney(Algo::exec(
@@ -927,6 +988,12 @@ class ServiceRate extends Model
             ]);
         }
 
+        if ($this->isMultiZoneDistance()) {
+            [$multiZoneFee, $multiZoneLines] = $this->quoteMultiZoneDistance($waypoints, $totalDistance);
+            $subTotal += $multiZoneFee;
+            $lines = $lines->merge($multiZoneLines);
+        }
+
         if ($this->isAlgorithm()) {
             $rateFee = $this->normalizeCalculatedMoney(Algo::exec(
                 $this->algorithm,
@@ -1086,6 +1153,211 @@ class ServiceRate extends Model
         return 2;
     }
 
+    protected function quoteMultiZoneDistance($waypoints = [], ?int $totalDistance = 0): array
+    {
+        $this->loadMissing(['rateFees.zone', 'rateFees.serviceArea']);
+
+        $rules = $this->rateFees
+            ->filter(fn ($rule) => !$rule->is_fallback && ($rule->zone || $rule->serviceArea))
+            ->sortByDesc(fn ($rule) => (int) ($rule->priority ?? 0))
+            ->values();
+
+        $fallbackRule = $this->rateFees
+            ->filter(fn ($rule) => (bool) $rule->is_fallback)
+            ->sortByDesc(fn ($rule) => (int) ($rule->priority ?? 0))
+            ->first();
+
+        if ($rules->isEmpty() && !$fallbackRule) {
+            return [0, collect()];
+        }
+
+        $pricedDistances = $this->calculateMultiZoneDistances($waypoints, $rules, $fallbackRule, $totalDistance);
+        $lines           = collect();
+        $subTotal        = 0;
+
+        foreach ($pricedDistances as $entry) {
+            $rule = $entry['rule'];
+            if (!$rule instanceof ServiceRateFee) {
+                continue;
+            }
+
+            $distanceInMeters = (float) ($entry['distance_m'] ?? 0);
+            if ($distanceInMeters <= 0) {
+                continue;
+            }
+
+            $unit     = strtolower($rule->distance_unit ?: 'km');
+            $distance = $this->normalizeDistanceForUnit($distanceInMeters, $unit);
+            $fee      = $this->normalizeCalculatedMoney($distance * Utils::numbersOnly($rule->fee ?? 0));
+            $subTotal += $fee;
+
+            if ($rule->is_fallback) {
+                $label = 'Out-of-zone distance charge';
+            } else {
+                $label = data_get($rule, 'zone.name') ?: data_get($rule, 'serviceArea.name') ?: $rule->label ?: 'Geographic';
+            }
+
+            if (!$rule->is_fallback && !str_ends_with(strtolower($label), 'distance charge')) {
+                $label .= ' distance charge';
+            }
+
+            $lines->push([
+                'details'          => sprintf('%s (%s %s x %s)', $label, round($distance, 2), $unit, Utils::moneyFormat($rule->fee, $this->currency)),
+                'amount'           => $fee,
+                'formatted_amount' => Utils::moneyFormat($fee, $this->currency),
+                'currency'         => $this->currency,
+                'code'             => 'MULTI_ZONE_DISTANCE_FEE',
+            ]);
+        }
+
+        return [$subTotal, $lines];
+    }
+
+    protected function calculateMultiZoneDistances($waypoints, $rules, ?ServiceRateFee $fallbackRule = null, ?int $totalDistance = 0): array
+    {
+        $places = collect($waypoints)->map(fn ($place) => Place::createFromMixed($place))->filter()->values();
+
+        if ($places->count() < 2 || (int) $totalDistance <= 0) {
+            return $fallbackRule ? [['rule' => $fallbackRule, 'distance_m' => (float) ($totalDistance ?? 0)]] : [];
+        }
+
+        $reader         = new GeoJSONReader();
+        $ruleGeometries = $rules->map(function ($rule) use ($reader) {
+            return [
+                'rule'      => $rule,
+                'geometry'  => $this->readRateRuleGeometry($rule, $reader),
+            ];
+        })->filter(fn ($entry) => $entry['geometry'])->values();
+
+        if ($ruleGeometries->isEmpty()) {
+            return $fallbackRule ? [['rule' => $fallbackRule, 'distance_m' => (float) $totalDistance]] : [];
+        }
+
+        $distances    = [];
+        $sampledTotal = 0;
+
+        for ($i = 0; $i < $places->count() - 1; $i++) {
+            $start = $this->getLngLatFromPlace($places[$i]);
+            $end   = $this->getLngLatFromPlace($places[$i + 1]);
+
+            if (!$start || !$end) {
+                continue;
+            }
+
+            $legDistance = $this->haversineDistanceInMeters($start['lat'], $start['lng'], $end['lat'], $end['lng']);
+            $steps       = max(1, min(500, (int) ceil($legDistance / 1000)));
+
+            for ($step = 0; $step < $steps; $step++) {
+                $fromRatio = $step / $steps;
+                $toRatio   = ($step + 1) / $steps;
+                $midRatio  = ($fromRatio + $toRatio) / 2;
+
+                $from = $this->interpolateLngLat($start, $end, $fromRatio);
+                $to   = $this->interpolateLngLat($start, $end, $toRatio);
+                $mid  = $this->interpolateLngLat($start, $end, $midRatio);
+
+                $sampleDistance = $this->haversineDistanceInMeters($from['lat'], $from['lng'], $to['lat'], $to['lng']);
+                $sampledTotal += $sampleDistance;
+
+                $matchedRule = $this->matchMultiZoneRule($mid, $ruleGeometries) ?: $fallbackRule;
+                if (!$matchedRule instanceof ServiceRateFee) {
+                    continue;
+                }
+
+                $key = $matchedRule->uuid ?? spl_object_hash($matchedRule);
+                if (!isset($distances[$key])) {
+                    $distances[$key] = ['rule' => $matchedRule, 'distance_m' => 0];
+                }
+
+                $distances[$key]['distance_m'] += $sampleDistance;
+            }
+        }
+
+        if ($sampledTotal > 0 && $totalDistance > 0) {
+            $scale = $totalDistance / $sampledTotal;
+            foreach ($distances as &$entry) {
+                $entry['distance_m'] *= $scale;
+            }
+            unset($entry);
+        }
+
+        return array_values($distances);
+    }
+
+    protected function readRateRuleGeometry(ServiceRateFee $rule, GeoJSONReader $reader)
+    {
+        $border = data_get($rule, 'zone.border') ?: data_get($rule, 'serviceArea.border');
+
+        if (!$border) {
+            return null;
+        }
+
+        try {
+            if (is_object($border) && method_exists($border, 'toJson')) {
+                return $reader->read($border->toJson());
+            }
+
+            if (is_array($border) || is_object($border)) {
+                return $reader->read(json_encode($border, JSON_UNESCAPED_UNICODE));
+            }
+
+            if (is_string($border)) {
+                return $reader->read($border);
+            }
+        } catch (\Throwable $e) {
+            return null;
+        }
+
+        return null;
+    }
+
+    protected function matchMultiZoneRule(array $point, $ruleGeometries): ?ServiceRateFee
+    {
+        $brickPoint = \Brick\Geo\Point::fromText(sprintf('POINT (%F %F)', $point['lng'], $point['lat']), 4326);
+
+        foreach ($ruleGeometries as $entry) {
+            if ($entry['geometry']->contains($brickPoint)) {
+                return $entry['rule'];
+            }
+        }
+
+        return null;
+    }
+
+    protected function getLngLatFromPlace(?Place $place): ?array
+    {
+        if (!$place instanceof Place) {
+            return null;
+        }
+
+        $point = $place->getLocationAsPoint();
+
+        if (!$point || !method_exists($point, 'getLat') || !method_exists($point, 'getLng')) {
+            return null;
+        }
+
+        return ['lat' => (float) $point->getLat(), 'lng' => (float) $point->getLng()];
+    }
+
+    protected function interpolateLngLat(array $start, array $end, float $ratio): array
+    {
+        return [
+            'lat' => $start['lat'] + (($end['lat'] - $start['lat']) * $ratio),
+            'lng' => $start['lng'] + (($end['lng'] - $start['lng']) * $ratio),
+        ];
+    }
+
+    protected function haversineDistanceInMeters(float $lat1, float $lng1, float $lat2, float $lng2): float
+    {
+        $earthRadius = 6371000;
+        $latDelta    = deg2rad($lat2 - $lat1);
+        $lngDelta    = deg2rad($lng2 - $lng1);
+
+        $a = sin($latDelta / 2) ** 2 + cos(deg2rad($lat1)) * cos(deg2rad($lat2)) * sin($lngDelta / 2) ** 2;
+
+        return $earthRadius * 2 * atan2(sqrt($a), sqrt(1 - $a));
+    }
+
     /**
      * Find the ServiceRateFee based on the total distance.
      *