@fleetbase/fleetops-engine 0.6.53 → 0.6.55

package/addon/templates/settings/routing.hbs

@@ -64,6 +64,7 @@
                     <div class="fleetbase-model-select fleetbase-power-select ember-model-select">
                         <PowerSelectMultiple
                             @searchEnabled={{true}}
+                            @searchField="label"
                             @options={{this.trackingProviderOptions}}
                             @selected={{this.selectedTrackingFallbackOptions}}
                             @onChange={{this.setTrackingFallbacks}}

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

@@ -0,0 +1,288 @@
+const connectionStatusOptions = [
+    { label: 'Online', value: 'online' },
+    { label: 'Recently Offline', value: 'recently_offline' },
+    { label: 'Offline', value: 'offline' },
+    { label: 'Long Offline', value: 'long_offline' },
+    { label: 'Never Connected', value: 'never_connected' },
+];
+
+const attachmentStateOptions = [
+    { label: 'Attached', value: 'attached' },
+    { label: 'Unattached', value: 'unattached' },
+];
+
+export { connectionStatusOptions, attachmentStateOptions };
+
+export default function buildDeviceTableColumns(controller, options = {}) {
+    const { showProvider = true, showActions = true, deviceActionMode = 'route', showDeviceStatus = true } = options;
+    const viewDevice =
+        deviceActionMode === 'panel'
+            ? (controller.deviceActions.panel?.view ?? controller.deviceActions.transition?.view)
+            : (controller.deviceActions.transition?.view ?? controller.deviceActions.panel?.view);
+    const editDevice =
+        deviceActionMode === 'panel'
+            ? (controller.deviceActions.panel?.edit ?? controller.deviceActions.transition?.edit)
+            : (controller.deviceActions.transition?.edit ?? controller.deviceActions.panel?.edit);
+
+    const columns = [
+        {
+            sticky: true,
+            label: 'Telematic Device',
+            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,
+        },
+        {
+            label: 'Connection',
+            valuePath: 'connection_status',
+            cellComponent: 'table/cell/status',
+            resizable: true,
+            sortable: false,
+            filterable: true,
+            filterParam: 'connection_status',
+            filterComponent: 'filter/multi-option',
+            filterOptions: connectionStatusOptions,
+            filterOptionLabel: 'label',
+            filterOptionValue: 'value',
+        },
+    ];
+    const providerIdColumn = {
+        label: 'Provider ID / IMEI',
+        valuePath: 'device_id',
+        resizable: true,
+        sortable: true,
+        filterable: true,
+        filterParam: 'device_id',
+        filterComponent: 'filter/string',
+    };
+    const vehicleColumn = {
+        label: 'Vehicle',
+        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,
+        permission: 'fleet-ops view vehicle',
+        showStatusBadge: true,
+        emptyText: '-',
+        resourcePath: (device) => {
+            const attachableType = `${device?.attachable_type ?? ''}`.toLowerCase();
+
+            if (!device?.attachable_uuid || (attachableType && !attachableType.includes('vehicle'))) {
+                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),
+                }
+            );
+        },
+        resizable: true,
+        sortable: false,
+        filterable: true,
+        filterParam: 'vehicle',
+        filterComponent: 'filter/model',
+        filterComponentPlaceholder: 'Select vehicle',
+        model: 'vehicle',
+        modelNamePath: 'displayName',
+    };
+
+    if (showProvider) {
+        columns.push({
+            label: 'Telematic Provider',
+            valuePath: 'telematic_name',
+            cellComponent: 'cell/telematic-provider',
+            compact: true,
+            action: controller.openTelematic,
+            permission: 'fleet-ops view telematic',
+            resizable: true,
+            sortable: false,
+            filterable: true,
+            filterParam: 'telematic',
+            filterComponent: 'filter/model',
+            filterComponentPlaceholder: 'Select telematic',
+            model: 'telematic',
+        });
+        columns.push(vehicleColumn, providerIdColumn);
+    } else {
+        columns.push(providerIdColumn, vehicleColumn);
+    }
+
+    columns.push(
+        {
+            label: 'Sensors',
+            valuePath: 'sensors_count',
+            resizable: true,
+            sortable: false,
+            filterable: false,
+        },
+        {
+            label: 'Last Seen',
+            valuePath: 'lastOnlineAt',
+            sortParam: 'last_online_at',
+            resizable: true,
+            sortable: true,
+            filterable: true,
+            filterParam: 'last_online_at',
+            filterComponent: 'filter/date',
+        },
+        {
+            label: 'Provider',
+            valuePath: 'provider',
+            hidden: true,
+            resizable: true,
+            sortable: true,
+            filterable: true,
+            filterParam: 'provider',
+            filterComponent: 'filter/string',
+        },
+        {
+            label: 'Type',
+            valuePath: 'type',
+            hidden: true,
+            resizable: true,
+            sortable: true,
+            filterable: true,
+            filterParam: 'type',
+            filterComponent: 'filter/multi-option',
+            filterOptions: controller.deviceTypeOptions,
+        },
+        {
+            label: 'Serial Number',
+            valuePath: 'serial_number',
+            hidden: true,
+            resizable: true,
+            sortable: true,
+            filterable: true,
+            filterParam: 'serial_number',
+            filterComponent: 'filter/string',
+        },
+        {
+            label: controller.intl.t('column.status'),
+            valuePath: 'status',
+            cellComponent: 'table/cell/status',
+            hidden: true,
+            resizable: true,
+            sortable: true,
+            filterable: true,
+            filterParam: 'status',
+            filterComponent: 'filter/multi-option',
+            filterOptions: controller.deviceStatusOptions,
+        },
+        {
+            label: 'Attachment',
+            valuePath: 'attachable_uuid',
+            hidden: true,
+            resizable: true,
+            sortable: false,
+            filterable: true,
+            filterParam: 'attachment_state',
+            filterComponent: 'filter/select',
+            filterOptions: attachmentStateOptions,
+            filterOptionLabel: 'label',
+            filterOptionValue: 'value',
+        },
+        {
+            label: controller.intl.t('column.updated-at'),
+            valuePath: 'updatedAt',
+            sortParam: 'updated_at',
+            resizable: true,
+            sortable: true,
+            hidden: true,
+            filterable: true,
+            filterComponent: 'filter/date',
+        }
+    );
+
+    if (showActions) {
+        columns.push({
+            label: '',
+            cellComponent: 'table/cell/dropdown',
+            ddButtonText: false,
+            ddButtonIcon: 'ellipsis-h',
+            ddButtonIconPrefix: 'fas',
+            ddMenuLabel: controller.intl.t('common.resource-actions', { resource: controller.intl.t('resource.device') }),
+            cellClassNames: 'overflow-visible align-middle',
+            wrapperClass: 'flex items-center justify-end mx-2',
+            sticky: 'right',
+            width: 60,
+            actions: [
+                {
+                    label: controller.intl.t('common.view-resource', { resource: controller.intl.t('resource.device') }),
+                    fn: viewDevice,
+                    permission: 'fleet-ops view device',
+                },
+                {
+                    label: controller.intl.t('common.edit-resource', { resource: controller.intl.t('resource.device') }),
+                    fn: editDevice,
+                    permission: 'fleet-ops update device',
+                },
+                {
+                    label: 'Attach or change vehicle',
+                    fn: controller.openAttachDeviceModal ?? controller.deviceActions.attachToVehicle,
+                    permission: 'fleet-ops update device',
+                },
+                {
+                    label: controller.intl.t('device.actions.detach-from-vehicle'),
+                    fn: controller.deviceActions.detachFromVehicle,
+                    permission: 'fleet-ops update device',
+                    isVisible: controller.hasAttachedVehicle,
+                },
+                {
+                    separator: true,
+                    isVisible: controller.hasAttachedVehicle,
+                },
+                {
+                    label: 'View attached vehicle',
+                    fn: controller.viewAttachedVehicle,
+                    permission: 'fleet-ops view vehicle',
+                    isVisible: controller.hasAttachedVehicle,
+                },
+                {
+                    label: 'Locate attached vehicle on map',
+                    fn: controller.locateAttachedVehicle,
+                    permission: 'fleet-ops view vehicle',
+                    isVisible: controller.hasAttachedVehicle,
+                },
+                ...(controller.openDeviceEvents
+                    ? [
+                          {
+                              separator: true,
+                          },
+                          {
+                              label: 'Review recent events',
+                              fn: controller.openDeviceEvents,
+                              permission: 'fleet-ops view device-event',
+                          },
+                      ]
+                    : []),
+            ],
+            sortable: false,
+            filterable: false,
+            resizable: false,
+            searchable: false,
+        });
+    }
+
+    return columns;
+}

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

