@fleetbase/fleetops-engine 0.6.64 → 0.6.66

package/addon/utils/radar.js

@@ -0,0 +1,212 @@
+/**
+ * Shared vocabulary for the Radar page: which pills exist, how a rule maps
+ * to a badge colour, which actions are record-level, and the snooze presets.
+ */
+
+export const RADAR_PILLS = ['overdue', 'due_week', 'unassigned', 'issues', 'inspections', 'shifts', 'expiring', 'low_stock', 'fuel', 'notices'];
+
+export const RADAR_STATUSES = ['open', 'snoozed', 'resolved'];
+
+export const RADAR_GROUPS = ['overdue', 'today', 'week', 'later', 'none'];
+
+/** Saved views every user starts with. */
+export const RADAR_DEFAULT_VIEWS = [
+    { id: 'my-assignments', intl: 'radar.saved-views.defaults.my-assignments', status: 'open', filters: '', assigned: 'me', q: '', isDefault: true },
+    { id: 'shift-changes', intl: 'radar.saved-views.defaults.shift-changes', status: 'open', filters: 'shifts', assigned: '', q: '', isDefault: true },
+    { id: 'due-this-week', intl: 'radar.saved-views.defaults.due-this-week', status: 'open', filters: 'due_week', assigned: '', q: '', isDefault: true },
+    { id: 'unmatched-fuel', intl: 'radar.saved-views.defaults.unmatched-fuel', status: 'open', filters: 'fuel', assigned: '', q: '', isDefault: true },
+];
+
+/** Badge status per category; issues go by severity instead. */
+const CHIP_BY_CATEGORY = {
+    maintenance: 'warning',
+    inspections: 'violet',
+    staffing: 'info',
+    compliance: 'cyan',
+    fuel: 'sky',
+    parts: 'slate',
+    connectivity: 'slate',
+    issues: 'warning',
+    notices: 'gray',
+};
+
+const CHIP_BY_RULE = {
+    work_order_overdue: 'orange',
+    work_order_blocked: 'orange',
+    shift_late_start: 'indigo',
+    shift_no_vehicle: 'indigo',
+    shift_handover: 'indigo',
+};
+
+export function chipStatusFor(item) {
+    if (!item) {
+        return 'gray';
+    }
+
+    if (item.rule === 'issue_open') {
+        return item.severity === 'critical' ? 'error' : 'warning';
+    }
+
+    return CHIP_BY_RULE[item.rule] ?? CHIP_BY_CATEGORY[item.category] ?? 'gray';
+}
+
+/**
+ * Actions that change the record itself, in the order the rail prefers
+ * them, each with its label key and icon. Everything else is state.
+ */
+export const RECORD_ACTIONS = {
+    create_work_order: { label: 'radar.actions.create-work-order', icon: 'clipboard-list' },
+    create_work_order_from_inspection: { label: 'radar.actions.create-work-order', icon: 'clipboard-list' },
+    create_issue_from_inspection: { label: 'radar.actions.create-issue', icon: 'triangle-exclamation' },
+    resolve_inspection: { label: 'radar.actions.mark-resolved', icon: 'check' },
+    resolve_issue: { label: 'radar.actions.mark-resolved', icon: 'check' },
+    assign_vehicle: { label: 'radar.actions.assign-vehicle', icon: 'truck' },
+    assign_driver: { label: 'radar.actions.assign-driver', icon: 'id-card' },
+    match_vehicle: { label: 'radar.actions.match-vehicle', icon: 'link' },
+    ignore_transaction: { label: 'radar.actions.ignore', icon: 'eye-slash' },
+    attach_device: { label: 'radar.actions.attach', icon: 'satellite-dish' },
+    send_pin: { label: 'radar.actions.send-pin', icon: 'paper-plane' },
+    revoke_link: { label: 'radar.actions.revoke-link', icon: 'ban' },
+    call: { label: 'radar.actions.call', icon: 'phone' },
+    cover_shift: { label: 'radar.actions.cover-shift', icon: 'people-arrows' },
+    handover: { label: 'radar.actions.reassign', icon: 'right-left' },
+    extend_shift: { label: 'radar.actions.extend-shift', icon: 'clock' },
+    resolve: { label: 'radar.actions.resolve', icon: 'check' },
+};
+
+export const STATE_ACTIONS = ['acknowledge', 'snooze', 'wake', 'assign', 'unassign', 'plan', 'unplan', 'open_record'];
+
+/** The first record-level action an item offers, with its label and icon. */
+export function primaryActionFor(item) {
+    const key = (item?.actions ?? []).find((action) => RECORD_ACTIONS[action]);
+    if (!key) {
+        return null;
+    }
+
+    return { key, ...RECORD_ACTIONS[key] };
+}
+
+/** Every record-level action after the primary one. */
+export function secondaryActionsFor(item) {
+    const primary = primaryActionFor(item);
+
+    return (item?.actions ?? []).filter((action) => RECORD_ACTIONS[action] && action !== primary?.key).map((key) => ({ key, ...RECORD_ACTIONS[key] }));
+}
+
+export const SNOOZE_PRESETS = ['1h', '4h', 'tomorrow', 'next-week'];
+
+/**
+ * The snooze payload for a preset: minutes for the short ones, a
+ * morning-of date for the longer ones.
+ */
+export function snoozePayloadFor(preset, now = new Date()) {
+    switch (preset) {
+        case '1h':
+            return { minutes: 60 };
+        case '4h':
+            return { minutes: 240 };
+        case 'tomorrow': {
+            const until = new Date(now);
+            until.setDate(until.getDate() + 1);
+            until.setHours(8, 0, 0, 0);
+            return { until: until.toISOString() };
+        }
+        case 'next-week': {
+            const until = new Date(now);
+            until.setDate(until.getDate() + 7);
+            until.setHours(8, 0, 0, 0);
+            return { until: until.toISOString() };
+        }
+        default:
+            return { minutes: 60 };
+    }
+}
+
+export function initialsOf(name) {
+    const parts = String(name ?? '')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean);
+    if (!parts.length) {
+        return '';
+    }
+
+    const first = parts[0].charAt(0);
+    const last = parts.length > 1 ? parts[parts.length - 1].charAt(0) : '';
+
+    return (first + last).toUpperCase();
+}
+
+/** Replace one item (by key) inside a Radar items payload, or drop it when the updater returns null. */
+export function patchPayload(payload, key, updater) {
+    if (!payload) {
+        return payload;
+    }
+
+    const apply = (item) => (item.key === key ? updater(item) : item);
+    const items = (payload.items ?? []).map(apply).filter(Boolean);
+    const groups = (payload.groups ?? [])
+        .map((group) => {
+            const members = (group.items ?? []).map(apply).filter(Boolean);
+            return { ...group, items: members, count: members.length };
+        })
+        .filter((group) => group.items.length > 0);
+
+    return { ...payload, items, groups };
+}
+
+/**
+ * How to show a record Radar links to without leaving the page: the Ember
+ * Data model to load, the action service whose `panel.view` renders it, or
+ * the details component to open in a plain context panel when the resource
+ * has no panel of its own. Keyed by the record route's prefix; the longest
+ * matching prefix wins, so `management.vehicles.index.details.devices`
+ * resolves to the vehicle panel.
+ */
+export const RECORD_PANELS = {
+    'management.drivers': { modelName: 'driver', service: 'driver-actions' },
+    'management.vehicles': { modelName: 'vehicle', service: 'vehicle-actions' },
+    'management.trailers': { modelName: 'trailer', service: 'trailer-actions' },
+    'management.issues': { modelName: 'issue', service: 'issue-actions', include: ['driver', 'vehicle', 'assignee', 'reporter', 'order', 'files'] },
+    'management.fuel-transactions': { modelName: 'fuel-provider-transaction', component: 'fuel-provider-transaction/summary' },
+    'maintenance.maintenances': { modelName: 'maintenance', service: 'maintenance-actions' },
+    'maintenance.equipment': { modelName: 'equipment', service: 'equipment-actions' },
+    'maintenance.schedules': { modelName: 'maintenance-schedule', service: 'maintenance-schedule-actions' },
+    'maintenance.work-orders': { modelName: 'work-order', service: 'work-order-actions' },
+    'maintenance.parts': { modelName: 'part', service: 'part-actions' },
+    'maintenance.inspection-submissions': { modelName: 'inspection-submission', service: 'inspection-submission-actions' },
+    'maintenance.inspection-forms': { modelName: 'inspection-form', service: 'inspection-form-actions' },
+    'connectivity.devices': { modelName: 'device', service: 'device-actions' },
+};
+
+/** The panel definition for a record route, or null when Radar has none for it. */
+export function recordPanelFor(route) {
+    if (!route) {
+        return null;
+    }
+
+    const prefix = Object.keys(RECORD_PANELS)
+        .filter((key) => route === key || route.startsWith(`${key}.`))
+        .sort((a, b) => b.length - a.length)[0];
+
+    return prefix ? RECORD_PANELS[prefix] : null;
+}
+
+/**
+ * The `{ route, model }` a Radar link points at, whichever shape it arrived
+ * in: an item (`item.record`), a decision or handover record, or a brief
+ * sentence segment carrying `route` and `model` itself.
+ */
+export function recordOf(target) {
+    if (!target) {
+        return null;
+    }
+    if (target.record?.route) {
+        return target.record;
+    }
+    if (target.route && target.model) {
+        return { route: target.route, model: target.model };
+    }
+
+    return null;
+}

