@fleetbase/fleetops-engine 0.6.38 → 0.6.39

package/server/src/Http/Controllers/Internal/v1/OrderController.php

@@ -1036,4 +1036,46 @@ class OrderController extends FleetOpsController
 
         return new OrderResource($order);
     }
+
+    /**
+     * Schedule an order: set scheduled_at and optionally assign a driver.
+     * This endpoint intentionally does NOT trigger dispatch or change the
+     * order status, so it is safe to call from the scheduler UI.
+     *
+     * @return \Illuminate\Http\Response
+     */
+    public function scheduleOrder(Request $request)
+    {
+        $orderId     = $request->input('order');
+        $scheduledAt = $request->input('scheduled_at');
+        $driverId    = $request->input('driver_id');
+
+        $order = Order::findById($orderId);
+        if (!$order) {
+            return response()->error('No order found to schedule.');
+        }
+
+        if ($scheduledAt) {
+            $order->scheduled_at = \Carbon\Carbon::parse($scheduledAt);
+        }
+
+        if ($driverId) {
+            // Resolve by uuid or public_id
+            $driver = Driver::where('uuid', $driverId)
+                ->orWhere('public_id', $driverId)
+                ->first();
+            if ($driver) {
+                $order->driver_assigned_uuid = $driver->uuid;
+            }
+        }
+
+        $order->saveQuietly();
+
+        return response()->json([
+            'status'       => 'OK',
+            'message'      => 'Order scheduled',
+            'order'        => $order->uuid,
+            'scheduled_at' => $order->scheduled_at,
+        ]);
+    }
 }

package/server/src/Http/Controllers/Internal/v1/PartController.php

@@ -3,6 +3,9 @@
 namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1;
 
 use Fleetbase\FleetOps\Http\Controllers\FleetOpsController;
+use Fleetbase\FleetOps\Imports\PartImport;
+use Fleetbase\Http\Requests\ImportRequest;
+use Maatwebsite\Excel\Facades\Excel;
 
 class PartController extends FleetOpsController
 {
@@ -12,4 +15,28 @@ class PartController extends FleetOpsController
      * @var string
      */
     public $resource = 'part';
+
+    /**
+     * Process import files (excel, csv) into Part records.
+     *
+     * @return \Illuminate\Http\Response
+     */
+    public function import(ImportRequest $request)
+    {
+        $disk          = $request->input('disk', config('filesystems.default'));
+        $files         = $request->resolveFilesFromIds();
+        $importedCount = 0;
+
+        foreach ($files as $file) {
+            try {
+                $import = new PartImport();
+                Excel::import($import, $file->path, $disk);
+                $importedCount += $import->imported;
+            } catch (\Throwable $e) {
+                return response()->error('Invalid file, unable to process.');
+            }
+        }
+
+        return response()->json(['status' => 'ok', 'message' => 'Import completed', 'imported' => $importedCount]);
+    }
 }

package/server/src/Http/Controllers/Internal/v1/SettingController.php

@@ -210,4 +210,122 @@ class SettingController extends Controller
 
         return response()->json($routingSettings);
     }
