@fleetbase/fleetops-engine 0.6.65 → 0.6.66

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'),
+        },
+    ];
+}

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

@@ -0,0 +1,75 @@
+import { get } from '@ember/object';
+import { first, present, relation, icon, fact, relatedFact, money, join, panelOpener, routeOpener } from './helpers';
+
+/**
+ * Fuel reports, fuel provider connections and their transactions.
+ */
+export default function buildFuelDescriptors(owner) {
+    return [
+        {
+            key: 'fuel-report',
+            labelKey: 'resource.fuel-report',
+            icon: 'gas-pump',
+            modelNames: ['fuel-report'],
+            polymorphicTypes: ['fleet-ops:fuel-report', 'Fleetbase\\FleetOps\\Models\\FuelReport'],
+            permission: 'fleet-ops view fuel-report',
+            title: (report) => first(report, 'public_id'),
+            identifier: (report) => join([get(report, 'volume'), first(report, 'metric_unit')]) ?? money(get(report, 'amount'), get(report, 'currency')),
+            image: () => icon('gas-pump'),
+            status: (report) => first(report, 'status'),
+            selectDetails: (report) => [first(report, 'vehicle_name'), join([get(report, 'volume'), first(report, 'metric_unit')])],
+            facts: (report) => [
+                relatedFact('vehicle', relation(owner, report, 'vehicle'), 'vehicle', first(report, 'vehicle_name')),
+                relatedFact('driver', relation(owner, report, 'driver'), 'driver', first(report, 'driver_name')),
+                relatedFact('reporter', relation(owner, report, 'reporter'), 'user', first(report, 'reporter_name')),
+                fact('volume', join([get(report, 'volume'), first(report, 'metric_unit')])),
+                fact('amount', money(get(report, 'amount'), get(report, 'currency'))),
+                fact('odometer', join([get(report, 'odometer'), first(report, 'source', 'provider')], ' · ')),
+            ],
+            open: panelOpener(owner, 'fuel-report-actions'),
+        },
+        {
+            key: 'fuel-provider-connection',
+            labelKey: 'resource.fuel-provider-connection',
+            icon: 'plug',
+            modelNames: ['fuel-provider-connection'],
+            polymorphicTypes: ['fleet-ops:fuel-provider-connection', 'Fleetbase\\FleetOps\\Models\\FuelProviderConnection'],
+            statusTones: { connected: 'text-green-500', configured: 'text-yellow-500', error: 'text-red-500', disabled: 'text-gray-400' },
+            title: (connection) => first(connection, 'displayName', 'name', 'provider', 'public_id'),
+            identifier: (connection) => first(connection, 'provider'),
+            image: () => icon('plug'),
+            status: (connection) => (present(get(connection, 'last_error')) ? 'error' : first(connection, 'status')),
+            selectDetails: (connection) => [first(connection, 'provider'), first(connection, 'environment')],
+            facts: (connection) => [
+                fact('provider', first(connection, 'provider')),
+                fact('environment', first(connection, 'environment'), { format: 'humanize' }),
+                fact('status', first(connection, 'status'), { format: 'humanize' }),
+                fact('last-synced', get(connection, 'last_synced_at'), { format: 'date' }),
+                fact('last-error', first(connection, 'last_error')),
+            ],
+            open: panelOpener(owner, 'fuel-integration-actions', { mode: 'transition' }),
+        },
+        {
+            key: 'fuel-provider-transaction',
+            labelKey: 'resource.fuel-provider-transaction',
+            icon: 'receipt',
+            modelNames: ['fuel-provider-transaction'],
+            polymorphicTypes: ['fleet-ops:fuel-provider-transaction', 'Fleetbase\\FleetOps\\Models\\FuelProviderTransaction'],
+            statusTones: { matched: 'text-green-500', unmatched: 'text-yellow-500', pending: 'text-yellow-500', failed: 'text-red-500' },
+            title: (transaction) => first(transaction, 'provider_transaction_id', 'public_id'),
+            identifier: (transaction) => first(transaction, 'station_name'),
+            image: () => icon('receipt'),
+            status: (transaction) => first(transaction, 'sync_status'),
+            selectDetails: (transaction) => [first(transaction, 'station_name'), join([get(transaction, 'volume'), first(transaction, 'metric_unit')])],
+            facts: (transaction) => [
+                fact('transaction-at', get(transaction, 'transaction_at'), { format: 'date' }),
+                fact('volume', join([join([get(transaction, 'volume'), first(transaction, 'metric_unit')]), money(get(transaction, 'amount'), get(transaction, 'currency'))], ' · ')),
+                fact('station', first(transaction, 'station_name')),
+                relatedFact('vehicle', relation(owner, transaction, 'vehicle'), 'vehicle', first(transaction, 'vehicle_name', 'plate_number')),
+                relatedFact('driver', relation(owner, transaction, 'driver'), 'driver', first(transaction, 'driver_name')),
+                relatedFact('fuel-report', relation(owner, transaction, 'fuel_report'), 'fuel-report', first(transaction, 'fuel_report_id')),
+            ],
+            open: routeOpener(owner, 'management.fuel-transactions.index.details'),
+        },
+    ];
+}

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

