@fleetbase/fleetops-engine 0.6.64 → 0.6.66

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

@@ -0,0 +1,326 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1;
+
+use Fleetbase\FleetOps\Http\Controllers\FleetOpsController;
+use Fleetbase\FleetOps\Http\Resources\v1\InspectionLink as InspectionLinkResource;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\InspectionForm;
+use Fleetbase\FleetOps\Models\InspectionLink;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Support\InspectionFormSync;
+use Fleetbase\FleetOps\Support\InspectionLinkPin;
+use Fleetbase\Models\User;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class InspectionFormController extends FleetOpsController
+{
+    /**
+     * The resource to query.
+     *
+     * @var string
+     */
+    public $resource = 'inspection-form';
+
+    /**
+     * The builder lays a form out before the form record exists, so the whole
+     * structure arrives with the save that creates it and is written in one
+     * go. `field_groups` is what this console posts; `draft` is what the fliit
+     * builder posts, and is accepted so a form authored there still saves.
+     *
+     * A save that mentions no structure at all leaves the structure alone —
+     * publishing a form, or renaming it, must not empty it.
+     */
+    public function onAfterCreate(Request $request, InspectionForm $inspectionForm): void
+    {
+        $this->syncStructureFromRequest($request, $inspectionForm);
+    }
+
+    public function onAfterUpdate(Request $request, InspectionForm $inspectionForm): void
+    {
+        $this->syncStructureFromRequest($request, $inspectionForm);
+    }
+
+    /** The console edits the structure, so a read has to carry it. */
+    public function onFindRecord($builder, $request): void
+    {
+        $builder->with(['fieldGroups', 'fields']);
+    }
+
+    public function onQueryRecord($builder, $request): void
+    {
+        $builder->with(['fieldGroups', 'fields']);
+    }
+
+    /**
+     * Writes the posted structure, pruning what the post no longer lists —
+     * the builder always posts the whole form, so a field it dropped is a
+     * field the author deleted.
+     */
+    protected function syncStructureFromRequest(Request $request, InspectionForm $form): void
+    {
+        $draft = null;
+        foreach (['inspection_form.field_groups', 'field_groups', 'inspection_form.draft', 'draft'] as $key) {
+            $posted = $request->input($key);
+            if (is_array($posted) && !empty($posted)) {
+                $draft = $posted;
+                break;
+            }
+        }
+
+        if ($draft === null) {
+            return;
+        }
+
+        InspectionFormSync::sync($form, $draft, true);
+        $form->unsetRelation('fieldGroups');
+        $form->unsetRelation('fields');
+        $form->load(['fieldGroups', 'fields']);
+    }
+
+    public function publish(string $id): JsonResponse
+    {
+        $form = $this->resolveForm($id)
+            ->firstOrFail();
+
+        $form->publish();
+
+        return response()->json([
+            'status'  => 'ok',
+            'message' => 'Inspection form published.',
+            'data'    => $form->fresh(),
+        ]);
+    }
+
+    public function archive(string $id): JsonResponse
+    {
+        $form = $this->resolveForm($id)
+            ->firstOrFail();
+
+        $form->archive();
+
+        return response()->json([
+            'status'  => 'ok',
+            'message' => 'Inspection form archived.',
+            'data'    => $form->fresh(),
+        ]);
+    }
+
+    public function generateLink(Request $request, string $id): JsonResponse
+    {
+        $form = $this->resolveForm($id)
+            ->firstOrFail();
+
+        if (!$form->is_published) {
+            return response()->json([
+                'error' => 'Inspection form must be published before generating a public link.',
+            ], 422);
+        }
+
+        $validated = $request->validate([
+            'assignee'     => 'nullable|string',
+            'driver'       => 'nullable|string',
+            'vehicle'      => 'nullable|string',
+            'expires_at'   => 'nullable|date|after:now',
+            'single_use'   => 'nullable|boolean',
+            'pin_delivery' => 'nullable|in:none,email,sms',
+        ]);
+
+        // Who the link is for, and the inspection's driver and vehicle, are
+        // each optional and independent: anyone in the organisation may
+        // complete an inspection, not only a driver.
+        $assignee = $this->resolveAssignee(data_get($validated, 'assignee'));
+        $driver   = $this->resolveDriver(data_get($validated, 'driver'));
+        $vehicle  = $this->resolveVehicle(data_get($validated, 'vehicle'));
+        $delivery = data_get($validated, 'pin_delivery') ?: 'none';
+        $token    = InspectionLink::generateToken();
+
+        // A delivery that cannot happen is refused before anything is minted,
+        // so the dispatcher hears now rather than finding a link nobody got
+        // the PIN for.
+        if ($delivery !== 'none') {
+            $reason = InspectionLinkPin::unavailableReason($assignee ?? $driver?->user, $delivery);
+
+            if ($reason) {
+                return response()->json(['error' => $reason], 422);
+            }
+        }
+
+        $link = InspectionLink::create([
+            'company_uuid'         => $form->company_uuid,
+            'inspection_form_uuid' => $form->uuid,
+            'driver_uuid'          => $driver?->uuid,
+            'vehicle_uuid'         => $vehicle?->uuid,
+            'assignee_uuid'        => $assignee?->uuid,
+            'created_by_uuid'      => session('user'),
+            'token_hash'           => InspectionLink::hashToken($token),
+            'token'                => $token,
+            'status'               => 'active',
+            'single_use'           => data_get($validated, 'single_use', true),
+            // A link nobody put a limit on used to stay live until it was
+            // used or revoked. It now lasts DEFAULT_TTL_HOURS unless chosen.
+            'expires_at'           => data_get($validated, 'expires_at') ?? now()->addHours(InspectionLink::DEFAULT_TTL_HOURS),
+        ]);
+
+        // Every link minted here carries a PIN. It protects anything only when
+        // it travels a different way from the link, which is why a delivery
+        // sends the PIN and never the link.
+        $pin = InspectionLink::generatePin();
+        $link->setPin($pin);
+        $link->save();
+
+        $delivered = $delivery !== 'none' ? InspectionLinkPin::send($link, $delivery) : null;
+
+        // `~/` is what puts the page outside the console: the host app routes
+        // `/~/:slug` at the top level, a sibling of `console`, so neither the
+        // console's chrome nor its authentication gate applies. Without it the
+        // link lands on the authenticated `console/:slug` route instead, which
+        // bounces a signed-out recipient to the login page and renders blank
+        // for everyone else.
+        $path = '/~/inspection?id=' . urlencode($form->public_id ?? $form->uuid) . '&token=' . urlencode($token);
+
+        return response()->json([
+            'status'  => 'ok',
+            'message' => 'Inspection link generated.',
+            'link'    => array_merge(
+                (new InspectionLinkResource($link->fresh(['form', 'driver', 'vehicle', 'assignee', 'createdBy'])))->resolve(),
+                ['path' => $path, 'token' => $token, 'pin' => $pin]
+            ),
+            'pin_delivery' => $delivered,
+        ]);
+    }
+
+    /**
+     * Every link minted for this form, newest first.
+     *
+     * A link used to vanish the moment the modal that minted it closed. An
+     * operator needs to see what is outstanding: which vehicle and driver a
+     * link was for, when it was made, whether it has been opened, and whether
+     * it still works.
+     */
+    public function links(Request $request, string $id): JsonResponse
+    {
+        $form = $this->resolveForm($id)->firstOrFail();
+
+        $links = InspectionLink::where('inspection_form_uuid', $form->uuid)
+            ->with(['form', 'driver', 'vehicle', 'assignee', 'createdBy'])
+            ->orderByDesc('created_at')
+            ->limit((int) $request->input('limit', 50))
+            ->get();
+
+        return response()->json([
+            'links' => InspectionLinkResource::collection($links)->resolve(),
+        ]);
+    }
+
+    /** Take a link out of use, leaving the record of it in the list. */
+    public function revokeLink(Request $request, string $id, string $linkId): JsonResponse
+    {
+        $form = $this->resolveForm($id)->firstOrFail();
+
+        $link = InspectionLink::where('inspection_form_uuid', $form->uuid)
+            ->where(function ($query) use ($linkId) {
+                $query->where('uuid', $linkId)->orWhere('public_id', $linkId);
+
+                if (is_numeric($linkId)) {
+                    $query->orWhere('id', (int) $linkId);
+                }
+            })
+            ->firstOrFail();
+
+        $link->revoke();
+
+        return response()->json([
+            'status'  => 'ok',
+            'message' => 'Inspection link revoked.',
+            'link'    => (new InspectionLinkResource($link->fresh(['form', 'driver', 'vehicle', 'createdBy'])))->resolve(),
+        ]);
+    }
+
+    /**
+     * Send a link's PIN again, by email or SMS, to whoever the link is for.
+     * A failed delivery answers 200 with `pin_delivery.sent` false and why, so
+     * the console shows it as a warning rather than an error.
+     */
+    public function sendPin(Request $request, string $id, string $linkId): JsonResponse
+    {
+        $form      = $this->resolveForm($id)->firstOrFail();
+        $validated = $request->validate(['via' => 'required|in:email,sms']);
+
+        $link = InspectionLink::where('inspection_form_uuid', $form->uuid)
+            ->where(function ($query) use ($linkId) {
+                $query->where('uuid', $linkId)->orWhere('public_id', $linkId);
+            })
+            ->firstOrFail();
+
+        if ($link->state !== 'active') {
+            return response()->json(['error' => 'Only an active link can have its PIN sent.'], 422);
+        }
+
+        $reason = InspectionLinkPin::unavailableReason(InspectionLinkPin::recipientFor($link), $validated['via']);
+
+        if ($reason) {
+            return response()->json(['error' => $reason], 422);
+        }
+
+        $result = InspectionLinkPin::send($link, $validated['via']);
+
+        return response()->json([
+            'status'       => $result['sent'] ? 'ok' : 'error',
+            'message'      => $result['sent'] ? 'PIN sent.' : $result['error'],
+            'pin_delivery' => $result,
+            'link'         => (new InspectionLinkResource($link->fresh(['form', 'driver', 'vehicle', 'assignee', 'createdBy'])))->resolve(),
+        ]);
+    }
+
+    /** A user a link may be assigned to: only a member of this organisation. */
+    protected function resolveAssignee(?string $id): ?User
+    {
+        if (!$id) {
+            return null;
+        }
+
+        return User::where(function ($query) use ($id) {
+            $query->where('uuid', $id)->orWhere('public_id', $id);
+        })
+            ->whereHas('companyUsers', function ($query) {
+                $query->where('company_uuid', session('company'));
+            })
+            ->firstOrFail();
+    }
+
+    protected function resolveDriver(?string $id): ?Driver
+    {
+        if (!$id) {
+            return null;
+        }
+
+        return Driver::where('company_uuid', session('company'))
+            ->where(function ($query) use ($id) {
+                $query->where('uuid', $id)->orWhere('public_id', $id);
+            })
+            ->firstOrFail();
+    }
+
+    protected function resolveForm(string $id)
+    {
+        return InspectionForm::where('company_uuid', session('company'))
+            ->where(function ($query) use ($id) {
+                $query->where('uuid', $id)->orWhere('public_id', $id);
+            });
+    }
+
+    protected function resolveVehicle(?string $id): ?Vehicle
+    {
+        if (!$id) {
+            return null;
+        }
+
+        return Vehicle::where('company_uuid', session('company'))
+            ->where(function ($query) use ($id) {
+                $query->where('uuid', $id)->orWhere('public_id', $id);
+            })
+            ->firstOrFail();
+    }
+}

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

