@fleetbase/fleetops-engine 0.6.64 → 0.6.66

package/addon/utils/device-table-columns.js

@@ -1,3 +1,6 @@
+import { buildIdentityStub } from './identity-cell-resource';
+import relationValue from './relation-value';
+
 const connectionStatusOptions = [
     { label: 'Online', value: 'online' },
     { label: 'Recently Offline', value: 'recently_offline' },
@@ -31,14 +34,13 @@ export default function buildDeviceTableColumns(controller, options = {}) {
             valuePath: 'displayName',
             cellComponent: 'cell/device-identity',
             action: viewDevice,
-            compact: true,
             permission: 'fleet-ops view device',
             resizable: true,
             sortable: true,
             filterable: true,
             filterParam: 'query',
             filterComponent: 'filter/string',
-            showStatus: showDeviceStatus,
+            showStatusDot: showDeviceStatus,
         },
         {
             label: 'Connection',
@@ -64,37 +66,26 @@ export default function buildDeviceTableColumns(controller, options = {}) {
         filterComponent: 'filter/string',
     };
     const vehicleColumn = {
-        label: 'Vehicle',
+        label: controller.intl?.t('device.attachment.asset') ?? 'Attached asset',
         valuePath: 'attached_to_name',
-        cellComponent: 'cell/vehicle-identity',
-        action: async (vehicle) => {
-            const resolvedVehicle = vehicle?.loadResource ? ((await vehicle.loadResource()) ?? vehicle) : vehicle;
-
-            if (resolvedVehicle?.id && controller.vehicleActions?.panel?.view) {
-                return controller.vehicleActions.panel.view(resolvedVehicle);
-            }
-        },
-        compact: true,
+        cellComponent: 'cell/attachable-identity',
         permission: 'fleet-ops view vehicle',
-        showStatusBadge: true,
         emptyText: '-',
         resourcePath: (device) => {
             const attachableType = `${device?.attachable_type ?? ''}`.toLowerCase();
 
-            if (!device?.attachable_uuid || (attachableType && !attachableType.includes('vehicle'))) {
+            if (!device?.attachable_uuid || (attachableType && !attachableType.includes('vehicle') && !attachableType.includes('trailer'))) {
                 return null;
             }
 
             return (
-                device.attachable ?? {
-                    id: device.attachable_uuid,
-                    displayName: device.attached_to_name,
-                    display_name: device.attached_to_name,
-                    name: device.attached_to_name,
-                    public_id: device.attachable_uuid,
-                    vehicle_number: device.plate_number ?? device.call_sign ?? device.vehicle_number ?? device.attachable_uuid,
-                    loadResource: () => controller.resolveAttachedVehicle?.(device),
-                }
+                relationValue(device, 'attachable') ??
+                buildIdentityStub(device, {
+                    type: attachableType.includes('trailer') ? 'trailer' : 'vehicle',
+                    nameKey: 'attached_to_name',
+                    load: () => controller.resolveAttachedVehicle?.(device),
+                    extra: { plate_number: device.plate_number ?? device.call_sign ?? null },
+                })
             );
         },
         resizable: true,
@@ -111,8 +102,8 @@ export default function buildDeviceTableColumns(controller, options = {}) {
         columns.push({
             label: 'Telematic Provider',
             valuePath: 'telematic_name',
-            cellComponent: 'cell/telematic-provider',
-            compact: true,
+            cellComponent: 'cell/telematic-identity',
+            resourcePath: (device) => relationValue(device, 'telematic') ?? buildIdentityStub(device, { type: 'telematic', load: () => device.get('telematic') }),
             action: controller.openTelematic,
             permission: 'fleet-ops view telematic',
             resizable: true,
@@ -166,6 +157,8 @@ export default function buildDeviceTableColumns(controller, options = {}) {
             filterParam: 'type',
             filterComponent: 'filter/multi-option',
             filterOptions: controller.deviceTypeOptions,
+            filterOptionLabel: 'label',
+            filterOptionValue: 'value',
         },
         {
             label: 'Serial Number',
@@ -188,6 +181,8 @@ export default function buildDeviceTableColumns(controller, options = {}) {
             filterParam: 'status',
             filterComponent: 'filter/multi-option',
             filterOptions: controller.deviceStatusOptions,
+            filterOptionLabel: 'label',
+            filterOptionValue: 'value',
         },
         {
             label: 'Attachment',
@@ -238,12 +233,12 @@ export default function buildDeviceTableColumns(controller, options = {}) {
                     permission: 'fleet-ops update device',
                 },
                 {
-                    label: 'Attach or change vehicle',
+                    label: controller.intl.t('device.attachment.attach-or-change'),
                     fn: controller.openAttachDeviceModal ?? controller.deviceActions.attachToVehicle,
                     permission: 'fleet-ops update device',
                 },
                 {
-                    label: controller.intl.t('device.actions.detach-from-vehicle'),
+                    label: controller.intl.t('device.attachment.detach'),
                     fn: controller.deviceActions.detachFromVehicle,
                     permission: 'fleet-ops update device',
                     isVisible: controller.hasAttachedVehicle,
@@ -253,13 +248,13 @@ export default function buildDeviceTableColumns(controller, options = {}) {
                     isVisible: controller.hasAttachedVehicle,
                 },
                 {
-                    label: 'View attached vehicle',
+                    label: controller.intl.t('device.attachment.view-attached'),
                     fn: controller.viewAttachedVehicle,
                     permission: 'fleet-ops view vehicle',
                     isVisible: controller.hasAttachedVehicle,
                 },
                 {
-                    label: 'Locate attached vehicle on map',
+                    label: controller.intl.t('device.attachment.locate-attached'),
                     fn: controller.locateAttachedVehicle,
                     permission: 'fleet-ops view vehicle',
                     isVisible: controller.hasAttachedVehicle,

package/addon/utils/fleet-ops-options.js

@@ -216,6 +216,41 @@ export const fuelReportStatuses = [
     { label: 'Reimbursed', value: 'reimbursed', description: 'Driver expense reimbursed' },
 ];
 
+export const inspectionFormTypes = [
+    { label: 'DVIR', value: 'dvir', description: 'Driver vehicle inspection report — the daily walk-round a driver signs.' },
+    { label: 'Pre-Trip', value: 'pre_trip', description: 'Completed before the vehicle leaves.' },
+    { label: 'Post-Trip', value: 'post_trip', description: 'Completed when the vehicle returns.' },
+    { label: 'Pre-Operational', value: 'pre_operational', description: 'Checks performed before operation begins.' },
+    { label: 'Post-Operational', value: 'post_operational', description: 'Checks performed after operation ends.' },
+    { label: 'Safety Inspection', value: 'safety_inspection', description: 'Comprehensive safety and compliance inspection.' },
+    { label: 'Maintenance Inspection', value: 'maintenance_inspection', description: 'Scheduled maintenance check and service inspection.' },
+    { label: 'Damage Assessment', value: 'damage_assessment', description: 'Inspection to assess damage or condition issues.' },
+    { label: 'Annual Inspection', value: 'annual_inspection', description: 'Yearly comprehensive vehicle inspection.' },
+    { label: 'Safety', value: 'safety', description: 'General safety checklist.' },
+    { label: 'Compliance', value: 'compliance', description: 'Regulatory or audit checklist.' },
+    { label: 'Maintenance', value: 'maintenance', description: 'Workshop or technician checklist.' },
+];
+
+export const inspectionFormStatuses = [
+    { label: 'Draft', value: 'draft', description: 'Still being written. Drivers cannot see it.' },
+    { label: 'Published', value: 'published', description: 'Available to drivers and to the public link.' },
+    { label: 'Archived', value: 'archived', description: 'Retired. Kept for the records already filed against it.' },
+];
+
+export const inspectionSeverities = [
+    { label: 'Minor', value: 'low', description: 'Monitor it. Nothing stops.' },
+    { label: 'Medium', value: 'medium', description: 'Book it in.' },
+    { label: 'High', value: 'high', description: 'Unsafe. Needs attention before the next trip.' },
+    { label: 'Critical', value: 'critical', description: 'Immobilise the vehicle.' },
+];
+
+export const inspectionSubmissionStatuses = [
+    { label: 'Draft', value: 'draft', description: 'Started but not filed.' },
+    { label: 'Submitted', value: 'submitted', description: 'Filed by the driver or the console.' },
+    { label: 'Needs Review', value: 'needs_review', description: 'Flagged for a supervisor to look at.' },
+    { label: 'Resolved', value: 'resolved', description: 'Follow-up is complete.' },
+];
+
 export const workOrderStatuses = [
     { label: 'Open', value: 'open', description: 'Work order has been created and is awaiting planning or assignment' },
     { label: 'Scheduled', value: 'scheduled', description: 'Work has been planned for a specific service window' },
@@ -945,6 +980,11 @@ export default function fleetOpsOptions(key) {
         routingConstraintOptions,
         serviceTimePresets,
         importColumnMappings,
+        // Inspections
+        inspectionFormTypes,
+        inspectionFormStatuses,
+        inspectionSeverities,
+        inspectionSubmissionStatuses,
     };
 
     return allOptions[key] ?? [];

package/addon/utils/fuel-integration-format.js

@@ -0,0 +1,43 @@
+export function fuelDate(value, fallback = 'Not yet') {
+    if (!value) return fallback;
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) return fallback;
+    const pad = (number) => String(number).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+export function fuelNumber(value) {
+    return Number(value ?? 0).toLocaleString('en-US', { maximumFractionDigits: 2 });
+}
+
+export function fuelMoney(amount, currency) {
+    return `${currency || 'SAR'} ${fuelNumber(Number(amount ?? 0) / 100)}`;
+}
+
+export function syncRunView(run) {
+    const received = run.summary?.received ?? Number(run.imported ?? 0) + Number(run.summary?.updated ?? 0);
+    const pending = ['queued', 'running'].includes(run.status);
+    const waiting = run.status === 'queued' && Date.now() - new Date(run.created_at).getTime() > 120000;
+    const labels = { queued: 'Queued', running: 'Importing', completed: 'Completed', error: 'Failed' };
+    return {
+        ...run,
+        pending,
+        label: labels[run.status] ?? run.status,
+        tone: run.status === 'error' ? 'danger' : pending ? 'warning' : 'success',
+        date: fuelDate(run.finished_at || run.started_at || run.created_at),
+        window: run.from && run.to ? `${String(run.from).slice(0, 10)} – ${String(run.to).slice(0, 10)}` : 'Date range unavailable for this earlier run',
+        result:
+            run.status === 'error'
+                ? run.error || 'The import failed. Retry this date range.'
+                : waiting
+                  ? 'Still queued. Check that the background worker is running.'
+                  : run.status === 'queued'
+                    ? 'Waiting for the background worker.'
+                    : run.status === 'running'
+                      ? 'Reading transactions from the provider.'
+                      : received === 0
+                        ? 'No transactions returned for this date range.'
+                        : `${fuelNumber(run.imported)} new · ${fuelNumber(run.summary?.updated)} updated · ${fuelNumber(run.unmatched)} need matching`,
+        received,
+    };
+}

package/addon/utils/fuel-transaction.js

@@ -0,0 +1,115 @@
+import { fuelDate, fuelMoney } from './fuel-integration-format';
+
+export const transactionStatuses = {
+    imported: { label: 'Imported', tone: 'info' },
+    matched: { label: 'Matched', tone: 'success' },
+    unmatched: { label: 'Unmatched', tone: 'warning' },
+    reviewed: { label: 'Reviewed', tone: 'success' },
+    ignored: { label: 'Ignored', tone: 'default' },
+    duplicate: { label: 'Duplicate', tone: 'warning' },
+    error: { label: 'Error', tone: 'error' },
+};
+
+export const transactionActions = {
+    vehicle: {
+        title: 'Match to Vehicle',
+        description: 'Choose the vehicle for this purchase. Confirming replaces the current vehicle match and may create a Fuel Report according to the integration settings.',
+    },
+    order: {
+        title: 'Match to Order',
+        description: 'Choose the order or trip for this purchase. Confirming replaces the current order link. The vehicle match and review status are unchanged.',
+    },
+    reprocess: {
+        title: 'Reprocess / Rematch',
+        description:
+            'Run the integration’s matching rules again for missing matches. Existing vehicle and order links are kept. Reviewed or ignored status will be replaced with Matched or Unmatched. A Fuel Report may be created if enabled in the integration settings.',
+    },
+    ignored: {
+        title: 'Ignore Transaction',
+        description:
+            'Exclude this purchase from automatic matching while keeping it in the ledger. Existing matches and Fuel Reports are kept. You can reprocess it later to resume matching.',
+    },
+    reviewed: { title: 'Mark Reviewed', description: 'Confirm that you have checked this purchase. This updates its review status without changing its vehicle, order, or Fuel Report.' },
+};
+
+export function openTransactionAction(modalsManager, mode, transactions, onSaved) {
+    const records = Array.isArray(transactions) ? transactions : [transactions];
+    if (!records.length || !transactionActions[mode]) return;
+    return modalsManager.show('modals/fuel-transaction-action', {
+        title: transactionActions[mode].title,
+        acceptButtonText: transactionActions[mode].title,
+        acceptButtonType: mode === 'ignored' ? 'danger' : 'primary',
+        declineButtonText: 'Cancel',
+        keepOpen: true,
+        mode,
+        transactions: records,
+        onSaved,
+    });
+}
+
+export async function loadTransactionOrder(store, transaction) {
+    const orderId = transaction?.order_uuid;
+
+    if (!orderId) {
+        return null;
+    }
+
+    // The transaction response carries the foreign key without an order relationship.
+    const order = await store.findRecord('order', orderId, { reload: true });
+
+    if (transaction.order_uuid !== orderId) {
+        return null;
+    }
+
+    transaction.set('order', order);
+    return order;
+}
+
+const present = (value) => ['string', 'number'].includes(typeof value) && String(value).trim() !== '';
+const text = (value) => (present(value) ? String(value).trim() : null);
+
+// Only named purchase fields are presented. Unknown payload objects, provider codes,
+// credentials and other integration internals never become operator-facing content.
+export function purchaseGroups(transaction) {
+    const normalized = transaction.normalized_payload ?? {};
+    const raw = transaction.raw_payload ?? {};
+    const value = (...keys) => keys.flatMap((key) => [normalized[key], raw[key]]).find(present);
+    const group = (title, rows) => ({ title, rows: rows.filter(([, value]) => present(value)).map(([label, value]) => ({ label, value: text(value) })) });
+    const petroapp = transaction.provider === 'petroapp';
+    const groups = [
+        group('Purchase', [
+            ['Bill number', transaction.provider_transaction_id],
+            ['Purchased at', transaction.transaction_at ? fuelDate(transaction.transaction_at, 'Unavailable') : null],
+            ['Amount', present(transaction.amount) ? fuelMoney(transaction.amount, transaction.currency) : null],
+            ['Quantity', present(transaction.volume) ? `${transaction.volume} ${transaction.metric_unit || 'L'}` : null],
+            ['Fuel type', value('fuel_type', 'product_name', 'fuel_grade')],
+            ['Payment method', value('payment_method_text', 'payment_method_name')],
+            ['Odometer', transaction.odometer],
+            ['Invoice number', value('invoice_number')],
+            [
+                'Amount before VAT',
+                petroapp && present(raw.cost_before_vat) ? `${transaction.currency || 'SAR'} ${Number(raw.cost_before_vat).toLocaleString('en-US', { maximumFractionDigits: 3 })}` : null,
+            ],
+            ['VAT rate', petroapp && present(raw.vat_percent) ? `${Number(raw.vat_percent) * 100}%` : null],
+        ]),
+        group('Station & account', [
+            ['Station', transaction.station_name],
+            ['City', value('city')],
+            ['District', value('district')],
+            ['Account branch', value('branch_name')],
+            ['Representative', value('delegate_name')],
+            ['Representative phone', petroapp ? value('delegate_mobile') : null],
+        ]),
+        group('Vehicle & trip references', [
+            ['Plate number', transaction.plate_number],
+            ['Fuel card', transaction.vehicle_card_id],
+            ['Internal number', transaction.internal_number],
+            ['Structure number', transaction.structure_number],
+            ['Trip number', transaction.trip_number],
+            ['VIN', value('vin', 'vin_number')],
+            ['Serial number', value('serial_number')],
+            ['Call sign', value('call_sign')],
+        ]),
+    ];
+    return groups.filter((group) => group.rows.length);
+}

package/addon/utils/identity-cell-resource.js

@@ -18,3 +18,59 @@ export function resolveIdentityCellResource(args) {
 
     return args.row;
 }
+
+const inflight = new WeakMap();
+
+/**
+ * A stand-in for a related record a row only knows by name: enough for an
+ * identity cell to render (`name`, `resourceType`) and a `loadResource()`
+ * the cell, pill or summary calls when the real record is needed. The
+ * stub never carries a UUID in an identifier field, so nothing renders one
+ * as a plate or an id, and concurrent loads of the same row share one
+ * request.
+ *
+ * `load` receives the row and returns the record (or a promise of it); with
+ * no `load`, `loadResource()` resolves to null and the stub stays static.
+ */
+export function buildIdentityStub(row, { type, nameKey = `${type}_name`, name, load, extra = {} } = {}) {
+    const label = name ?? (row ? get(row, nameKey) : null);
+
+    if (!label) {
+        return null;
+    }
+
+    const stub = {
+        ...extra,
+        name: label,
+        display_name: label,
+        displayName: label,
+        resourceType: type,
+        isIdentityStub: true,
+        loadResource: async () => {
+            if (typeof load !== 'function') {
+                return null;
+            }
+
+            let loads = inflight.get(row);
+
+            if (!loads) {
+                loads = new Map();
+                inflight.set(row, loads);
+            }
+
+            if (!loads.has(type)) {
+                loads.set(
+                    type,
+                    Promise.resolve()
+                        .then(() => load(row))
+                        .catch(() => null)
+                        .finally(() => loads.delete(type))
+                );
+            }
+
+            return loads.get(type);
+        },
+    };
+
+    return stub;
+}