@@ -0,0 +1,191 @@
+import formatDate from '@fleetbase/ember-ui/utils/format-date';
+import { get } from '@ember/object';
+import { getPlaceholderImage, resolveResourceImage } from '../placeholder-images';
+
+/**
+ * Small building blocks the FleetOps descriptors share. They are written
+ * against attribute names, so an identity stub or an API payload renders
+ * the same as an Ember Data record.
+ */
+
+export function present(value) {
+    return value !== undefined && value !== null && String(value).trim() !== '';
+}
+
+/** The first present value at any of the paths. */
+export function first(record, ...paths) {
+    if (!record) {
+        return null;
+    }
+
+    for (const path of paths) {
+        const value = get(record, path);
+
+        if (present(value)) {
+            return value;
+        }
+    }
+
+    return null;
+}
+
+/** A related record read through its reference, never a promise proxy. */
+export function relation(owner, record, name) {
+    const registry = owner?.lookup?.('service:resource-registry');
+
+    if (registry && typeof registry.relationValue === 'function') {
+        return registry.relationValue(record, name);
+    }
+
+    const value = record ? get(record, name) : null;
+
+    if (value && typeof value === 'object' && typeof value.then === 'function') {
+        return value.content ?? null;
+    }
+
+    return value ?? null;
+}
+
+/** A photo with the styled placeholder as fallback. */
+export function photo(record, type, path = 'photo_url') {
+    return { url: resolveResourceImage(get(record, path), type), fallback: getPlaceholderImage(type), shape: type === 'vehicle' || type === 'trailer' ? 'square' : 'round' };
+}
+
+export function icon(name, iconClass) {
+    return iconClass ? { icon: name, iconClass } : { icon: name };
+}
+
+/** A coloured tile for records that carry their own colour (service areas, zones). */
+export function colourTile(record, name) {
+    const colour = first(record, 'color', 'stroke_color');
+
+    return colour ? { icon: name, iconClass: 'resource-colour-tile', colour } : { icon: name };
+}
+
+export function badge(key, iconName, label, extra = {}) {
+    return present(label) ? { key, icon: iconName, label, ...extra } : null;
+}
+
+export function badges(...list) {
+    return list.filter(Boolean);
+}
+
+export function fact(label, value, extra = {}) {
+    return { labelKey: `resource-summary.facts.${label}`, value, ...extra };
+}
+
+/** A fact that renders as the related record's pill when the record is loaded. */
+export function relatedFact(label, related, relatedType, fallbackValue) {
+    return { labelKey: `resource-summary.facts.${label}`, related: related ?? null, relatedType, value: fallbackValue ?? null };
+}
+
+/**
+ * A date the way the console writes one everywhere else (date-fns, not the
+ * browser locale), or null for anything that is not a date.
+ */
+export function dateLabel(value, pattern = 'dd MMM yyyy, HH:mm') {
+    if (!present(value)) {
+        return null;
+    }
+
+    const date = value instanceof Date ? value : new Date(value);
+
+    return Number.isNaN(date.getTime()) ? null : formatDate(date, pattern);
+}
+
+/**
+ * A contact's type the way a person reads it: "customer-fleet-ops:contact"
+ * and "customer" both become "Customer"; anything unreadable becomes null.
+ */
+export function typeLabel(value) {
+    if (!present(value)) {
+        return null;
+    }
+
+    const head = String(value)
+        .split(':')[0]
+        .replace(/-fleet-ops$/, '')
+        .replace(/[-_]+/g, ' ')
+        .trim();
+
+    return head ? head.charAt(0).toUpperCase() + head.slice(1) : null;
+}
+
+export function money(amount, currency) {
+    if (!present(amount)) {
+        return null;
+    }
+
+    return present(currency) ? `${amount} ${currency}` : String(amount);
+}
+
+export function join(parts, separator = ' ') {
+    return parts.filter(present).join(separator) || null;
+}
+
+/** The resolved `*_type` for a polymorphic relation, from the record or a `_type` attribute. */
+export function polymorphicType(record, relationName, typeAttr) {
+    const related = record ? get(record, relationName) : null;
+    const modelName = related?.constructor?.modelName ?? related?.content?.constructor?.modelName;
+
+    return modelName ?? (typeAttr ? get(record, typeAttr) : null) ?? null;
+}
+
+/**
+ * An opener that hands the record to an action service's context panel,
+ * falling back to its route transition. Resolved lazily from the engine
+ * owner so descriptors can be built before the services exist.
+ */
+export function panelOpener(owner, serviceName, { mode = 'panel' } = {}) {
+    return (record) => {
+        const service = owner.lookup(`service:${serviceName}`);
+
+        if (!service) {
+            return false;
+        }
+
+        const view =
+            (mode === 'panel' ? (service.panel?.view ?? service.transition?.view) : null) ??
+            (mode === 'transition' ? service.transition?.view : null) ??
+            (mode === 'modal' ? service.modal?.view : null);
+
+        if (typeof view !== 'function') {
+            return false;
+        }
+
+        view.call(service, record);
+
+        return true;
+    };
+}
+
+/** An opener that transitions to a route inside the engine. */
+export function routeOpener(owner, routeName) {
+    return (record) => {
+        const router = owner.lookup('service:router');
+
+        if (!router || !record) {
+            return false;
+        }
+
+        const mountPrefix = owner.lookup('service:vehicle-actions')?.mountPrefix ?? 'console.fleet-ops';
+
+        router.transitionTo(`${mountPrefix}.${routeName}`, record);
+
+        return true;
+    };
+}
+
+/** An opener that delegates to a parent record. */
+export function parentOpener(owner, parentRelation, parentType) {
+    return async (record, context) => {
+        const registry = owner.lookup('service:resource-registry');
+        const parent = relation(owner, record, parentRelation);
+
+        if (!registry || !parent) {
+            return false;
+        }
+
+        return registry.open(parent, { ...context, resourceType: parentType });
+    };
+}

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