package/addon/utils/relation-value.js

@@ -0,0 +1,37 @@
+import { get } from '@ember/object';
+
+/**
+ * Reads a relation without returning a promise proxy: the loaded record for
+ * an Ember Data relationship (null while it is not loaded), the plain value
+ * for a POJO. Async belongsTo relations return an always-truthy proxy from
+ * `get`, which is why identity cells must read them this way.
+ */
+export default function relationValue(record, name) {
+    if (!record || !name) {
+        return null;
+    }
+
+    if (typeof record.belongsTo === 'function') {
+        try {
+            return record.belongsTo(name).value() ?? null;
+        } catch {
+            // not a belongsTo on this model
+        }
+    }
+
+    if (typeof record.hasMany === 'function') {
+        try {
+            return record.hasMany(name).value() ?? null;
+        } catch {
+            // not a hasMany either
+        }
+    }
+
+    const value = get(record, name);
+
+    if (value && typeof value === 'object' && typeof value.then === 'function') {
+        return value.content ?? null;
+    }
+
+    return value ?? null;
+}

package/addon/utils/resource-descriptors/assets.js

@@ -0,0 +1,246 @@
+import { get } from '@ember/object';
+import { first, present, relation, photo, icon, badge, badges, fact, relatedFact, money, join, panelOpener } from './helpers';
+
+/**
+ * Vehicles, trailers, equipment, parts, generic assets and warranties.
+ */
+export default function buildAssetDescriptors(owner) {
+    return [
+        {
+            key: 'vehicle',
+            labelKey: 'resource.vehicle',
+            icon: 'truck',
+            modelNames: ['vehicle'],
+            aliases: ['attachable-vehicle', 'maintenance-subject-vehicle'],
+            polymorphicTypes: ['fleet-ops:vehicle', 'Fleetbase\\FleetOps\\Models\\Vehicle'],
+            permission: 'fleet-ops view vehicle',
+            statusTones: {
+                available: 'text-green-500',
+                active: 'text-green-500',
+                in_service: 'text-green-500',
+                maintenance: 'text-yellow-500',
+                unavailable: 'text-gray-400',
+                inactive: 'text-gray-400',
+                out_of_service: 'text-red-500',
+            },
+            title: (vehicle) =>
+                first(vehicle, 'displayName', 'display_name', 'name', 'yearMakeModel', 'public_id') ?? join([get(vehicle, 'year'), get(vehicle, 'make'), get(vehicle, 'model')]),
+            identifier: (vehicle) => first(vehicle, 'plate_number', 'call_sign', 'vin', 'serial_number'),
+            image: (vehicle) => photo(vehicle, 'vehicle'),
+            online: (vehicle) => {
+                const online = get(vehicle, 'online');
+
+                return typeof online === 'boolean' ? online : undefined;
+            },
+            status: (vehicle) => first(vehicle, 'status'),
+            badges: (vehicle) => {
+                const driver = relation(owner, vehicle, 'driver');
+
+                return badges(
+                    badge('plate', 'id-card', first(vehicle, 'plate_number', 'call_sign', 'vehicle_number')),
+                    badge('driver', 'user', first(driver, 'name', 'displayName') ?? first(vehicle, 'driver_name'), {
+                        relatedType: 'driver',
+                        relatedId: driver?.id ?? get(vehicle, 'driver_uuid'),
+                    })
+                );
+            },
+            selectDetails: (vehicle) => [first(vehicle, 'plate_number', 'vin', 'serial_number', 'call_sign'), first(vehicle, 'driver_name')],
+            facts: (vehicle) => {
+                const driver = relation(owner, vehicle, 'driver');
+                const trailers = relation(owner, vehicle, 'trailers');
+                const trailer = trailers && typeof trailers.objectAt === 'function' ? trailers.objectAt(0) : Array.isArray(trailers) ? trailers[0] : null;
+                const extra = trailers?.length > 1 ? ` (+${trailers.length - 1})` : '';
+
+                return [
+                    fact('make-model', join([get(vehicle, 'year'), get(vehicle, 'make'), get(vehicle, 'model'), get(vehicle, 'trim')])),
+                    fact('plate', join([first(vehicle, 'plate_number'), first(vehicle, 'vin')], ' · ')),
+                    relatedFact('driver', driver, 'driver', first(vehicle, 'driver_name')),
+                    trailer ? { ...relatedFact('trailer', trailer, 'trailer', first(trailer, 'displayName', 'display_name', 'name')), suffix: extra } : fact('trailer', null),
+                    fact('odometer', present(get(vehicle, 'odometer')) ? join([get(vehicle, 'odometer'), get(vehicle, 'odometer_unit')]) : null),
+                    fact('status', first(vehicle, 'status'), { format: 'humanize' }),
+                ];
+            },
+            open: panelOpener(owner, 'vehicle-actions'),
+            components: { identity: 'cell/vehicle-identity' },
+        },
+        {
+            key: 'trailer',
+            labelKey: 'resource.trailer',
+            icon: 'trailer',
+            modelNames: ['trailer'],
+            aliases: ['attachable-trailer', 'maintenance-subject-trailer'],
+            polymorphicTypes: ['fleet-ops:trailer', 'Fleetbase\\FleetOps\\Models\\Trailer'],
+            permission: 'fleet-ops view trailer',
+            statusTones: { attached: 'text-green-500', detached: 'text-gray-400' },
+            title: (trailer) => first(trailer, 'displayName', 'display_name', 'name', 'public_id'),
+            identifier: (trailer) => first(trailer, 'plate_number', 'vin', 'code'),
+            image: (trailer) => photo(trailer, 'trailer'),
+            online: (trailer) => {
+                const online = get(trailer, 'isOnline') ?? get(trailer, 'online') ?? get(trailer, 'is_online');
+
+                return typeof online === 'boolean' ? online : undefined;
+            },
+            status: (trailer) => first(trailer, 'status', 'attachment_state'),
+            badges: (trailer) => {
+                const vehicle = relation(owner, trailer, 'current_vehicle');
+
+                return badges(
+                    badge('plate', 'id-card', first(trailer, 'plate_number', 'code')),
+                    badge('vehicle', 'truck', first(vehicle, 'displayName', 'display_name', 'name') ?? first(trailer, 'current_vehicle_name'), {
+                        relatedType: 'vehicle',
+                        relatedId: vehicle?.id ?? get(trailer, 'current_vehicle_id'),
+                    })
+                );
+            },
+            selectDetails: (trailer) => [first(trailer, 'type'), first(trailer, 'plate_number', 'vin', 'code')],
+            facts: (trailer) => {
+                const vehicle = relation(owner, trailer, 'current_vehicle');
+
+                return [
+                    fact('type', first(trailer, 'type', 'body_type'), { format: 'humanize' }),
+                    fact('body-coupling', join([first(trailer, 'body_type'), first(trailer, 'coupling_type')], ' · '), { format: 'humanize' }),
+                    fact('plate', join([first(trailer, 'plate_number'), first(trailer, 'vin')], ' · ')),
+                    relatedFact('vehicle', vehicle, 'vehicle', first(trailer, 'current_vehicle_name')),
+                    fact('axles', get(trailer, 'axle_count')),
+                    fact('attachment', first(trailer, 'attachment_state'), { format: 'humanize' }),
+                ];
+            },
+            open: panelOpener(owner, 'trailer-actions'),
+            components: { identity: 'cell/trailer-identity' },
+        },
+        {
+            key: 'equipment',
+            labelKey: 'resource.equipment',
+            icon: 'toolbox',
+            modelNames: ['equipment'],
+            aliases: ['maintenance-subject-equipment'],
+            polymorphicTypes: ['fleet-ops:equipment', 'Fleetbase\\FleetOps\\Models\\Equipment'],
+            permission: 'fleet-ops view equipment',
+            statusTones: {
+                active: 'text-green-500',
+                equipped: 'text-green-500',
+                available: 'text-green-500',
+                maintenance: 'text-yellow-500',
+                unequipped: 'text-gray-400',
+                inactive: 'text-gray-400',
+                retired: 'text-red-500',
+            },
+            title: (equipment) => first(equipment, 'name', 'code', 'public_id'),
+            identifier: (equipment) => first(equipment, 'serial_number', 'code'),
+            image: (equipment) => (present(get(equipment, 'photo_url')) ? { url: get(equipment, 'photo_url'), shape: 'square' } : icon('toolbox')),
+            status: (equipment) => (get(equipment, 'is_equipped') ? 'equipped' : first(equipment, 'status')),
+            selectDetails: (equipment) => [first(equipment, 'type'), first(equipment, 'serial_number', 'code')],
+            facts: (equipment) => [
+                fact('type', first(equipment, 'type'), { format: 'humanize' }),
+                fact('make-model', join([first(equipment, 'manufacturer'), first(equipment, 'model')])),
+                fact('serial', first(equipment, 'serial_number')),
+                relatedFact('equipped-to', relation(owner, equipment, 'equipable'), null, first(equipment, 'equipped_to_name')),
+                relatedFact('warranty', relation(owner, equipment, 'warranty'), 'warranty', first(equipment, 'warranty_name')),
+                fact('purchase-price', money(get(equipment, 'purchase_price'), get(equipment, 'currency'))),
+            ],
+            open: panelOpener(owner, 'equipment-actions'),
+            components: { identity: 'cell/equipment-identity' },
+        },
+        {
+            key: 'part',
+            labelKey: 'resource.part',
+            icon: 'gears',
+            modelNames: ['part'],
+            polymorphicTypes: ['fleet-ops:part', 'Fleetbase\\FleetOps\\Models\\Part'],
+            permission: 'fleet-ops view part',
+            statusTones: { in_stock: 'text-green-500', low_stock: 'text-yellow-500', out_of_stock: 'text-red-500' },
+            title: (part) => first(part, 'name', 'sku', 'public_id'),
+            identifier: (part) => first(part, 'sku', 'serial_number'),
+            image: (part) => (present(get(part, 'photo_url')) ? { url: get(part, 'photo_url'), shape: 'square' } : icon('gears')),
+            status: (part) =>
+                get(part, 'is_low_stock') ? 'low_stock' : get(part, 'is_in_stock') ? 'in_stock' : get(part, 'quantity_on_hand') === undefined ? first(part, 'status') : 'out_of_stock',
+            selectDetails: (part) => [first(part, 'sku'), first(part, 'manufacturer')],
+            facts: (part) => [
+                fact('sku', first(part, 'sku')),
+                fact('make-model', join([first(part, 'manufacturer'), first(part, 'model')])),
+                fact('quantity', present(get(part, 'quantity_on_hand')) ? `${get(part, 'quantity_on_hand')}${get(part, 'is_low_stock') ? ' (low stock)' : ''}` : null),
+                fact('unit-cost', money(get(part, 'unit_cost'), get(part, 'currency'))),
+                relatedFact('vendor', relation(owner, part, 'vendor'), 'vendor', first(part, 'vendor_name')),
+                relatedFact('fitted-to', part.__fittedTo ?? null, first(part, 'asset_type'), first(part, 'asset_name')),
+            ],
+            hydrate: async (part) => {
+                const type = first(part, 'asset_type');
+                const id = first(part, 'asset_uuid');
+                const registry = owner.lookup('service:resource-registry');
+                const store = owner.lookup('service:store');
+                const key = registry?.resolveKey(type);
+
+                if (!key || !id || !store || part.__fittedTo) {
+                    return null;
+                }
+
+                try {
+                    part.__fittedTo = store.peekRecord(key, id) ?? (await store.findRecord(key, id));
+                } catch {
+                    part.__fittedTo = null;
+                }
+
+                return part;
+            },
+            open: panelOpener(owner, 'part-actions'),
+            components: { identity: 'cell/part-identity' },
+        },
+        {
+            key: 'asset',
+            labelKey: 'resource.asset',
+            icon: 'cube',
+            modelNames: ['asset'],
+            aliases: ['attachable-asset'],
+            polymorphicTypes: ['fleet-ops:asset', 'Fleetbase\\FleetOps\\Models\\Asset'],
+            title: (asset) => first(asset, 'display_name', 'displayName', 'name', 'public_id'),
+            identifier: (asset) => first(asset, 'plate_number', 'vin', 'serial_number', 'code'),
+            image: (asset) => (present(get(asset, 'photo_url')) ? { url: get(asset, 'photo_url'), shape: 'square' } : icon('cube')),
+            online: (asset) => {
+                const online = get(asset, 'is_online') ?? get(asset, 'online');
+
+                return typeof online === 'boolean' ? online : undefined;
+            },
+            status: (asset) => first(asset, 'status'),
+            selectDetails: (asset) => [first(asset, 'type'), first(asset, 'plate_number', 'vin', 'serial_number')],
+            facts: (asset) => [
+                fact('type', first(asset, 'type', 'usage_type'), { format: 'humanize' }),
+                fact('make-model', join([get(asset, 'year'), get(asset, 'make'), get(asset, 'model')])),
+                relatedFact('vendor', relation(owner, asset, 'vendor'), 'vendor', first(asset, 'vendor_name')),
+                fact('category', first(asset, 'category_name', 'category.name')),
+                fact('location', first(asset, 'current_location', 'current_place.name')),
+            ],
+            open: async (asset, context) => {
+                const registry = owner.lookup('service:resource-registry');
+                const concrete = first(asset, 'asset_class', 'type');
+                const key = concrete && concrete !== 'asset' ? registry?.resolveKey(concrete) : null;
+
+                if (key && key !== 'asset') {
+                    return registry.open(asset, { ...context, resourceType: key });
+                }
+
+                return false;
+            },
+        },
+        {
+            key: 'warranty',
+            labelKey: 'resource.warranty',
+            icon: 'shield-halved',
+            modelNames: ['warranty'],
+            polymorphicTypes: ['fleet-ops:warranty', 'Fleetbase\\FleetOps\\Models\\Warranty'],
+            statusTones: { active: 'text-green-500', expired: 'text-red-500', expiring: 'text-yellow-500' },
+            title: (warranty) => join([first(warranty, 'provider'), first(warranty, 'policy_number')], ' · ') ?? first(warranty, 'public_id'),
+            identifier: (warranty) => first(warranty, 'policy_number'),
+            image: () => icon('shield-halved'),
+            status: (warranty) => (get(warranty, 'is_expired') ? 'expired' : get(warranty, 'is_active') ? 'active' : first(warranty, 'status')),
+            selectDetails: (warranty) => [first(warranty, 'provider'), first(warranty, 'policy_number')],
+            facts: (warranty) => [
+                fact('provider', first(warranty, 'provider')),
+                fact('policy', first(warranty, 'policy_number')),
+                relatedFact('vendor', relation(owner, warranty, 'vendor'), 'vendor', first(warranty, 'vendor_name')),
+                fact('subject', first(warranty, 'subject_name')),
+                fact('period', join([get(warranty, 'startDateShort') ?? get(warranty, 'start_date'), get(warranty, 'endDateShort') ?? get(warranty, 'end_date')], ' – ')),
+                fact('coverage', first(warranty, 'coverage_summary', 'coverage')),
+            ],
+        },
+    ];
+}