@@ -0,0 +1,229 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers\Internal\v1;
+
+use Fleetbase\FleetOps\Exports\InspectionExport;
+use Fleetbase\FleetOps\Http\Controllers\FleetOpsController;
+use Fleetbase\FleetOps\Models\InspectionItemResult;
+use Fleetbase\FleetOps\Models\InspectionSubmission;
+use Fleetbase\FleetOps\Support\InspectionSubmitter;
+use Fleetbase\Http\Requests\ExportRequest;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Str;
+
+class InspectionSubmissionController extends FleetOpsController
+{
+    /**
+     * The resource to query.
+     *
+     * @var string
+     */
+    public $resource = 'inspection-submission';
+
+    /** What a submission has to carry for the console record to render. */
+    protected const RELATIONS = ['form', 'vehicle', 'driver', 'itemResults', 'customFieldValues.customField', 'files'];
+
+    public function onAfterCreate($request, InspectionSubmission $record, array $input): void
+    {
+        // Filed from the console, a submission is the signed-in user's. It
+        // used to be nobody's, so issues and work orders raised from its
+        // failures had no reporter either.
+        if (!$record->submitted_by_uuid && session('user')) {
+            $record->forceFill(['submitted_by_uuid' => session('user')])->save();
+        }
+
+        $this->syncAnswersFromRequest($request, $record);
+        $record->load(array_merge(['submittedBy'], static::RELATIONS));
+    }
+
+    public function onAfterUpdate($request, InspectionSubmission $record, array $input): void
+    {
+        $this->syncAnswersFromRequest($request, $record);
+        $record->load(static::RELATIONS);
+    }
+
+    public function onFindRecord($builder, $request): void
+    {
+        $builder->with(array_merge(['submittedBy', 'issue', 'workOrder'], static::RELATIONS));
+    }
+
+    public function onQueryRecord($builder, $request): void
+    {
+        $builder->with(['form', 'vehicle', 'driver', 'itemResults']);
+    }
+
+    /**
+     * The answers, then the results derived from them.
+     *
+     * A form built from fields is answered with `custom_field_values`, exactly
+     * as the driver API answers it, so the console and the app write the same
+     * rows; the submitter stores any photo or signature and mirrors every
+     * pass-fail answer into an item result. A submission against a legacy
+     * checklist still posts `item_results` directly, and that door stays open.
+     */
+    protected function syncAnswersFromRequest(Request $request, InspectionSubmission $submission): void
+    {
+        $values = static::arrayInput($request, 'inspection_submission.custom_field_values', 'custom_field_values');
+        if (!empty($values)) {
+            InspectionSubmitter::applyCustomFieldValues($submission, $values, session('user'));
+
+            return;
+        }
+
+        $this->syncItemResultsFromRequest($request, $submission);
+    }
+
+    /**
+     * The first of the given keys that carries a list.
+     *
+     * The console posts a record under its resource name and the app posts it
+     * flat, so both spellings are read. `Request::array()` arrived in Laravel
+     * 11 and this runs on 10, where calling it is a BadMethodCallException.
+     *
+     * @return array<int, mixed>
+     */
+    protected static function arrayInput(Request $request, string ...$keys): array
+    {
+        foreach ($keys as $key) {
+            $value = $request->input($key);
+            if (is_array($value) && !empty($value)) {
+                return $value;
+            }
+        }
+
+        return [];
+    }
+
+    /**
+     * Export inspections to excel or csv.
+     *
+     * @return \Illuminate\Http\Response
+     */
+    public function export(ExportRequest $request)
+    {
+        $format     = $request->input('format', 'xlsx');
+        $selections = static::arrayInput($request, 'selections');
+        $fileName   = trim(Str::slug('inspections-' . date('Y-m-d-H:i')) . '.' . $format);
+
+        return $this->downloadExport(new InspectionExport($selections), $fileName);
+    }
+
+    public function submit(string $id): JsonResponse
+    {
+        $submission = InspectionSubmission::where('uuid', $id)
+            ->orWhere('public_id', $id)
+            ->with(['itemResults', 'vehicle', 'driver', 'form'])
+            ->firstOrFail();
+
+        $submission->syncResultCounts();
+
+        return response()->json([
+            'status'  => 'ok',
+            'message' => 'Inspection submitted.',
+            'data'    => $submission->fresh(['itemResults', 'vehicle', 'driver', 'form']),
+        ]);
+    }
+
+    public function createIssue(string $id): JsonResponse
+    {
+        $submission = InspectionSubmission::where('uuid', $id)
+            ->orWhere('public_id', $id)
+            ->with(['itemResults', 'vehicle', 'driver', 'form'])
+            ->firstOrFail();
+
+        $submission->syncResultCounts();
+        $issue = $submission->createIssueFromFailures();
+
+        return response()->json([
+            'status'  => 'ok',
+            'message' => $issue ? 'Issue created from failed inspection items.' : 'No failed inspection items found.',
+            'issue'   => $issue,
+            'data'    => $submission->fresh(['itemResults', 'issue']),
+        ]);
+    }
+
+    public function createWorkOrder(string $id): JsonResponse
+    {
+        $submission = InspectionSubmission::where('uuid', $id)
+            ->orWhere('public_id', $id)
+            ->with(['itemResults', 'vehicle', 'driver', 'form'])
+            ->firstOrFail();
+
+        $submission->syncResultCounts();
+        $submission->createIssueFromFailures();
+        $workOrder = $submission->createWorkOrderFromFailures();
+
+        return response()->json([
+            'status'     => 'ok',
+            'message'    => $workOrder ? 'Work order created from failed inspection items.' : 'No failed inspection items found.',
+            'work_order' => $workOrder,
+            'data'       => $submission->fresh(['itemResults', 'issue', 'workOrder']),
+        ]);
+    }
+
+    public function resolve(string $id): JsonResponse
+    {
+        $submission = InspectionSubmission::where('uuid', $id)
+            ->orWhere('public_id', $id)
+            ->firstOrFail();
+
+        $submission->update([
+            'status'      => 'resolved',
+            'resolved_at' => now(),
+        ]);
+
+        return response()->json([
+            'status'  => 'ok',
+            'message' => 'Inspection resolved.',
+            'data'    => $submission->fresh(['itemResults', 'issue', 'workOrder']),
+        ]);
+    }
+
+    protected function syncItemResultsFromRequest(Request $request, InspectionSubmission $submission): void
+    {
+        $items = static::arrayInput($request, 'inspection_submission.item_results', 'item_results');
+        if (empty($items)) {
+            return;
+        }
+
+        $seen = [];
+        foreach ($items as $item) {
+            $uuid    = data_get($item, 'uuid');
+            $payload = [
+                'company_uuid'               => $submission->company_uuid,
+                'inspection_submission_uuid' => $submission->uuid,
+                'item_key'                   => data_get($item, 'item_key'),
+                'label'                      => data_get($item, 'label', data_get($item, 'title', 'Inspection item')),
+                'category'                   => data_get($item, 'category'),
+                'status'                     => data_get($item, 'status', data_get($item, 'passed') === false ? 'failed' : 'passed'),
+                'severity'                   => data_get($item, 'severity'),
+                'passed'                     => (bool) data_get($item, 'passed', data_get($item, 'status') !== 'failed'),
+                'comments'                   => data_get($item, 'comments'),
+                'photos'                     => data_get($item, 'photos'),
+                'meta'                       => data_get($item, 'meta'),
+            ];
+
+            $lookup = [
+                'inspection_submission_uuid' => $submission->uuid,
+            ];
+
+            if ($uuid) {
+                $lookup['uuid'] = $uuid;
+            } elseif ($payload['item_key']) {
+                $lookup['item_key'] = $payload['item_key'];
+            } else {
+                $lookup['label'] = $payload['label'];
+            }
+
+            $result = InspectionItemResult::updateOrCreate($lookup, $payload);
+            $seen[] = $result->uuid;
+        }
+
+        if (!empty($seen)) {
+            $submission->itemResults()->whereNotIn('uuid', $seen)->delete();
+        }
+
+        $submission->syncResultCounts();
+    }
+}

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

@@ -176,7 +176,7 @@ class LiveController extends Controller
         return LiveCacheService::remember('vehicles', $cacheParams, function () use ($bounds, $limit) {
             // Fetch vehicles that are online
             $query = Vehicle::where(['company_uuid' => session('company')])
-                ->with(['devices', 'driver'])
+                ->with(['devices', 'driver', 'currentTrailers'])
                 ->applyDirectivesForPermissions('fleet-ops list vehicle');
 
             $this->applyLiveLocationGuards($query);