@@ -0,0 +1,35 @@
+import buildAssetDescriptors from './assets';
+import buildPeopleDescriptors from './people';
+import buildConnectivityDescriptors from './connectivity';
+import buildMaintenanceDescriptors from './maintenance';
+import buildOperationsDescriptors from './operations';
+import buildFuelDescriptors from './fuel';
+import buildSubRecordDescriptors from './sub-records';
+import buildPolymorphicDescriptors from './polymorphic';
+
+/**
+ * Every FleetOps resource descriptor. Model names that are only polymorphic
+ * subtypes of another model (attachable-vehicle, facilitator-driver,
+ * customer-contact, …) are aliases on the concrete descriptor rather than
+ * descriptors of their own.
+ */
+export function buildFleetOpsResourceDescriptors(owner) {
+    return [
+        ...buildAssetDescriptors(owner),
+        ...buildPeopleDescriptors(owner),
+        ...buildConnectivityDescriptors(owner),
+        ...buildMaintenanceDescriptors(owner),
+        ...buildOperationsDescriptors(owner),
+        ...buildFuelDescriptors(owner),
+        ...buildSubRecordDescriptors(owner),
+        ...buildPolymorphicDescriptors(owner),
+    ].map((descriptor) => ({
+        ...descriptor,
+        components: {
+            identity: `cell/${descriptor.key}-identity`,
+            ...(descriptor.components ?? {}),
+        },
+    }));
+}
+
+export default buildFleetOpsResourceDescriptors;

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