@@ -216,6 +216,42 @@ export const fuelReportStatuses = [
     { label: 'Reimbursed', value: 'reimbursed', description: 'Driver expense reimbursed' },
 ];
 
+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' },
+    { label: 'Assigned', value: 'assigned', description: 'A technician, vendor, or team has been assigned' },
+    { label: 'In Progress', value: 'in_progress', description: 'Work is actively being performed' },
+    { label: 'Awaiting Parts', value: 'awaiting_parts', description: 'Work is blocked until required parts are available' },
+    { label: 'Awaiting Vendor', value: 'awaiting_vendor', description: 'Work is waiting on a third-party vendor or repair shop' },
+    { label: 'On Hold', value: 'on_hold', description: 'Work is temporarily paused' },
+    { label: 'Quality Check', value: 'quality_check', description: 'Work is complete and awaiting verification or road-readiness check' },
+    { label: 'Closed', value: 'closed', description: 'Work is complete and recorded in maintenance history' },
+    { label: 'Canceled', value: 'canceled', description: 'Work order was canceled before completion' },
+];
+
+export const workOrderCategories = [
+    { label: 'Preventive Maintenance (PM)', value: 'preventive_maintenance', description: 'Scheduled service intended to prevent failures and downtime' },
+    { label: 'Predictive Maintenance', value: 'predictive_maintenance', description: 'Maintenance triggered by forecasts, telematics, diagnostics, or condition trends' },
+    { label: 'Condition-Based Maintenance', value: 'condition_based_maintenance', description: 'Service based on measured asset condition or threshold readings' },
+    { label: 'Inspection Request', value: 'inspection_request', description: 'Technician or compliance inspection requested for the asset' },
+    { label: 'Failed Inspection', value: 'failed_inspection', description: 'Follow-up work created from a failed inspection or DVIR item' },
+    { label: 'Recall', value: 'recall', description: 'Manufacturer, regulatory, or safety recall work' },
+    { label: 'Compliance / Safety', value: 'compliance_safety', description: 'Required safety, regulatory, or roadworthiness work' },
+    { label: 'General Repair', value: 'general_repair', description: 'General corrective repair that does not fit a more specific category' },
+    { label: 'Mechanical Complaint', value: 'mechanical_complaint', description: 'Engine, drivetrain, suspension, steering, or other mechanical concern' },
+    { label: 'Electrical Complaint', value: 'electrical_complaint', description: 'Battery, charging, lighting, wiring, sensor, or electrical system concern' },
+    { label: 'Brake Issue', value: 'brake_issue', description: 'Brake wear, performance, air brake, ABS, or related safety concern' },
+    { label: 'Tire Issue', value: 'tire_issue', description: 'Tire wear, puncture, blowout, alignment, rotation, or replacement' },
+    { label: 'HVAC / Air Conditioning Issue', value: 'hvac_issue', description: 'Heating, ventilation, defrost, or air conditioning concern' },
+    { label: 'AdBlue / DEF', value: 'adblue_def', description: 'Diesel exhaust fluid, SCR, emissions fluid, or dosing system issue' },
+    { label: 'Fluid Leak', value: 'fluid_leak', description: 'Oil, coolant, fuel, hydraulic, brake fluid, or other leak' },
+    { label: 'Body Damage', value: 'body_damage', description: 'Non-accident body, panel, paint, glass, door, or cosmetic damage' },
+    { label: 'Accident Damage', value: 'accident_damage', description: 'Collision or incident-related inspection and repair' },
+    { label: 'Roadside Assistance', value: 'roadside_assistance', description: 'Tow, recovery, jump start, lockout, or field service request' },
+    { label: 'Breakdown', value: 'breakdown', description: 'Unplanned asset failure requiring urgent repair' },
+    { label: 'Other', value: 'other', description: 'Work that does not fit another operational category' },
+];
+
 export const issueStatuses = [
     { label: 'Open', value: 'open', description: 'Issue is open and unresolved' },
     { label: 'Pending', value: 'pending', description: 'Issue is logged but work has not yet started' },
@@ -862,6 +898,8 @@ export default function fleetOpsOptions(key) {
         contactStatuses,
         fuelReportTypes,
         fuelReportStatuses,
+        workOrderStatuses,
+        workOrderCategories,
         issueTypes,
         issueStatuses,
         issueCategories,

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

@@ -0,0 +1,20 @@
+import { get } from '@ember/object';
+
+export function resolveIdentityCellResource(args) {
+    const column = args.column ?? {};
+    const resourcePath = column.resourcePath;
+
+    if (typeof resourcePath === 'function') {
+        return resourcePath(args.row, args.value, column) ?? null;
+    }
+
+    if (typeof resourcePath === 'string') {
+        return get(args.row, resourcePath) ?? null;
+    }
+
+    if (args.value && typeof args.value === 'object') {
+        return args.value;
+    }
+
+    return args.row;
+}

package/addon/utils/map-drawer-dropdown-position.js

@@ -0,0 +1,47 @@
+export default function calculateMapDrawerDropdownPosition(trigger, content) {
+    const dropdownRoot = trigger?.closest?.('.ember-basic-dropdown');
+    const drawerPanel = trigger?.closest?.('.next-drawer-panel');
+
+    if (!trigger || !dropdownRoot) {
+        return { style: {} };
+    }
+
+    const triggerRect = trigger.getBoundingClientRect();
+    const rootRect = dropdownRoot.getBoundingClientRect();
+    const drawerRect = drawerPanel?.getBoundingClientRect?.();
+    const contentRect = content?.getBoundingClientRect?.();
+    const contentWidth = contentRect?.width || 224;
+    // const contentHeight = contentRect?.height || 240;
+    const gap = 6;
+
+    const viewportRect = {
+        top: 0,
+        right: window.innerWidth,
+        bottom: window.innerHeight,
+        left: 0,
+    };
+    const boundaryRect = drawerRect ?? viewportRect;
+    const minLeft = boundaryRect.left - rootRect.left + gap;
+    const maxLeft = boundaryRect.right - rootRect.left - contentWidth - gap;
+    // const minTop = boundaryRect.top - rootRect.top + gap;
+    // const maxTop = boundaryRect.bottom - rootRect.top - contentHeight - gap;
+
+    const preferredLeft = triggerRect.left - rootRect.left - contentWidth - gap;
+    // const preferredTop = triggerRect.top - rootRect.top;
+    const left = clamp(preferredLeft, minLeft, Math.max(minLeft, maxLeft));
+    const top = 0; //clamp(preferredTop, minTop, Math.max(minTop, maxTop));
+
+    return {
+        style: {
+            position: 'absolute',
+            left: `${left}px`,
+            top: `${top}px`,
+            marginTop: '0px',
+            zIndex: '10000',
+        },
+    };
+}
+
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}

package/addon/utils/trackable-option.js

@@ -0,0 +1,93 @@
+import getModelName from '@fleetbase/ember-core/utils/get-model-name';
+import { isArray } from '@ember/array';
+import { get } from '@ember/object';
+
+export function buildTrackableOption(resource, modelName = getTrackableModelName(resource)) {
+    const deviceLabel = trackableDeviceLabel(resource, modelName);
+    const secondaryLabel = trackableSecondaryLabel(resource, modelName);
+    const primaryLabel = getValue(resource, 'name') ?? getValue(resource, 'displayName') ?? getValue(resource, 'display_name') ?? getValue(resource, 'public_id');
+    const trackableSearchText = [
+        primaryLabel,
+        secondaryLabel,
+        getValue(resource, 'public_id'),
+        getValue(resource, 'internal_id'),
+        getValue(resource, 'serial_number'),
+        getValue(resource, 'plate_number'),
+        getValue(resource, 'email'),
+        getValue(resource, 'vin'),
+        getValue(resource, 'call_sign'),
+        deviceLabel,
+    ]
+        .filter(Boolean)
+        .join(' ');
+
+    return {
+        resource,
+        modelName,
+        primaryLabel,
+        secondaryLabel,
+        deviceLabel,
+        trackableSearchText,
+    };
+}
+
+export function trackableSecondaryLabel(resource, modelName = getTrackableModelName(resource)) {
+    if (modelName === 'driver') {
+        return getValue(resource, 'email') ?? getValue(resource, 'phone') ?? getValue(resource, 'vehicle_name') ?? getValue(resource, 'internal_id') ?? getValue(resource, 'public_id');
+    }
+
+    return getValue(resource, 'plate_number') ?? getValue(resource, 'serial_number') ?? getValue(resource, 'internal_id') ?? getValue(resource, 'vin') ?? getValue(resource, 'public_id');
+}
+
+export function trackableDeviceLabel(resource, modelName = getTrackableModelName(resource)) {
+    const devices = trackableDevices(resource, modelName);
+    const labels = devices.map(deviceLabel).filter(Boolean);
+
+    if (labels.length === 0) {
+        return null;
+    }
+
+    return labels.length === 1 ? `Device: ${labels[0]}` : `Devices: ${labels.join(', ')}`;
+}
+
+export function trackableDevices(resource, modelName = getTrackableModelName(resource)) {
+    const devices = modelName === 'driver' ? getValue(resource, 'vehicle.devices') : getValue(resource, 'devices');
+
+    if (!devices) {
+        return [];
+    }
+
+    if (isArray(devices)) {
+        return devices;
+    }
+
+    if (typeof devices.toArray === 'function') {
+        return devices.toArray();
+    }
+
+    return [];
+}
+
+export function deviceLabel(device) {
+    return (
+        getValue(device, 'displayName') ??
+        getValue(device, 'display_name') ??
+        getValue(device, 'name') ??
+        getValue(device, 'device_id') ??
+        getValue(device, 'serial_number') ??
+        getValue(device, 'imei') ??
+        getValue(device, 'public_id')
+    );
+}
+
+function getTrackableModelName(resource) {
+    return getModelName(resource) ?? getValue(resource, 'modelName') ?? resource?.constructor?.modelName;
+}
+
+function getValue(object, path) {
+    if (!object) {
+        return undefined;
+    }
+
+    return get(object, path);
+}

package/app/components/cell/attached-vehicle.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/cell/attached-vehicle';

package/app/components/cell/device-identity.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/cell/device-identity';

package/app/components/cell/driver-identity.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/cell/driver-identity';

package/app/components/cell/equipment-identity.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/cell/equipment-identity';

package/app/components/cell/part-identity.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/cell/part-identity';

package/app/components/cell/telematic-device.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/cell/telematic-device';

package/app/components/cell/vehicle-identity.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/cell/vehicle-identity';

package/app/components/device/panel-tabs/events.hbs

@@ -0,0 +1,30 @@
+<div class="flex flex-col gap-3 p-3" ...attributes>
+    <div class="flex items-start justify-between gap-3">
+        <div class="min-w-0">
+            <h2 class="text-base font-bold text-gray-900 dark:text-gray-100">Telemetry Events</h2>
+            <p class="mt-0.5 text-xs text-gray-500 dark:text-gray-300">Recent device events, warning signals, and processing state.</p>
+        </div>
+        <Button @icon="refresh" @size="xs" @onClick={{this.refreshEvents}} @isLoading={{this.loadEvents.isRunning}} />
+    </div>
+
+    <Layout::Resource::Tabular
+        @resource="device-event"
+        @title="Telemetry Events"
+        @data={{this.events}}
+        @columns={{this.columns}}
+        @controller={{this}}
+        @pagination={{false}}
+        @withoutHeader={{true}}
+        @tableWrapperClass="no-table-extra-spacing"
+        @emptyStateComponent={{component
+            "table/empty-state"
+            variant="compact"
+            icon="bolt"
+            title="No telemetry events"
+            description="Events appear after this device reports provider activity."
+            primaryText="Refresh"
+            primaryIcon="refresh"
+            primaryAction=this.refreshEvents
+        }}
+    />
+</div>