@fleetbase/fleetops-engine 0.6.71 → 0.6.72

package/server/src/Models/Payload.php

@@ -12,11 +12,16 @@ use Fleetbase\FleetOps\Http\Resources\v1\Payload as PayloadResource;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\LaravelMysqlSpatial\Types\Point;
 use Fleetbase\Models\Model;
+use Fleetbase\Support\ApiModelCache;
 use Fleetbase\Traits\HasApiModelBehavior;
 use Fleetbase\Traits\HasMetaAttributes;
 use Fleetbase\Traits\HasPublicId;
 use Fleetbase\Traits\HasUuid;
 use Fleetbase\Traits\TracksApiCredential;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\HasManyThrough;
+use Illuminate\Support\Arr;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Str;
 
@@ -140,7 +145,7 @@ class Payload extends Model
     /**
      * Entities in the payload.
      */
-    public function entities()
+    public function entities(): HasMany
     {
         return $this->hasMany(Entity::class);
     }
@@ -194,7 +199,7 @@ class Payload extends Model
     /**
      * The address the shipment will be delivered to.
      */
-    public function dropoff()
+    public function dropoff(): BelongsTo
     {
         return $this->belongsTo(Place::class, 'dropoff_uuid')->whereNull('deleted_at')->withoutGlobalScopes();
     }
@@ -202,7 +207,7 @@ class Payload extends Model
     /**
      * The address the shipment will be delivered from.
      */
-    public function pickup()
+    public function pickup(): BelongsTo
     {
         return $this->belongsTo(Place::class, 'pickup_uuid')->whereNull('deleted_at')->withoutGlobalScopes();
     }
@@ -210,7 +215,7 @@ class Payload extends Model
     /**
      * The address the shipment will be sent to upon failed delivery.
      */
-    public function return()
+    public function return(): BelongsTo
     {
         return $this->belongsTo(Place::class)->withoutGlobalScopes();
     }
@@ -233,10 +238,8 @@ class Payload extends Model
 
     /**
      * Waypoints between start and end.
-     *
-     * @return \Illuminate\Database\Eloquent\Concerns\HasManyThrough
      */
-    public function waypoints()
+    public function waypoints(): HasManyThrough
     {
         return $this->hasManyThrough(Place::class, Waypoint::class, 'payload_uuid', 'uuid', 'uuid', 'place_uuid')->whereNull('waypoints.deleted_at')->withoutGlobalScopes();
     }
@@ -249,6 +252,11 @@ class Payload extends Model
         $this->attributes['cod_amount'] = Utils::numbersOnly($value);
     }
 