+
+    /**
+     * Retrieve driver scheduling settings for the current company.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function getSchedulingSettings()
+    {
+        $defaults = [
+            'horizon_days'                   => 60,
+            'default_shift_duration'         => 8,
+            'hos_daily_limit'                => 11,
+            'hos_weekly_limit'               => 70,
+            'auto_activate_schedule'         => true,
+            'notify_drivers_on_shift_change' => false,
+        ];
+        $settings = Setting::lookupFromCompany('fleet-ops.scheduling-settings', $defaults);
+
+        return response()->json($settings);
+    }
+
+    /**
+     * Save driver scheduling settings for the current company.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function saveSchedulingSettings(Request $request)
+    {
+        $settings = [
+            'horizon_days'                   => (int) $request->input('horizon_days', 60),
+            'default_shift_duration'         => (int) $request->input('default_shift_duration', 8),
+            'hos_daily_limit'                => (int) $request->input('hos_daily_limit', 11),
+            'hos_weekly_limit'               => (int) $request->input('hos_weekly_limit', 70),
+            'auto_activate_schedule'         => (bool) $request->input('auto_activate_schedule', true),
+            'notify_drivers_on_shift_change' => (bool) $request->input('notify_drivers_on_shift_change', false),
+        ];
+        Setting::configureCompany('fleet-ops.scheduling-settings', $settings);
+
+        return response()->json($settings);
+    }
+
+    /**
+     * Retrieve order allocation settings for the current company.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function getOrchestratorSettings()
+    {
+        $defaults = [
+            'allocation_engine'           => 'vroom',
+            'auto_allocate_on_create'     => false,
+            'auto_reallocate_on_complete' => false,
+            'max_travel_time_seconds'     => 3600,
+            'balance_workload'            => false,
+        ];
+        $settings = Setting::lookupFromCompany('fleet-ops.allocation-settings', $defaults);
+
+        return response()->json($settings);
+    }
+
+    /**
+     * Save order allocation settings for the current company.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function saveOrchestratorSettings(Request $request)
+    {
+        $settings = [
+            'allocation_engine'           => $request->input('allocation_engine', 'vroom'),
+            'auto_allocate_on_create'     => (bool) $request->input('auto_allocate_on_create', false),
+            'auto_reallocate_on_complete' => (bool) $request->input('auto_reallocate_on_complete', false),
+            'max_travel_time_seconds'     => (int) $request->input('max_travel_time_seconds', 3600),
+            'balance_workload'            => (bool) $request->input('balance_workload', false),
+        ];
+        Setting::configureCompany('fleet-ops.allocation-settings', $settings);
+
+        return response()->json($settings);
+    }
+
+    /**
+     * Retrieve orchestrator order card field settings for the current company.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function getOrchestratorCardFields()
+    {
+        $defaults = [
+            'standard'  => ['tracking', 'status', 'scheduled_at', 'customer', 'dropoff'],
+            'byConfig'  => (object) [],
+            'meta'      => [],
+        ];
+        $settings = Setting::lookupFromCompany('fleet-ops.orchestrator-card-fields', $defaults);
+
+        return response()->json(['settings' => $settings]);
+    }
+
+    /**
+     * Save orchestrator order card field settings for the current company.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function saveOrchestratorCardFields(Request $request)
+    {
+        $settings = $request->input('settings', []);
+
+        $normalized = [
+            'standard'  => $settings['standard'] ?? ['tracking', 'status', 'scheduled_at', 'customer', 'dropoff'],
+            'byConfig'  => $settings['byConfig'] ?? [],
+            'meta'      => $settings['meta'] ?? [],
+        ];
+        Setting::configureCompany('fleet-ops.orchestrator-card-fields', $normalized);
+
+        return response()->json([
+            'status'   => 'ok',
+            'message'  => 'Orchestrator card fields saved.',
+            'settings' => $normalized,
+        ]);
+    }
 }

package/server/src/Http/Controllers/Internal/v1/Traits/DriverSchedulingTrait.php

@@ -0,0 +1,214 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1\Traits;
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\Models\Schedule;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\DB;
+
+/**
+ * DriverSchedulingTrait.
+ *
+ * Provides scheduling-related controller methods for the DriverController.
+ * These methods expose the core-api scheduling relationships (ScheduleItem,
+ * ScheduleAvailability) through FleetOps-specific driver endpoints.
+ *
+ * Routes:
+ *   GET /int/v1/drivers/{id}/schedule-items
+ *   GET /int/v1/drivers/{id}/availabilities
+ *   GET /int/v1/drivers/{id}/hos-status
+ *   GET /int/v1/drivers/{id}/active-shift
+ *
+ * The {id} parameter accepts either the driver's UUID or public_id.
+ */
+trait DriverSchedulingTrait
+{
+    /**
+     * Regulatory HOS defaults used when no per-schedule override is configured.
+     * These match the US FMCSA 11-hour / 70-hour rules as a sensible baseline.
+     */
+    private const HOS_DEFAULT_DAILY_LIMIT  = 11;
+    private const HOS_DEFAULT_WEEKLY_LIMIT = 70;
+
+    /**
+     * Resolve a Driver by UUID or public_id, throwing 404 if not found.
+     */
+    private function resolveDriver(string $id): Driver
+    {
+        return Driver::where('uuid', $id)
+            ->orWhere('public_id', $id)
+            ->firstOrFail();
+    }
+
+    /**
+     * Return all ScheduleItem records assigned to this driver.
+     * Supports optional date range filtering via start_at and end_at query params.
+     *
+     * GET /int/v1/drivers/{id}/schedule-items
+     */
+    public function scheduleItems(string $id, Request $request): JsonResponse
+    {
+        $driver = $this->resolveDriver($id);
+        $query  = $driver->scheduleItems();
+
+        if ($request->filled('start_at')) {
+            $query->where('start_at', '>=', $request->input('start_at'));
+        }
+        if ($request->filled('end_at')) {
+            $query->where('end_at', '<=', $request->input('end_at'));
+        }
+
+        return response()->json(['data' => $query->orderBy('start_at')->get()]);
+    }
+
+    /**
+     * Return all ScheduleAvailability records for this driver.
+     * Supports optional date range filtering via start_at and end_at query params.
+     *
+     * GET /int/v1/drivers/{id}/availabilities
+     */
+    public function availabilities(string $id, Request $request): JsonResponse
+    {
+        $driver = $this->resolveDriver($id);
+        $query  = $driver->availabilities();
+
+        if ($request->filled('start_at')) {
+            $query->where('start_at', '>=', $request->input('start_at'));
+        }
+        if ($request->filled('end_at')) {
+            $query->where('end_at', '<=', $request->input('end_at'));
+        }
+
+        return response()->json(['data' => $query->orderBy('start_at')->get()]);
+    }
+
+    /**
+     * Return the driver's Hours of Service (HOS) status.
+     *
+     * ## Data source
+     *
+     * The `hos_source` field on the driver's active Schedule determines how
+     * driving hours are accumulated:
+     *
+     *  - `schedule` (default): Hours are derived from the driver's ScheduleItem
+     *    records. Any shift whose `start_at` is in the past (i.e. has already
+     *    started) is counted. For ongoing shifts (no `end_at` or end_at > NOW()),
+     *    elapsed time up to NOW() is used. This gives a meaningful "hours
+     *    scheduled/worked so far" reading immediately, without requiring
+     *    clock-in/clock-out or telematics data.
+     *
+     *  - `telematics` (future): Accumulated from GPS movement data.
+     *  - `manual` (future): Manually logged by a dispatcher.
+     *
+     * ## Limits
+     *
+     * Limits are resolved in priority order:
+     *   1. Per-schedule `hos_daily_limit` / `hos_weekly_limit` (if set on the Schedule)
+     *   2. Hard-coded regulatory defaults: 11h daily / 70h weekly (US FMCSA baseline)
+     *
+     * GET /int/v1/drivers/{id}/hos-status
+     */
+    public function hosStatus(string $id): JsonResponse
+    {
+        $driver = $this->resolveDriver($id);
+
+        // ── Resolve the driver's active schedule ──────────────────────────────
+        /** @var Schedule|null $schedule */
+        $schedule = $driver->schedules()
+            ->where('status', 'active')
+            ->latest('created_at')
+            ->first();
+
+        // ── Determine HOS limits (per-schedule → global default) ──────────────
+        $dailyLimit  = ($schedule && $schedule->hos_daily_limit)
+            ? (int) $schedule->hos_daily_limit
+            : self::HOS_DEFAULT_DAILY_LIMIT;
+
+        $weeklyLimit = ($schedule && $schedule->hos_weekly_limit)
+            ? (int) $schedule->hos_weekly_limit
+            : self::HOS_DEFAULT_WEEKLY_LIMIT;
+
+        // ── Determine HOS source ──────────────────────────────────────────────
+        $hosSource = $schedule ? ($schedule->hos_source ?? 'schedule') : 'schedule';
+
+        // ── Calculate hours based on source ───────────────────────────────────
+        [$dailyHours, $weeklyHours] = match ($hosSource) {
+            // Future sources (telematics, manual) will be added here
+            default => $this->calculateHosFromSchedule($driver),
+        };
+
+        return response()->json([
+            'daily_hours'   => $dailyHours,
+            'weekly_hours'  => $weeklyHours,
+            'daily_limit'   => $dailyLimit,
+            'weekly_limit'  => $weeklyLimit,
+            'hos_source'    => $hosSource,
+            'is_compliant'  => $dailyHours < $dailyLimit && $weeklyHours < $weeklyLimit,
+        ]);
+    }
+
+    /**
+     * Calculate HOS hours from the driver's ScheduleItem records.
+     *
+     * Counts all shifts whose `start_at` is in the past (i.e. the shift has
+     * already started). For ongoing shifts (end_at is null or in the future),
+     * elapsed time up to NOW() is used via LEAST(COALESCE(end_at, NOW()), NOW()).
+     *
+     * Cancelled shifts are excluded. All other statuses (scheduled, in_progress,
+     * completed) are included — a shift that has started counts toward HOS
+     * regardless of whether it has been formally marked completed.
+     *
+     * @return array{float, float} [dailyHours, weeklyHours]
+     */
+    private function calculateHosFromSchedule(Driver $driver): array
+    {
+        $now         = now();
+        $startOfDay  = $now->copy()->startOfDay();
+        $startOfWeek = $now->copy()->startOfWeek();
+
+        // Duration expression: elapsed minutes from shift start to MIN(end_at, NOW()).
+        // This caps ongoing shifts at the current moment so future time is never counted.
+        $durationExpr = DB::raw(
+            'TIMESTAMPDIFF(MINUTE, start_at, LEAST(COALESCE(end_at, NOW()), NOW()))'
+        );
+
+        // Daily: shifts that started today and have already begun
+        $dailyMinutes = $driver->scheduleItems()
+            ->where('start_at', '>=', $startOfDay)
+            ->where('start_at', '<=', $now)
+            ->where('status', '!=', 'cancelled')
+            ->sum($durationExpr);
+
+        // Weekly: shifts that started this week and have already begun
+        $weeklyMinutes = $driver->scheduleItems()
+            ->where('start_at', '>=', $startOfWeek)
+            ->where('start_at', '<=', $now)
+            ->where('status', '!=', 'cancelled')
+            ->sum($durationExpr);
+
+        return [
+            round((float) $dailyMinutes / 60, 1),
+            round((float) $weeklyMinutes / 60, 1),
+        ];
+    }
+
+    /**
+     * Return the driver's currently active shift for today.
+     * Used by OrchestrationPayloadBuilder to inject time_window constraints.
+     *
+     * GET /int/v1/drivers/{id}/active-shift
+     */
+    public function activeShift(string $id): JsonResponse
+    {
+        $driver = $this->resolveDriver($id);
+        $shift  = $driver->activeShiftFor(now());
+
+        if (!$shift) {
+            return response()->json(['data' => null]);
+        }
+
+        return response()->json(['data' => $shift]);
+    }
+}