@@ -0,0 +1,175 @@
+import { get } from '@ember/object';
+import { first, present, relation, icon, fact, relatedFact, money, join, panelOpener, polymorphicType } from './helpers';
+
+/**
+ * Issues, maintenance, schedules, work orders and inspections.
+ */
+export default function buildMaintenanceDescriptors(owner) {
+    return [
+        {
+            key: 'issue',
+            labelKey: 'resource.issue',
+            icon: 'triangle-exclamation',
+            modelNames: ['issue'],
+            polymorphicTypes: ['fleet-ops:issue', 'Fleetbase\\FleetOps\\Models\\Issue'],
+            permission: 'fleet-ops view issue',
+            statusTones: {
+                low: 'text-gray-400',
+                medium: 'text-yellow-500',
+                high: 'text-red-500',
+                critical: 'text-red-500',
+                scheduled_maintenance: 'text-yellow-500',
+                resolved: 'text-green-500',
+                completed: 'text-green-500',
+                pending: 'text-yellow-500',
+                in_progress: 'text-yellow-500',
+            },
+            title: (issue) => first(issue, 'title', 'issue_id', 'public_id'),
+            identifier: (issue) => first(issue, 'issue_id', 'public_id'),
+            image: () => icon('triangle-exclamation'),
+            status: (issue) => first(issue, 'priority', 'status'),
+            selectDetails: (issue) => [first(issue, 'type', 'category'), first(issue, 'status')],
+            facts: (issue) => [
+                fact('type', join([first(issue, 'type'), first(issue, 'category')], ' · '), { format: 'humanize' }),
+                fact('priority', first(issue, 'priority'), { format: 'humanize' }),
+                fact('status', first(issue, 'status'), { format: 'humanize' }),
+                relatedFact('vehicle', relation(owner, issue, 'vehicle'), 'vehicle', first(issue, 'vehicle_name')),
+                relatedFact('driver', relation(owner, issue, 'driver'), 'driver', first(issue, 'driver_name')),
+                relatedFact('assignee', relation(owner, issue, 'assignee'), 'user', first(issue, 'assignee_name')),
+            ],
+            open: panelOpener(owner, 'issue-actions'),
+        },
+        {
+            key: 'maintenance',
+            labelKey: 'resource.maintenance',
+            icon: 'screwdriver-wrench',
+            modelNames: ['maintenance'],
+            polymorphicTypes: ['fleet-ops:maintenance', 'Fleetbase\\FleetOps\\Models\\Maintenance'],
+            permission: 'fleet-ops view maintenance',
+            title: (maintenance) => first(maintenance, 'summary', 'type', 'public_id'),
+            identifier: (maintenance) => first(maintenance, 'public_id'),
+            image: () => icon('screwdriver-wrench'),
+            status: (maintenance) => (get(maintenance, 'is_overdue') ? 'overdue' : first(maintenance, 'status')),
+            selectDetails: (maintenance) => [first(maintenance, 'type'), first(maintenance, 'maintainable_name')],
+            facts: (maintenance) => [
+                fact('type', first(maintenance, 'type'), { format: 'humanize' }),
+                relatedFact('maintainable', relation(owner, maintenance, 'maintainable'), polymorphicType(maintenance, 'maintainable'), first(maintenance, 'maintainable_name')),
+                relatedFact('performed-by', relation(owner, maintenance, 'performed_by'), polymorphicType(maintenance, 'performed_by'), first(maintenance, 'performed_by_name')),
+                fact('scheduled', get(maintenance, 'completed_at') ?? get(maintenance, 'scheduled_at'), { format: 'date' }),
+                fact('total-cost', money(get(maintenance, 'total_cost'), get(maintenance, 'currency'))),
+                relatedFact('work-order', relation(owner, maintenance, 'work_order'), 'work-order', first(maintenance, 'work_order_subject')),
+            ],
+            open: panelOpener(owner, 'maintenance-actions'),
+        },
+        {
+            key: 'maintenance-schedule',
+            labelKey: 'resource.maintenance-schedule',
+            icon: 'calendar-check',
+            modelNames: ['maintenance-schedule'],
+            polymorphicTypes: ['fleet-ops:maintenance-schedule', 'Fleetbase\\FleetOps\\Models\\MaintenanceSchedule'],
+            permission: 'fleet-ops view maintenance-schedule',
+            statusTones: { active: 'text-green-500', paused: 'text-yellow-500', archived: 'text-gray-400' },
+            title: (schedule) => first(schedule, 'name', 'title', 'code', 'public_id'),
+            identifier: (schedule) => first(schedule, 'code') ?? join([get(schedule, 'interval_value'), first(schedule, 'interval_unit')]),
+            image: () => icon('calendar-check'),
+            status: (schedule) => first(schedule, 'status'),
+            selectDetails: (schedule) => [first(schedule, 'subject_name'), join([get(schedule, 'interval_value'), first(schedule, 'interval_unit')])],
+            facts: (schedule) => [
+                relatedFact('subject', relation(owner, schedule, 'subject'), polymorphicType(schedule, 'subject', 'subject_type'), first(schedule, 'subject_name')),
+                fact('interval', join([first(schedule, 'interval_method'), join([get(schedule, 'interval_value'), first(schedule, 'interval_unit')])], ' · '), { format: 'humanize' }),
+                fact('next-due', get(schedule, 'next_due_date') ?? get(schedule, 'nextDueAt'), { format: 'date' }),
+                relatedFact(
+                    'assignee',
+                    relation(owner, schedule, 'default_assignee'),
+                    polymorphicType(schedule, 'default_assignee', 'default_assignee_type'),
+                    first(schedule, 'default_assignee_name')
+                ),
+                fact('priority', first(schedule, 'default_priority'), { format: 'humanize' }),
+            ],
+            open: panelOpener(owner, 'maintenance-schedule-actions'),
+        },
+        {
+            key: 'work-order',
+            labelKey: 'resource.work-order',
+            icon: 'clipboard-list',
+            modelNames: ['work-order'],
+            polymorphicTypes: ['fleet-ops:work-order', 'Fleetbase\\FleetOps\\Models\\WorkOrder'],
+            permission: 'fleet-ops view work-order',
+            title: (workOrder) => first(workOrder, 'subject', 'code', 'public_id'),
+            identifier: (workOrder) => first(workOrder, 'code'),
+            image: () => icon('clipboard-list'),
+            status: (workOrder) => (get(workOrder, 'is_overdue') ? 'overdue' : first(workOrder, 'status')),
+            selectDetails: (workOrder) => [first(workOrder, 'code'), first(workOrder, 'status')],
+            facts: (workOrder) => [
+                relatedFact('target', relation(owner, workOrder, 'target'), polymorphicType(workOrder, 'target'), first(workOrder, 'target_name')),
+                relatedFact('assignee', relation(owner, workOrder, 'assignee'), polymorphicType(workOrder, 'assignee'), first(workOrder, 'assignee_name')),
+                fact('priority', first(workOrder, 'priority'), { format: 'humanize' }),
+                fact('due', get(workOrder, 'due_at'), { format: 'date' }),
+                fact('completion', present(get(workOrder, 'completion_percentage')) ? `${get(workOrder, 'completion_percentage')}%` : null),
+                relatedFact('schedule', workOrder.__schedule ?? null, 'maintenance-schedule', null),
+            ],
+            hydrate: async (workOrder) => {
+                const id = get(workOrder, 'schedule_uuid');
+                const store = owner.lookup('service:store');
+
+                if (!id || !store || workOrder.__schedule !== undefined) {
+                    return null;
+                }
+
+                try {
+                    workOrder.__schedule = store.peekRecord('maintenance-schedule', id) ?? (await store.findRecord('maintenance-schedule', id));
+                } catch {
+                    workOrder.__schedule = null;
+                }
+
+                return workOrder;
+            },
+            open: panelOpener(owner, 'work-order-actions'),
+        },
+        {
+            key: 'inspection-form',
+            labelKey: 'resource.inspection-form',
+            icon: 'list-check',
+            modelNames: ['inspection-form'],
+            polymorphicTypes: ['fleet-ops:inspection-form', 'Fleetbase\\FleetOps\\Models\\InspectionForm'],
+            permission: 'fleet-ops view inspection-form',
+            statusTones: { published: 'text-green-500', draft: 'text-yellow-500', archived: 'text-gray-400' },
+            title: (form) => first(form, 'name', 'displayName', 'public_id'),
+            identifier: (form) => join([first(form, 'type'), present(get(form, 'item_count')) ? `${get(form, 'item_count')} items` : null], ' · '),
+            image: () => icon('list-check'),
+            status: (form) => (get(form, 'is_published') ? 'published' : first(form, 'status')),
+            selectDetails: (form) => [first(form, 'type'), first(form, 'status')],
+            facts: (form) => [
+                fact('type', first(form, 'type'), { format: 'humanize' }),
+                fact('status', get(form, 'is_published') ? 'published' : first(form, 'status'), { format: 'humanize' }),
+                fact('items', get(form, 'item_count')),
+                relatedFact('subject', relation(owner, form, 'subject'), polymorphicType(form, 'subject', 'subject_type'), first(form, 'subject.displayName', 'subject.name')),
+                fact('published', get(form, 'published_at'), { format: 'date' }),
+            ],
+            open: panelOpener(owner, 'inspection-form-actions', { mode: 'transition' }),
+        },
+        {
+            key: 'inspection-submission',
+            labelKey: 'resource.inspection-submission',
+            icon: 'clipboard-check',
+            modelNames: ['inspection-submission'],
+            polymorphicTypes: ['fleet-ops:inspection-submission', 'Fleetbase\\FleetOps\\Models\\InspectionSubmission'],
+            permission: 'fleet-ops view inspection-submission',
+            statusTones: { passed: 'text-green-500', failed: 'text-red-500', submitted: 'text-green-500', draft: 'text-yellow-500' },
+            title: (submission) => first(submission, 'form.name', 'form_name', 'displayName', 'public_id'),
+            identifier: (submission) => first(submission, 'submittedAt', 'submitted_at'),
+            image: () => icon('clipboard-check'),
+            status: (submission) => first(submission, 'result', 'status'),
+            selectDetails: (submission) => [first(submission, 'vehicle_name', 'driver_name'), first(submission, 'result', 'status')],
+            facts: (submission) => [
+                relatedFact('form', relation(owner, submission, 'form'), 'inspection-form', first(submission, 'form_name')),
+                relatedFact('vehicle', relation(owner, submission, 'vehicle'), 'vehicle', first(submission, 'vehicle_name')),
+                relatedFact('driver', relation(owner, submission, 'driver'), 'driver', first(submission, 'driver_name')),
+                relatedFact('submitted-by', relation(owner, submission, 'submitted_by'), 'user', first(submission, 'submitted_by.name')),
+                fact('failed-items', present(get(submission, 'total_items')) ? `${get(submission, 'failed_items') ?? 0} of ${get(submission, 'total_items')}` : null),
+                fact('submitted', get(submission, 'submitted_at'), { format: 'date' }),
+            ],
+            open: panelOpener(owner, 'inspection-submission-actions', { mode: 'transition' }),
+        },
+    ];
+}