+    /**
+     * Add entities to the payload. Every entry creates a new entity, so sending
+     * the payload's current entities again duplicates them; use syncEntities()
+     * to replace the list.
+     */
     public function setEntities($entities = [])
     {
         if (empty($entities) || !is_array($entities)) {
@@ -256,49 +264,228 @@ class Payload extends Model
         }
 
         foreach ($entities as $attributes) {
-            if (isset($attributes['_import_id'])) {
-                $waypoint = $this->waypoints->firstWhere('_import_id', $attributes['_import_id']);
+            $entity = new Entity($this->prepareEntityAttributes($attributes));
+            $this->entities()->save($entity);
+        }
 
-                if ($waypoint) {
-                    $attributes['destination_uuid'] = $waypoint->uuid;
-                }
+        return $this;
+    }
+
+    /**
+     * Replace the payload's entities with the given list: entries naming an
+     * existing entity of this payload (by `id` public id or `uuid`) update it,
+     * entries without one create a new entity, and entities left out are deleted.
+     *
+     * @return array{created: string[], updated: string[], deleted: string[]} entity uuids by outcome
+     */
+    public function syncEntities($entities = []): array
+    {
+        $result = ['created' => [], 'updated' => [], 'deleted' => []];
+        if (!is_array($entities)) {
+            return $result;
+        }
+
+        $existing = $this->entities()->get();
+        $kept     = [];
+
+        foreach ($entities as $attributes) {
+            if (!is_array($attributes)) {
+                continue;
             }
 
-            // if a destination or waypoint is explicitly set
-            if (empty($attributes['destination_uuid'])) {
-                $destinationKey = Utils::or($attributes, ['waypoint', 'destination']);
-                $destination    = $this->findDestinationFromKey($destinationKey);
-                if ($destination instanceof Place) {
-                    $attributes['destination_uuid'] = $destination->uuid;
+            $entity = $this->findOwnEntity($existing, $attributes);
+            $values = $this->prepareEntityAttributes(Arr::except($attributes, ['id', 'uuid', 'public_id', 'payload_uuid', 'company_uuid']));
+
+            if ($entity) {
+                $entity->fill(Arr::only($values, $entity->getFillable()));
+                if ($entity->isDirty()) {
+                    $entity->save();
+                    $result['updated'][] = $entity->uuid;
                 }
+                $kept[] = $entity->uuid;
+
+                continue;
             }
 
-            // Validate destination actually exists
-            if (isset($attributes['destination_uuid']) && Place::where('uuid', $attributes['destination_uuid'])->doesntExist()) {
-                $validDestination = $this->_findCorrectDestinationForEntity($attributes);
-                if ($validDestination) {
-                    $attributes['destination_uuid'] = $validDestination->uuid;
-                }
+            $entity = new Entity($values);
+            $this->entities()->save($entity);
+            $result['created'][] = $entity->uuid;
+            $kept[]              = $entity->uuid;
+        }
+
+        foreach ($existing as $entity) {
+            if (!in_array($entity->uuid, $kept, true)) {
+                $entity->delete();
+                $result['deleted'][] = $entity->uuid;
             }
+        }
 
-            // Handle entity photo upload
-            if (isset($attributes['photo'])) {
-                $path = 'uploads/' . session('company') . '/entities';
-                $file = app(\Fleetbase\Services\FileResolverService::class)->resolve($attributes['photo'], $path);
+        $this->unsetRelation('entities');
 
-                if ($file) {
-                    $attributes['photo_uuid'] = $file->uuid;
+        return $result;
+    }
+
+    /**
+     * Whether every entry names an entity this payload already has, i.e. applying the
+     * list with syncEntities() would only update or remove entities, never add one.
+     */
+    public function entitiesListOnlyNamesExisting(array $entities): bool
+    {
+        $existing = $this->entities()->get();
+
+        foreach ($entities as $attributes) {
+            if (!is_array($attributes) || !$this->findOwnEntity($existing, $attributes)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Find the payload entity an entity entry refers to by `id` (public id) or `uuid`.
+     */
+    protected function findOwnEntity($existing, array $attributes): ?Entity
+    {
+        $key = $attributes['id'] ?? $attributes['public_id'] ?? $attributes['uuid'] ?? null;
+        if (!is_string($key) || $key === '') {
+            return null;
+        }
+
+        return $existing->first(fn (Entity $entity) => $entity->public_id === $key || $entity->uuid === $key);
+    }
+
+    /**
+     * Resolve an entity entry's destination and photo into storable attributes.
+     */
+    protected function prepareEntityAttributes(array $attributes): array
+    {
+        if (isset($attributes['_import_id'])) {
+            $waypoint = $this->waypoints->firstWhere('_import_id', $attributes['_import_id']);
+
+            if ($waypoint) {
+                $attributes['destination_uuid'] = $waypoint->uuid;
+            }
+        }
+
+        // if a destination or waypoint is explicitly set
+        if (empty($attributes['destination_uuid'])) {
+            $destinationKey = Utils::or($attributes, ['waypoint', 'destination']);
+            $destination    = $this->findDestinationFromKey($destinationKey);
+            if ($destination instanceof Place) {
+                $attributes['destination_uuid'] = $destination->uuid;
+            }
+        }
+
+        // Validate destination actually exists
+        if (isset($attributes['destination_uuid']) && Place::where('uuid', $attributes['destination_uuid'])->doesntExist()) {
+            $validDestination = $this->_findCorrectDestinationForEntity($attributes);
+            if ($validDestination) {
+                $attributes['destination_uuid'] = $validDestination->uuid;
+            }
+        }
+
+        // Handle entity photo upload
+        if (isset($attributes['photo'])) {
+            $path = 'uploads/' . session('company') . '/entities';
+            $file = app(\Fleetbase\Services\FileResolverService::class)->resolve($attributes['photo'], $path);
+
+            if ($file) {
+                $attributes['photo_uuid'] = $file->uuid;
+            }
+
+            // Clean up raw photo data
+            unset($attributes['photo']);
+        }
+
+        return $attributes;
+    }
+
+    /**
+     * The payload's stops as stored: pickup, dropoff and return place uuids, the
+     * waypoint place uuids in order and the current waypoint. Compare two
+     * signatures with routeChanges() to see what an edit changed.
+     */
+    public function routeSignature(): array
+    {
+        return [
+            'payload'   => $this->uuid,
+            'pickup'    => $this->pickup_uuid,
+            'dropoff'   => $this->dropoff_uuid,
+            'return'    => $this->return_uuid,
+            'waypoints' => $this->uuid ? Waypoint::where('payload_uuid', $this->uuid)->whereNull('deleted_at')->orderBy('order')->pluck('place_uuid')->values()->all() : [],
+            'current'   => $this->current_waypoint_uuid,
+        ];
+    }
+
+    /**
+     * The route parts (pickup, dropoff, return, waypoints) that differ between two route signatures.
+     */
+    public static function routeChanges(array $before, array $after): array
+    {
+        $changes = [];
+        foreach (['pickup', 'dropoff', 'return', 'waypoints'] as $part) {
+            if (($before[$part] ?? null) !== ($after[$part] ?? null)) {
+                $changes[] = $part;
+            }
+        }
+
+        return $changes;
+    }
+
+    /**
+     * Point the payload at the right stop after its route changed.
+     *
+     * Before the order is under way this is the first stop, as it always was. Once
+     * the driver is under way the stop they are heading to is kept when it is still
+     * on the route; when it was replaced the stop that took its place is used (the
+     * new pickup, dropoff or return), and a removed waypoint moves them on to the
+     * next stop they have not completed.
+     *
+     * @param array $before the routeSignature() taken before the edit
+     */
+    public function reconcileCurrentWaypoint(array $before, bool $inProgress): ?Place
+    {
+        $this->unsetRelation('waypoints');
+        $this->unsetRelation('waypointMarkers');
+        $this->loadMissing(['pickup', 'dropoff', 'return']);
+
+        $destination = null;
+
+        if ($inProgress) {
+            $after   = $this->routeSignature();
+            $current = $before['current'] ?? null;
+            $stops   = array_filter(array_merge([$after['pickup'], $after['dropoff'], $after['return']], $after['waypoints']));
+
+            if ($current && in_array($current, $stops, true)) {
+                $destination = Place::where('uuid', $current)->first();
+            } elseif ($current) {
+                foreach (['pickup', 'dropoff', 'return'] as $role) {
+                    if ($current === ($before[$role] ?? null) && $this->{$role} instanceof Place) {
+                        $destination = $this->{$role};
+                        break;
+                    }
                 }
 
-                // Clean up raw photo data
-                unset($attributes['photo']);
+                if (!$destination) {
+                    $next = $this->waypointMarkers()->orderBy('order')->get()->first(function (Waypoint $waypoint) {
+                        return !$waypoint->complete;
+                    });
+                    $destination = $next ? $next->getPlace() : ($this->dropoff instanceof Place ? $this->dropoff : null);
+                }
             }
+        }
 
-            $entity = new Entity($attributes);
-            $this->entities()->save($entity);
+        if (!$destination) {
+            $destination = $this->getPickupOrFirstWaypoint() ?? $this->getDropoffOrLastWaypoint();
         }
 
-        return $this;
+        if ($destination instanceof Place) {
+            $this->setCurrentWaypoint($destination);
+            $this->setRelation('currentWaypoint', $destination);
+        }
+
+        return $destination instanceof Place ? $destination : null;
     }
 
     public function insertEntities($entities = [])
@@ -365,6 +552,7 @@ class Payload extends Model
         $this->current_waypoint_uuid = $destination->uuid;
         if ($save) {
             DB::table($this->getTable())->where('uuid', $this->uuid)->update(['current_waypoint_uuid' => $destination->uuid]);
+            ApiModelCache::invalidateModelCache($this, $this->company_uuid);
         }
 
         return $this;
@@ -868,6 +1056,7 @@ class Payload extends Model
     public function removeWaypoints()
     {
         Waypoint::where('payload_uuid', $this->uuid)->delete();
+        Waypoint::invalidateApiCacheManually($this->company_uuid);
         $this->setRelation('waypoints', collect());
 
         return $this;
@@ -895,6 +1084,7 @@ class Payload extends Model
 
         if ($save) {
             $this->updateQuietly([$attr => null]);
+            ApiModelCache::invalidateModelCache($this, $this->company_uuid);
         }
 
         if (is_callable($callback)) {
@@ -928,6 +1118,7 @@ class Payload extends Model
         // If optioned to save
         if ($save) {
             $this->updateQuietly([$attr => $id]);
+            ApiModelCache::invalidateModelCache($this, $this->company_uuid);
         }
 
         if (is_callable($callback)) {
@@ -1000,6 +1191,7 @@ class Payload extends Model
 
         $this->current_waypoint_uuid = $destination->uuid;
         $this->saveQuietly();
+        ApiModelCache::invalidateModelCache($this, $this->company_uuid);
         $this->updateWaypointActivity($activity, $location);
 
         return $this->load('currentWaypoint');

package/server/src/Models/Place.php

@@ -187,7 +187,8 @@ class Place extends Model
             return static::getAvatar($value);
         }
 
-        return $value;
+        // legacy rows hold an absolute URL; re-sign it if it points into the private media bucket
+        return Utils::signStoredFileUrl($value);
     }
 
     /**
@@ -872,6 +873,11 @@ class Place extends Model
 
         $result = static::insert($values);
 
+        // Inserted without model events
+        if ($result) {
+            static::invalidateApiCacheManually($values['company_uuid']);
+        }
+
         return $result ? $uuid : false;
     }
 

package/server/src/Models/ServiceArea.php

@@ -91,6 +91,13 @@ class ServiceArea extends Model
      */
     protected $with = ['zones'];
 
+    /**
+     * Relation paths the cached service area lists embed through `$with` (fleetbase/core-api#301).
+     *
+     * @var string[]
+     */
+    protected $apiCacheDependencies = ['zones'];
+
     /**
      * Dynamic attributes that are appended to object.
      *

package/server/src/Models/ServiceRate.php

@@ -12,6 +12,8 @@ use Fleetbase\Traits\HasPublicId;
 use Fleetbase\Traits\HasUuid;
 use Fleetbase\Traits\SendsWebhooks;
 use Fleetbase\Traits\TracksApiCredential;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
 
 class ServiceRate extends Model
 {
@@ -110,42 +112,30 @@ class ServiceRate extends Model
      */
     protected $filterParams = [];
 
-    /**
-     * @return \Illuminate\Database\Eloquent\Relations\HasMany
-     */
-    public function rateFees()
+    public function rateFees(): HasMany
     {
         return $this->hasMany(ServiceRateFee::class);
     }
 
-    /**
-     * @return \Illuminate\Database\Eloquent\Relations\HasMany
-     */
-    public function parcelFees()
+    public function parcelFees(): HasMany
     {
         return $this->hasMany(ServiceRateParcelFee::class);
     }
 
     /**
-     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
+     * @return BelongsTo
      */
     public function orderConfig()
     {
         return $this->belongsTo(OrderConfig::class)->withTrashed();
     }
 
-    /**
-     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
-     */
-    public function serviceArea()
+    public function serviceArea(): BelongsTo
     {
         return $this->belongsTo(ServiceArea::class)->whereNull('deleted_at');
     }
 
-    /**
-     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
-     */
-    public function zone()
+    public function zone(): BelongsTo
     {
         return $this->belongsTo(Zone::class);
     }

package/server/src/Models/TrackingNumber.php

@@ -4,9 +4,11 @@ namespace Fleetbase\FleetOps\Models;
 
 use Fleetbase\Casts\PolymorphicType;
 use Fleetbase\FleetOps\Casts\Point;
+use Fleetbase\FleetOps\Support\TrackingCode;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\LaravelMysqlSpatial\Eloquent\SpatialTrait;
 use Fleetbase\Models\Model;
+use Fleetbase\Support\ApiModelCache;
 use Fleetbase\Traits\HasApiModelBehavior;
 use Fleetbase\Traits\HasPublicId;
 use Fleetbase\Traits\HasUuid;
@@ -16,6 +18,7 @@ use Illuminate\Support\Carbon;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Schema;
 use Illuminate\Support\Str;
+use Milon\Barcode\Facades\DNS1DFacade as DNS1D;
 use Milon\Barcode\Facades\DNS2DFacade as DNS2D;
 
 class TrackingNumber extends Model
@@ -236,6 +239,74 @@ class TrackingNumber extends Model
         throw (new \Illuminate\Database\Eloquent\ModelNotFoundException())->setModel(static::class, $id);
     }
 
+    /**
+     * The record a scanned code points at, within one company: the order, waypoint,
+     * entity or place that owns the tracking number.
+     *
+     * Accepts every format TrackingCode::parse() reads, including the bare owner uuid
+     * printed on labels before codes carried a url, and a bare tracking number or public
+     * id from a barcode or typed by hand. Without a company nothing resolves.
+     */
+    public static function findOwnerByCode(?string $code, ?string $companyUuid): ?\Illuminate\Database\Eloquent\Model
+    {
+        if (empty($companyUuid)) {
+            return null;
+        }
+
+        $parsed = TrackingCode::parse($code);
+
+        if ($parsed['uuid']) {
+            return static::ownerOf(static::firstForCode('owner_uuid', $parsed['uuid'], $companyUuid));
+        }
+
+        $number = $parsed['tracking_number'] ?? $parsed['reference'];
+        if ($number) {
+            $owner = static::ownerOf(static::firstForCode('tracking_number', $number, $companyUuid));
+
+            // A url names its tracking number deliberately, so an unknown one is a miss,
+            // not a cue to fall back to the owner it also names, which must agree.
+            if ($owner || $parsed['tracking_number']) {
+                return $owner && (!$parsed['public_id'] || data_get($owner, 'public_id') === $parsed['public_id']) ? $owner : null;
+            }
+        }
+
+        $publicId = $parsed['public_id'] ?? $parsed['reference'];
+
+        return $publicId ? static::ownerOf(static::firstForOwnerPublicId($publicId, $companyUuid)) : null;
+    }
+
+    protected static function firstForCode(string $column, string $value, string $companyUuid): ?self
+    {
+        return static::where('company_uuid', $companyUuid)->where($column, $value)->first();
+    }
+
+    protected static function firstForOwnerPublicId(string $publicId, string $companyUuid): ?self
+    {
+        // The public id's prefix names the owner's model, so only that table is searched.
+        $prefix     = Str::contains($publicId, '_') ? Str::before($publicId, '_') : null;
+        $ownerClass = [
+            'order'    => Order::class,
+            'waypoint' => Waypoint::class,
+            'entity'   => Entity::class,
+            'place'    => Place::class,
+        ][$prefix] ?? null;
+
+        if (!$ownerClass) {
+            return null;
+        }
+
+        return static::where('company_uuid', $companyUuid)
+            // Rows inserted raw (waypoints, entities) store the class with a leading slash.
+            ->whereIn('owner_type', [$ownerClass, '\\' . $ownerClass])
+            ->whereIn('owner_uuid', $ownerClass::withoutGlobalScopes()->select('uuid')->where('public_id', $publicId))
+            ->first();
+    }
+
+    protected static function ownerOf(?self $trackingNumber): ?\Illuminate\Database\Eloquent\Model
+    {
+        return $trackingNumber?->owner;
+    }
+
     public function updateOwnerStatus(?TrackingStatus $trackingStatus = null)
     {
         $trackingStatus = $trackingStatus ?? $this->load(['status'])->getRelationValue('status');
@@ -254,6 +325,10 @@ class TrackingNumber extends Model
 
     public static function insertGetUuid($values = [], ?Model $owner = null)
     {
+        // Read before the fillable filter below drops it. Callers that insert the owner
+        // with a raw query, and so have no model to pass, hand its public_id over here.
+        $ownerPublicId = $owner ? data_get($owner, 'public_id') : ($values['owner_public_id'] ?? null);
+
         $instance   = new static();
         $fillable   = $instance->getFillable();
         $insertKeys = array_keys($values);
@@ -276,8 +351,7 @@ class TrackingNumber extends Model
         }
 
         $values['tracking_number'] = static::newTrackingNumber($values['region'] ?? 'SG');
-        $values['qr_code']         = static::newBarcode((string) ($values['owner_uuid'] ?? ''), 'QRCODE');
-        $values['barcode']         = static::newBarcode((string) ($values['owner_uuid'] ?? ''), 'PDF417');
+        $values                    = array_merge($values, static::codeImages($values['tracking_number'], $ownerPublicId));
 
         if (isset($values['meta']) && (is_object($values['meta']) || is_array($values['meta']))) {
             $values['meta'] = json_encode($values['meta']);
@@ -314,8 +388,12 @@ class TrackingNumber extends Model
 
             // silent update
             static::updateOwnerStatusColumn($owner, $initialCode ?? 'created');
+            ApiModelCache::invalidateModelCache($owner, data_get($owner, 'company_uuid', $values['company_uuid']));
         }
 
+        // Inserted and updated without model events
+        ApiModelCache::invalidateModelCache($instance, $values['company_uuid']);
+
         return $uuid;
     }
 
@@ -339,8 +417,29 @@ class TrackingNumber extends Model
         return static::generateNumber($region);
     }
 
+    /**
+     * The base64 PNGs printed on a label: a QR code carrying the tracking url (see
+     * TrackingCode) and a Code 128 barcode carrying the bare tracking number.
+     *
+     * @return array{qr_code: string, barcode: string}
+     */
+    public static function codeImages(string $trackingNumber, ?string $ownerPublicId = null): array
+    {
+        return [
+            // Medium error correction: labels get scuffed, and the url fits comfortably.
+            'qr_code' => static::newBarcode(TrackingCode::qrContent($trackingNumber, $ownerPublicId), 'QRCODE,M'),
+            'barcode' => static::newBarcode(TrackingCode::barcodeContent($trackingNumber), 'C128'),
+        ];
+    }
+
     protected static function newBarcode(string $value, string $type): string
     {
+        if ($type === 'C128') {
+            // 2px modules, 60px tall: a typical tracking number renders ~330px wide, inside
+            // the label's 360px cap, so it prints at its own resolution.
+            return DNS1D::getBarcodePNG($value, $type, 2, 60);
+        }
+
         return DNS2D::getBarcodePNG($value, $type);
     }
 

package/server/src/Models/TrackingSession.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Fleetbase\FleetOps\Models;
+
+use Fleetbase\Models\Model;
+use Fleetbase\Traits\HasUuid;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+/**
+ * A device that has verified on the public tracking page. The cookie's value is never
+ * stored, only its SHA-256 in `token_hash`.
+ */
+class TrackingSession extends Model
+{
+    use HasUuid;
+
+    protected $table = 'tracking_sessions';
+
+    protected $fillable = ['token_hash', 'ip', 'user_agent', 'last_seen_at', 'expires_at', 'revoked_at'];
+
+    protected $casts = [
+        'last_seen_at' => 'datetime',
+        'expires_at'   => 'datetime',
+        'revoked_at'   => 'datetime',
+    ];
+
+    protected $hidden = ['token_hash'];
+
+    public function grants(): HasMany
+    {
+        return $this->hasMany(TrackingSessionGrant::class, 'tracking_session_uuid', 'uuid');
+    }
+}

package/server/src/Models/TrackingSessionGrant.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Fleetbase\FleetOps\Models;
+
+use Fleetbase\Models\Model;
+use Fleetbase\Traits\HasUuid;
+
+/**
+ * What a verified device may see: one customer within one order, until `expires_at`.
+ */
+class TrackingSessionGrant extends Model
+{
+    use HasUuid;
+
+    protected $table = 'tracking_session_grants';
+
+    protected $fillable = ['tracking_session_uuid', 'company_uuid', 'order_uuid', 'customer_type', 'customer_uuid', 'channel', 'expires_at'];
+
+    protected $casts = [
+        'expires_at' => 'datetime',
+    ];
+}