package/server/src/Http/Controllers/Internal/v1/WorkOrderController.php

@@ -3,6 +3,13 @@
 namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1;
 
 use Fleetbase\FleetOps\Http\Controllers\FleetOpsController;
+use Fleetbase\FleetOps\Imports\WorkOrderImport;
+use Fleetbase\FleetOps\Mail\WorkOrderDispatched;
+use Fleetbase\FleetOps\Models\WorkOrder;
+use Fleetbase\Http\Requests\ImportRequest;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Support\Facades\Mail;
+use Maatwebsite\Excel\Facades\Excel;
 
 class WorkOrderController extends FleetOpsController
 {
@@ -12,4 +19,65 @@ class WorkOrderController extends FleetOpsController
      * @var string
      */
     public $resource = 'work-order';
+
+    /**
+     * Process import files (excel, csv) into WorkOrder records.
+     *
+     * @return \Illuminate\Http\Response
+     */
+    public function import(ImportRequest $request)
+    {
+        $disk          = $request->input('disk', config('filesystems.default'));
+        $files         = $request->resolveFilesFromIds();
+        $importedCount = 0;
+
+        foreach ($files as $file) {
+            try {
+                $import = new WorkOrderImport();
+                Excel::import($import, $file->path, $disk);
+                $importedCount += $import->imported;
+            } catch (\Throwable $e) {
+                return response()->error('Invalid file, unable to process.');
+            }
+        }
+
+        return response()->json(['status' => 'ok', 'message' => 'Import completed', 'imported' => $importedCount]);
+    }
+
+    /**
+     * Send a work order email to the assigned vendor.
+     * POST /work-orders/{id}/send.
+     */
+    public function sendEmail(string $id): JsonResponse
+    {
+        $workOrder = WorkOrder::where('uuid', $id)
+            ->orWhere('public_id', $id)
+            ->with(['assignee', 'target'])
+            ->firstOrFail();
+
+        // Resolve recipient email from the assignee (vendor or contact)
+        $assignee = $workOrder->assignee;
+
+        if (!$assignee) {
+            return response()->json(['error' => 'This work order has no assigned vendor.'], 422);
+        }
+
+        $email = $assignee->email ?? null;
+
+        if (!$email) {
+            return response()->json(['error' => 'The assigned vendor has no email address on file.'], 422);
+        }
+
+        Mail::to($email)->send(new WorkOrderDispatched($workOrder));
+
+        activity('work_order_sent')
+            ->performedOn($workOrder)
+            ->withProperties(['sent_to' => $email])
+            ->log('Work order emailed to vendor');
+
+        return response()->json([
+            'status'  => 'ok',
+            'message' => 'Work order successfully sent to ' . $email,
+        ]);
+    }
 }