package/addon/utils/resource-descriptors/connectivity.js

@@ -0,0 +1,146 @@
+import { get } from '@ember/object';
+import { first, present, relation, icon, fact, relatedFact, join, panelOpener } from './helpers';
+
+const DEFAULT_PROVIDER_ICON = '/engines-dist/images/telematics/providers/default.webp';
+
+function providerImage(record) {
+    const descriptor = get(record, 'provider_descriptor') ?? {};
+    const url = descriptor.icon ?? get(record, 'provider_icon');
+
+    return present(url) ? { url, fallback: DEFAULT_PROVIDER_ICON, shape: 'square' } : icon('satellite-dish');
+}
+
+/**
+ * Devices, sensors, telematics providers and device events.
+ */
+export default function buildConnectivityDescriptors(owner) {
+    return [
+        {
+            key: 'device',
+            labelKey: 'resource.device',
+            icon: 'microchip',
+            modelNames: ['device'],
+            polymorphicTypes: ['fleet-ops:device', 'Fleetbase\\FleetOps\\Models\\Device'],
+            permission: 'fleet-ops view device',
+            statusTones: {
+                online: 'text-green-500',
+                active: 'text-green-500',
+                recently_offline: 'text-yellow-500',
+                offline: 'text-gray-400',
+                long_offline: 'text-gray-400',
+                never_connected: 'text-gray-400',
+                inactive: 'text-gray-400',
+                error: 'text-red-500',
+            },
+            title: (device) => first(device, 'displayName', 'display_name', 'name', 'device_id', 'imei', 'serial_number', 'public_id'),
+            identifier: (device) => first(device, 'device_id', 'imei', 'serial_number'),
+            image: (device) => (present(get(device, 'photo_url')) ? { url: get(device, 'photo_url'), shape: 'square' } : icon('microchip')),
+            online: (device) => {
+                const online = get(device, 'is_online') ?? get(device, 'online');
+
+                return typeof online === 'boolean' ? online : undefined;
+            },
+            status: (device) => first(device, 'connection_status', 'status'),
+            selectDetails: (device) => [first(device, 'type', 'model'), first(device, 'imei', 'serial_number', 'device_id')],
+            facts: (device) => [
+                fact('type', join([first(device, 'type'), first(device, 'model')], ' · '), { format: 'humanize' }),
+                fact('imei', join([first(device, 'imei'), first(device, 'serial_number')], ' · ')),
+                relatedFact('telematic', relation(owner, device, 'telematic'), 'telematic', first(device, 'telematic_name')),
+                relatedFact('attached-to', relation(owner, device, 'attachable'), null, first(device, 'attached_to_name')),
+                fact('last-online', get(device, 'last_online_at'), { format: 'date' }),
+                fact('firmware', first(device, 'firmware_version')),
+            ],
+            open: panelOpener(owner, 'device-actions'),
+            components: { identity: 'cell/device-identity' },
+        },
+        {
+            key: 'sensor',
+            labelKey: 'resource.sensor',
+            icon: 'gauge',
+            modelNames: ['sensor'],
+            polymorphicTypes: ['fleet-ops:sensor', 'Fleetbase\\FleetOps\\Models\\Sensor'],
+            permission: 'fleet-ops view sensor',
+            statusTones: { normal: 'text-green-500', ok: 'text-green-500', warning: 'text-yellow-500', breached: 'text-red-500', critical: 'text-red-500' },
+            title: (sensor) => first(sensor, 'displayName', 'display_name', 'name', 'internal_id', 'public_id'),
+            identifier: (sensor) => first(sensor, 'serial_number', 'internal_id', 'imei'),
+            image: (sensor) => (present(get(sensor, 'photo_url')) ? { url: get(sensor, 'photo_url'), shape: 'square' } : icon('gauge')),
+            status: (sensor) => first(sensor, 'threshold_status', 'status'),
+            selectDetails: (sensor) => [first(sensor, 'type'), first(sensor, 'serial_number', 'internal_id')],
+            facts: (sensor) => [
+                fact('type', first(sensor, 'type'), { format: 'humanize' }),
+                fact('last-value', join([get(sensor, 'last_value'), first(sensor, 'unit')])),
+                fact(
+                    'threshold',
+                    present(get(sensor, 'min_threshold')) || present(get(sensor, 'max_threshold')) ? `${get(sensor, 'min_threshold') ?? '–'} to ${get(sensor, 'max_threshold') ?? '–'}` : null
+                ),
+                relatedFact('device', relation(owner, sensor, 'device'), 'device', first(sensor, 'device_name')),
+                relatedFact('telematic', relation(owner, sensor, 'telematic'), 'telematic', first(sensor, 'telematic_name')),
+                fact('last-reading', get(sensor, 'last_reading_at'), { format: 'date' }),
+            ],
+            open: panelOpener(owner, 'sensor-actions'),
+        },
+        {
+            key: 'telematic',
+            labelKey: 'resource.telematic',
+            icon: 'satellite-dish',
+            modelNames: ['telematic'],
+            polymorphicTypes: ['fleet-ops:telematic', 'Fleetbase\\FleetOps\\Models\\Telematic'],
+            permission: 'fleet-ops view telematic',
+            title: (telematic) => first(telematic, 'name', 'provider_descriptor.label', 'provider', 'public_id'),
+            identifier: (telematic) => first(telematic, 'provider_descriptor.label', 'provider', 'serial_number'),
+            image: providerImage,
+            status: (telematic) => first(telematic, 'status'),
+            selectDetails: (telematic) => [first(telematic, 'provider_descriptor.label', 'provider'), first(telematic, 'serial_number', 'imei')],
+            facts: (telematic) => [
+                fact('provider', first(telematic, 'provider_descriptor.label', 'provider')),
+                fact('model', first(telematic, 'model')),
+                fact('serial', join([first(telematic, 'serial_number'), first(telematic, 'imei')], ' · ')),
+                fact('status', first(telematic, 'status'), { format: 'humanize' }),
+                fact('last-seen', get(telematic, 'last_seen_at'), { format: 'date' }),
+                relatedFact('warranty', relation(owner, telematic, 'warranty'), 'warranty', first(telematic, 'warranty_name')),
+            ],
+            open: panelOpener(owner, 'telematic-actions'),
+            components: { identity: 'cell/telematic-identity' },
+        },
+        {
+            key: 'device-event',
+            labelKey: 'resource.device-event',
+            icon: 'bolt',
+            modelNames: ['device-event'],
+            polymorphicTypes: ['fleet-ops:device-event', 'Fleetbase\\FleetOps\\Models\\DeviceEvent'],
+            permission: 'fleet-ops view device-event',
+            statusTones: {
+                info: 'text-gray-400',
+                low: 'text-gray-400',
+                notice: 'text-yellow-500',
+                warning: 'text-yellow-500',
+                medium: 'text-yellow-500',
+                high: 'text-red-500',
+                critical: 'text-red-500',
+                error: 'text-red-500',
+            },
+            title: (event) => {
+                const type = first(event, 'event_type', 'code');
+
+                return type
+                    ? String(type)
+                          .replace(/[_.-]+/g, ' ')
+                          .replace(/\b\w/g, (c) => c.toUpperCase())
+                    : first(event, 'public_id');
+            },
+            identifier: (event) => first(event, 'ident', 'public_id'),
+            image: (event) => (present(get(event, 'device_photo_url')) ? { url: get(event, 'device_photo_url'), shape: 'square' } : icon('bolt')),
+            status: (event) => first(event, 'severity'),
+            selectDetails: (event) => [first(event, 'device_name'), first(event, 'severity')],
+            facts: (event) => [
+                fact('event-type', first(event, 'event_type', 'code'), { format: 'humanize' }),
+                fact('severity', first(event, 'severity'), { format: 'humanize' }),
+                relatedFact('device', relation(owner, event, 'device'), 'device', first(event, 'device_name')),
+                fact('telematic', first(event, 'telematic_name', 'provider')),
+                fact('occurred', get(event, 'occurred_at') ?? get(event, 'created_at'), { format: 'date' }),
+                fact('reason', first(event, 'reason', 'comment')),
+            ],
+            open: panelOpener(owner, 'device-event-actions'),
+        },
+    ];
+}