@fleetbase/fleetops-engine 0.6.68 → 0.6.70

package/server/src/Support/Ai/Tools/SearchResourcesTool.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Ai\Tools;
+
+use Fleetbase\Ai\Contracts\AIToolCapabilityInterface;
+use Fleetbase\Ai\Models\AiTask;
+use Fleetbase\Ai\Support\AiToolContext;
+use Fleetbase\FleetOps\Support\Ai\Capabilities\SearchResourcesCapability;
+use Illuminate\Support\Str;
+
+/**
+ * Lets the model look up specific Fleet-Ops records by id, name, plate, email, or tracking number.
+ */
+class SearchResourcesTool extends SearchResourcesCapability implements AIToolCapabilityInterface
+{
+    public const TYPES = ['orders', 'vehicles', 'drivers', 'work_orders', 'maintenances', 'devices', 'sensors', 'telematics'];
+
+    public function toolName(): string
+    {
+        return 'fleetops_search';
+    }
+
+    public function toolDescription(): string
+    {
+        return 'Find specific Fleet-Ops records (orders, vehicles, drivers, work orders, maintenances, devices, sensors, telematics) by public id, internal id, tracking number, name, plate number, VIN, email, or phone. '
+            . 'Use it when the user refers to a particular record. For counts or status breakdowns use the counting tools instead. Returns at most 5 matches per type.';
+    }
+
+    public function toolParameters(): array
+    {
+        return [
+            'type'       => 'object',
+            'properties' => [
+                'query' => ['type' => 'string', 'description' => 'The identifier or name to look for, e.g. "order_yhkejdnzgz", "SBA1234Z", or "Jane Doe".'],
+                'types' => ['type' => 'array', 'items' => ['type' => 'string', 'enum' => static::TYPES], 'description' => 'Optional record types to search. Searches all types when omitted.'],
+            ],
+            'required'             => ['query'],
+            'additionalProperties' => false,
+        ];
+    }
+
+    public function availableFor(AiToolContext $context): bool
+    {
+        foreach ($this->permissions() as $permission) {
+            if ($context->audience->can($permission)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function invoke(AiTask $task, array $arguments, AiToolContext $context): array
+    {
+        $query = trim((string) ($arguments['query'] ?? ''));
+
+        if (mb_strlen($query) < 2) {
+            return ['error' => 'Provide an identifier or name to search for.'];
+        }
+
+        // The model sends an intentional query, so the whole phrase is searched along with any ids in it.
+        $terms = collect([Str::limit($query, 100, '')])
+            ->merge($this->searchTerms($query))
+            ->unique(fn ($term) => Str::lower($term))
+            ->take(4)
+            ->values()
+            ->all();
+
+        $types = array_values(array_intersect((array) ($arguments['types'] ?? []), static::TYPES));
+
+        return $this->searchAll($terms, $types ?: null);
+    }
+}

package/server/src/Support/Analytics/LiveFleet.php

@@ -2,10 +2,13 @@
 
 namespace Fleetbase\FleetOps\Support\Analytics;
 
+use Fleetbase\FleetOps\Http\Resources\v1\Index\Driver as DriverIndexResource;
+use Fleetbase\FleetOps\Http\Resources\v1\Index\Vehicle as VehicleIndexResource;
 use Fleetbase\FleetOps\Models\Driver;
 use Fleetbase\FleetOps\Models\Order;
 use Fleetbase\FleetOps\Models\Vehicle;
 use Fleetbase\FleetOps\Support\Metrics\OrdersInProgressMetric;
+use Illuminate\Http\Resources\Json\JsonResource;
 
 /**
  * Real-time fleet snapshot used as the initial-state payload for Live Fleet Map.
@@ -23,7 +26,8 @@ class LiveFleet extends AbstractAnalytics
 
         // Driver.name is a virtual attribute backed by users.name — eager-load the
         // user so the accessor resolves cleanly without a per-record query.
-        $drivers = Driver::with(['user:uuid,name,avatar_uuid'])
+        // The user and vehicle also feed each marker's card (see card()).
+        $drivers = Driver::with(['user', 'vehicle'])
             ->where('drivers.company_uuid', $companyUuid)
             ->whereNotNull('drivers.location')
             ->where(function ($q) {
@@ -33,7 +37,8 @@ class LiveFleet extends AbstractAnalytics
 
         // Vehicles tracked independently of drivers (telematics-connected rigs may
         // report position without an active driver session).
-        $vehicles = Vehicle::where('company_uuid', $companyUuid)
+        $vehicles = Vehicle::with(['devices', 'driver', 'currentTrailers'])
+            ->where('company_uuid', $companyUuid)
             ->whereNotNull('location')
             ->get();
 
@@ -79,6 +84,7 @@ class LiveFleet extends AbstractAnalytics
             'lat'                => $lat,
             'lng'                => $lng,
             'updated_at'         => $d->last_location_update_at,
+            'card'               => $this->card(new DriverIndexResource($d)),
         ];
     }
 
@@ -98,9 +104,19 @@ class LiveFleet extends AbstractAnalytics
             'heading'      => (float) ($v->heading ?? 0),
             'lat'          => $lat,
             'lng'          => $lng,
+            'card'         => $this->card(new VehicleIndexResource($v)),
         ];
     }
 
+    /**
+     * What the operational live map shows in a marker's popup and tooltip: the same index
+     * resource its live endpoints return, so the dashboard widget renders identical cards.
+     */
+    private function card(JsonResource $resource): array
+    {
+        return $resource->resolve(request());
+    }
+
     /**
      * Pull [lat, lng] out of whatever shape the spatial accessor handed us.
      * Supports Point objects, [lat, lng] arrays, and {lat, lng} hashes.

package/server/src/Support/Authorization.php

@@ -0,0 +1,103 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support;
+
+use Fleetbase\Models\Permission;
+use Fleetbase\Support\Auth;
+use Illuminate\Http\Exceptions\HttpResponseException;
+
+/**
+ * Explicit Fleet-Ops permission checks for endpoints that AuthorizationGuard
+ * cannot resolve correctly on its own: controllers that are not resource
+ * controllers, and custom actions whose method name does not match a schema
+ * action (for example `bulkDispatch`, which the guard maps to `create order`).
+ *
+ * Mirrors the guard's semantics:
+ *  - platform admins always pass;
+ *  - a permission is granted by its exact name, `fleet-ops * {resource}` or `fleet-ops *`;
+ *  - while the resource has no permission rows at all (the schema has not been
+ *    seeded yet) the check passes, exactly like an unguarded resource.
+ *
+ * Methods that call this must carry `#[SkipAuthorizationCheck]` so the guard
+ * does not also demand its own (wrong) permission.
+ */
+class Authorization
+{
+    public const SERVICE = 'fleet-ops';
+
+    /**
+     * Abort with a 401 JSON response unless the user holds at least one of the permissions.
+     *
+     * @param string ...$permissions Short form `{action} {resource}`, e.g. `dispatch order`
+     *
+     * @throws HttpResponseException
+     */
+    public static function authorize(string ...$permissions): void
+    {
+        if (static::canAny(...$permissions)) {
+            return;
+        }
+
+        throw new HttpResponseException(response()->json(['errors' => ['User is not authorized to ' . $permissions[0]]], 401));
+    }
+
+    /**
+     * Abort with a 401 JSON response unless the current user is a platform administrator.
+     *
+     * @throws HttpResponseException
+     */
+    public static function authorizeAdmin(): void
+    {
+        $user = static::user();
+        if ($user && $user->isAdmin()) {
+            return;
+        }
+
+        throw new HttpResponseException(response()->json(['errors' => ['This action requires a system administrator']], 401));
+    }
+
+    public static function canAny(string ...$permissions): bool
+    {
+        $user = static::user();
+        if (!$user) {
+            return false;
+        }
+
+        if ($user->isAdmin()) {
+            return true;
+        }
+
+        foreach ($permissions as $permission) {
+            if (static::can($permission)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static function can(string $permission): bool
+    {
+        [$action, $resource] = explode(' ', $permission, 2);
+
+        // Same test as Auth::isResourceGuarded(): no permission rows for the resource yet.
+        if (!Permission::where('name', 'like', static::SERVICE . ' % ' . $resource)->exists()) {
+            return true;
+        }
+
+        try {
+            return Auth::can(static::SERVICE . " {$action} {$resource}");
+        } catch (\Throwable $e) {
+            return false;
+        }
+    }
+
+    protected static function user()
+    {
+        try {
+            return Auth::getUserFromSession();
+        } catch (\Throwable $e) {
+            return null;
+        }
+    }
+}

package/server/src/Support/Database/TableIndexes.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\Database;
+
+use Illuminate\Support\Facades\Schema;
+
+/**
+ * Inspect table indexes without Schema::getIndexes, which is absent in the
+ * Laravel versions this package supports. Fleet-Ops deploys on MySQL and runs
+ * its migration tests on SQLite.
+ */
+final class TableIndexes
+{
+    /**
+     * @return array<string, string[]> index name => ordered column names
+     */
+    public static function for(string $table): array
+    {
+        $connection = Schema::getConnection();
+        $prefixed   = $connection->getTablePrefix() . $table;
+        $indexes    = [];
+
+        if ($connection instanceof \Illuminate\Database\SQLiteConnection || $connection->getDriverName() === 'sqlite') {
+            $quoted = str_replace('"', '""', $prefixed);
+            foreach ($connection->select('PRAGMA index_list("' . $quoted . '")') as $index) {
+                $name    = str_replace('"', '""', $index->name);
+                $columns = $connection->select('PRAGMA index_info("' . $name . '")');
+                usort($columns, fn ($a, $b) => $a->seqno <=> $b->seqno);
+                $indexes[$index->name] = array_column($columns, 'name');
+            }
+
+            return $indexes;
+        }
+
+        // @codeCoverageIgnoreStart
+        if ($connection->getDriverName() !== 'mysql') {
+            throw new \RuntimeException('Index inspection requires MySQL or SQLite.');
+        }
+
+        $quoted = str_replace('`', '``', $prefixed);
+        foreach ($connection->select('SHOW INDEX FROM `' . $quoted . '`') as $index) {
+            $indexes[$index->Key_name][(int) $index->Seq_in_index - 1] = $index->Column_name;
+        }
+        foreach ($indexes as &$columns) {
+            ksort($columns);
+            $columns = array_values($columns);
+        }
+
+        return $indexes;
+        // @codeCoverageIgnoreEnd
+    }
+
+    /**
+     * Whether any index already leads with exactly these columns, in order.
+     */
+    public static function covers(string $table, array $columns): bool
+    {
+        foreach (self::for($table) as $indexed) {
+            if (array_slice($indexed, 0, count($columns)) === $columns) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

package/server/src/Support/OrderTracker.php

@@ -14,11 +14,11 @@ class OrderTracker
 
     public function eta(array $options = []): array
     {
-        return app(TrackingIntelligenceService::class)->eta($this->order, TrackingOptions::fromArray($options));
+        return app(TrackingIntelligenceService::class)->eta($this->order, TrackingOptions::fromArray($options, $this->order->company_uuid));
     }
 
     public function toArray(array $options = []): array
     {
-        return app(TrackingIntelligenceService::class)->track($this->order, TrackingOptions::fromArray($options));
+        return app(TrackingIntelligenceService::class)->track($this->order, TrackingOptions::fromArray($options, $this->order->company_uuid));
     }
 }