package/server/src/Http/Resources/v1/Driver.php

@@ -50,6 +50,7 @@ class Driver extends FleetbaseResource
             'jobs'                          => $this->whenLoaded('jobs', fn () => $this->getJobs()),
             'vendor'                        => $this->whenLoaded('vendor', fn () => new Vendor($this->vendor)),
             'fleets'                        => $this->whenLoaded('fleets', fn () => Fleet::collection($this->fleets()->without('drivers')->get())),
+            'current_shift'                 => $this->whenLoaded('currentShift', fn () => $this->currentShift),
             'location'                      => $this->wasRecentlyCreated ? new Point(0, 0) : Utils::castPoint($this->location),
             'heading'                       => (int) data_get($this, 'heading', 0),
             'altitude'                      => (int) data_get($this, 'altitude', 0),

package/server/src/Http/Resources/v1/Maintenance.php

@@ -0,0 +1,138 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Resources\v1;
+
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Http\Resources\FleetbaseResource;
+use Fleetbase\Support\Http;
+use Illuminate\Support\Str;
+
+class Maintenance extends FleetbaseResource
+{
+    /**
+     * Transform the resource into an array.
+     *
+     * @param \Illuminate\Http\Request $request
+     *
+     * @return array
+     */
+    public function toArray($request)
+    {
+        return $this->withCustomFields([
+            'id'                      => $this->when(Http::isInternalRequest(), $this->id, $this->public_id),
+            'uuid'                    => $this->when(Http::isInternalRequest(), $this->uuid),
+            'public_id'               => $this->when(Http::isInternalRequest(), $this->public_id),
+            'company_uuid'            => $this->when(Http::isInternalRequest(), $this->company_uuid),
+            'work_order_uuid'         => $this->when(Http::isInternalRequest(), $this->work_order_uuid),
+            'created_by_uuid'         => $this->when(Http::isInternalRequest(), $this->created_by_uuid),
+            'updated_by_uuid'         => $this->when(Http::isInternalRequest(), $this->updated_by_uuid),
+            // Polymorphic maintainable
+            'maintainable_uuid'       => $this->when(Http::isInternalRequest(), $this->maintainable_uuid),
+            'maintainable_type'       => $this->when(Http::isInternalRequest(), $this->maintainable_type ? Utils::toEmberResourceType($this->maintainable_type) : null),
+            'maintainable'            => $this->whenLoaded('maintainable', function () {
+                return $this->setMaintainableType($this->transformMorphResource($this->maintainable));
+            }),
+            // Polymorphic performed_by
+            'performed_by_uuid'       => $this->when(Http::isInternalRequest(), $this->performed_by_uuid),
+            'performed_by_type'       => $this->when(Http::isInternalRequest(), $this->performed_by_type ? Utils::toEmberResourceType($this->performed_by_type) : null),
+            'performed_by'            => $this->whenLoaded('performedBy', function () {
+                return $this->setPerformedByType($this->transformMorphResource($this->performedBy));
+            }),
+            // Core attributes
+            'type'                    => $this->type,
+            'status'                  => $this->status,
+            'priority'                => $this->priority,
+            'odometer'                => $this->odometer,
+            'engine_hours'            => $this->engine_hours,
+            'summary'                 => $this->summary,
+            'notes'                   => $this->notes,
+            'line_items'              => data_get($this, 'line_items', []),
+            'labor_cost'              => $this->labor_cost,
+            'parts_cost'              => $this->parts_cost,
+            'tax'                     => $this->tax,
+            'total_cost'              => $this->total_cost,
+            'currency'                => $this->currency,
+            'attachments'             => data_get($this, 'attachments', []),
+            'meta'                    => data_get($this, 'meta', (object) []),
+            'slug'                    => $this->slug,
+            // Computed
+            'maintainable_name'       => $this->maintainable_name,
+            'work_order_subject'      => $this->work_order_subject,
+            'performed_by_name'       => $this->performed_by_name,
+            'duration_hours'          => $this->duration_hours,
+            'is_overdue'              => $this->is_overdue,
+            'days_until_due'          => $this->days_until_due,
+            'cost_breakdown'          => $this->cost_breakdown,
+            // Dates
+            'scheduled_at'            => $this->scheduled_at,
+            'started_at'              => $this->started_at,
+            'completed_at'            => $this->completed_at,
+            'updated_at'              => $this->updated_at,
+            'created_at'              => $this->created_at,
+        ]);
+    }
+
+    /**
+     * Inject the abstract 'maintenance-subject' type into the embedded maintainable object
+     * so Ember Data can resolve the correct polymorphic model.
+     *
+     * subject_type must be the Ember Data model name for the concrete subtype,
+     * e.g. 'maintenance-subject-vehicle' or 'maintenance-subject-equipment'.
+     * We use the bare PHP class basename so we get 'vehicle' / 'equipment' rather
+     * than the full 'fleet-ops:vehicle' string that toEmberResourceType() would return.
+     */
+    protected function setMaintainableType(?array $resolved): ?array
+    {
+        if (empty($resolved)) {
+            return $resolved;
+        }
+
+        $bareSlug = Str::kebab(class_basename($this->maintainable_type ?? ''));
+
+        data_set($resolved, 'type', 'maintenance-subject-' . $bareSlug);
+        data_set($resolved, 'subject_type', 'maintenance-subject-' . $bareSlug);
+
+        return $resolved;
+    }
+
+    /**
+     * Inject the abstract 'facilitator' type into the embedded performed_by object
+     * so Ember Data can resolve the correct polymorphic model.
+     *
+     * facilitator_type must be the Ember Data model name for the concrete subtype,
+     * e.g. 'facilitator-vendor' or 'facilitator-contact'.
+     * We use the bare PHP class basename so we get 'vendor' / 'contact' rather
+     * than the full 'fleet-ops:vendor' string that toEmberResourceType() would return.
+     */
+    protected function setPerformedByType(?array $resolved): ?array
+    {
+        if (empty($resolved)) {
+            return $resolved;
+        }
+
+        $bareSlug = Str::kebab(class_basename($this->performed_by_type ?? ''));
+
+        data_set($resolved, 'type', 'facilitator-' . $bareSlug);
+        data_set($resolved, 'facilitator_type', 'facilitator-' . $bareSlug);
+
+        return $resolved;
+    }
+
+    /**
+     * Resolve the appropriate resource transformer for a polymorphic morph target
+     * and return its array representation.
+     */
+    protected function transformMorphResource($model): ?array
+    {
+        if (!$model) {
+            return null;
+        }
+
+        $resourceClass = \Fleetbase\Support\Find::httpResourceForModel($model);
+        if ($resourceClass) {
+            return (new $resourceClass($model))->resolve();
+        }
+
+        return (new \Illuminate\Http\Resources\Json\JsonResource($model))->resolve();
+    }
+}