@fleetbase/fleetops-engine 0.6.65 → 0.6.66

package/addon/utils/inspection-form-structure.js

@@ -0,0 +1,161 @@
+import generateUuid from '@fleetbase/ember-core/utils/generate-uuid';
+import isObject from '@fleetbase/ember-core/utils/is-object';
+import { componentForFieldType, INSPECTION_FIELD_TYPES } from './inspection-field-types';
+
+/**
+ * A form's structure, in the one shape the console holds it in.
+ *
+ * The `inspection-form` model belongs to `@fleetbase/fleetops-data` and
+ * declares no structure attribute, so the builder cannot hang the groups off
+ * the record and let Ember Data carry them. It reads the structure from the
+ * internal form payload and writes it back whole under
+ * `inspection_form.field_groups`, which is what
+ * `InspectionFormController::syncStructureFromRequest()` looks for and what
+ * `InspectionFormSync::sync()` matches on `uuid`.
+ *
+ * Everything here is plain objects. Nothing in this file mutates its argument.
+ */
+
+/** Sorts groups or fields the way the builder laid them out. */
+function byOrder(a, b) {
+    const ao = a?.order ?? Number.MAX_SAFE_INTEGER;
+    const bo = b?.order ?? Number.MAX_SAFE_INTEGER;
+    return ao - bo;
+}
+
+function metaOf(value) {
+    return isObject(value) ? { ...value } : {};
+}
+
+/** One field, as the builder and the answering screen both read it. */
+export function normalizeField(field, index = 0) {
+    const type = INSPECTION_FIELD_TYPES.includes(field?.type) ? field.type : 'input';
+
+    return {
+        uuid: field?.uuid ?? field?.id ?? generateUuid(),
+        name: field?.name ?? '',
+        label: field?.label ?? '',
+        description: field?.description ?? null,
+        help_text: field?.help_text ?? null,
+        type,
+        component: field?.component ?? componentForFieldType(type),
+        required: Boolean(field?.required),
+        editable: field?.editable === undefined ? true : Boolean(field.editable),
+        options: Array.isArray(field?.options) ? [...field.options] : [],
+        order: field?.order ?? index + 1,
+        meta: metaOf(field?.meta),
+    };
+}
+
+/** One group, with its fields inside it and sorted. */
+export function normalizeGroup(group, index = 0, fields = []) {
+    const own = Array.isArray(group?.fields) ? group.fields : Array.isArray(group?.customFields) ? group.customFields : fields;
+
+    return {
+        uuid: group?.uuid ?? group?.id ?? generateUuid(),
+        name: group?.name ?? '',
+        description: group?.description ?? null,
+        order: group?.order ?? index + 1,
+        meta: { grid_size: 1, ...metaOf(group?.meta) },
+        fields: [...own].sort(byOrder).map((field, fieldIndex) => normalizeField(field, fieldIndex)),
+    };
+}
+
+/**
+ * The structure held in an internal form payload.
+ *
+ * A read carries `field_groups` (the groups alone) beside a flat `fields` list
+ * that names its group by `category_uuid`; `grouped_fields` carries the same
+ * thing already nested, and is what the driver API answers with. Either is
+ * accepted, so this works against a record read through the console and one
+ * read through the public link.
+ */
+export function normalizeFieldGroups(payload) {
+    if (!payload) {
+        return [];
+    }
+
+    const groups = Array.isArray(payload.field_groups) ? payload.field_groups : [];
+    const fields = Array.isArray(payload.fields) ? payload.fields : [];
+
+    const fromFieldGroups = groups
+        .slice()
+        .sort(byOrder)
+        .map((group, index) => {
+            const groupUuid = group?.uuid ?? group?.id;
+            const own = fields.filter((field) => (field?.category_uuid ?? null) === groupUuid);
+            return normalizeGroup(group, index, own);
+        });
+
+    const fromGroupedFields = (Array.isArray(payload.grouped_fields) ? payload.grouped_fields : [])
+        .slice()
+        .sort(byOrder)
+        .map((group, index) => normalizeGroup(group, index));
+
+    /*
+     * Two shapes describe the same structure. `field_groups` carries no fields
+     * of its own — they arrive in the sibling `fields` array, joined on
+     * `category_uuid` — while `grouped_fields` nests them. A public payload
+     * omits `category_uuid`, so the join finds nothing and every group comes
+     * back empty; take whichever shape actually produced fields.
+     *
+     * When neither did, prefer `field_groups`: a form whose groups are laid
+     * out but still empty is a real state in the builder, and returning
+     * nothing would lose those groups.
+     */
+    if (fromFieldGroups.some((group) => group.fields.length > 0)) {
+        return fromFieldGroups;
+    }
+
+    if (fromGroupedFields.some((group) => group.fields.length > 0)) {
+        return fromGroupedFields;
+    }
+
+    return fromFieldGroups.length ? fromFieldGroups : fromGroupedFields;
+}
+
+/** Every field of every group, flattened, in the order they are answered. */
+export function flattenFields(groups = []) {
+    return groups.reduce((carry, group) => carry.concat(Array.isArray(group?.fields) ? group.fields : []), []);
+}
+
+/**
+ * The structure as the server writes it. `order` is rewritten from the
+ * builder's own ordering so a drag or a delete renumbers the whole form, and
+ * the uuid is kept so a second save updates rather than duplicates.
+ */
+export function serializeFieldGroups(groups = []) {
+    return groups.map((group, groupIndex) => ({
+        uuid: group.uuid,
+        name: group.name,
+        description: group.description ?? null,
+        order: groupIndex + 1,
+        meta: metaOf(group.meta),
+        fields: (Array.isArray(group.fields) ? group.fields : []).map((field, fieldIndex) => ({
+            uuid: field.uuid,
+            name: field.name || null,
+            label: field.label,
+            description: field.description ?? null,
+            help_text: field.help_text ?? null,
+            type: field.type,
+            component: componentForFieldType(field.type),
+            required: Boolean(field.required),
+            editable: field.editable === undefined ? true : Boolean(field.editable),
+            options: Array.isArray(field.options) ? field.options.filter((option) => typeof option === 'string' && option.trim() !== '') : [],
+            order: fieldIndex + 1,
+            meta: metaOf(field.meta),
+        })),
+    }));
+}
+
+/** A blank group, ready for the builder to name. */
+export function createFieldGroup(attributes = {}) {
+    return normalizeGroup({ uuid: generateUuid(), name: '', meta: { grid_size: 1 }, fields: [], ...attributes });
+}
+
+/** A blank field of the given type. */
+export function createField(type = 'pass-fail', attributes = {}) {
+    const meta = type === 'pass-fail' ? { severity: 'medium', require_photo_on_fail: false, require_comment_on_fail: false, unsafe_on_fail: false } : {};
+
+    return normalizeField({ uuid: generateUuid(), label: '', type, meta, ...attributes });
+}

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