@fleetbase/fleetops-engine 0.6.65 → 0.6.66

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

@@ -0,0 +1,215 @@
+import { get } from '@ember/object';
+import { first, present, relation, icon, colourTile, fact, relatedFact, money, join, panelOpener, routeOpener, polymorphicType, dateLabel } from './helpers';
+
+/**
+ * Places, orders, order configs, service rates, service areas, zones,
+ * entities, manifests and recurring order schedules.
+ */
+export default function buildOperationsDescriptors(owner) {
+    return [
+        {
+            key: 'place',
+            labelKey: 'resource.place',
+            icon: 'location-dot',
+            modelNames: ['place'],
+            polymorphicTypes: ['fleet-ops:place', 'Fleetbase\\FleetOps\\Models\\Place'],
+            permission: 'fleet-ops view place',
+            title: (place) => first(place, 'displayName', 'name', 'address', 'street1', 'public_id'),
+            identifier: (place) => join([first(place, 'city'), first(place, 'country')], ', ') ?? first(place, 'public_id'),
+            image: () => icon('location-dot'),
+            selectDetails: (place) => [first(place, 'address', 'street1'), join([first(place, 'city'), first(place, 'country')], ', ')],
+            facts: (place) => [
+                fact('address', first(place, 'address', 'street1')),
+                fact('phone', first(place, 'phone')),
+                fact('type', first(place, 'type'), { format: 'humanize' }),
+                relatedFact('vendor', relation(owner, place, 'vendor'), 'vendor', first(place, 'vendor_name')),
+                fact('coordinates', first(place, 'positionString') ?? (present(get(place, 'latitude')) ? `${get(place, 'latitude')}, ${get(place, 'longitude')}` : null)),
+            ],
+            open: panelOpener(owner, 'place-actions'),
+        },
+        {
+            key: 'order',
+            labelKey: 'resource.order',
+            icon: 'box',
+            modelNames: ['order'],
+            polymorphicTypes: ['fleet-ops:order', 'Fleetbase\\FleetOps\\Models\\Order'],
+            permission: 'fleet-ops view order',
+            statusTones: {
+                created: 'text-gray-400',
+                preparing: 'text-yellow-500',
+                dispatched: 'text-yellow-500',
+                started: 'text-yellow-500',
+                in_progress: 'text-yellow-500',
+                enroute: 'text-yellow-500',
+                completed: 'text-green-500',
+                delivered: 'text-green-500',
+                canceled: 'text-red-500',
+                cancelled: 'text-red-500',
+                failed: 'text-red-500',
+            },
+            title: (order) => first(order, 'tracking', 'tracking_number.tracking_number', 'public_id'),
+            identifier: (order) => first(order, 'public_id', 'internal_id'),
+            image: () => icon('box'),
+            status: (order) => first(order, 'status'),
+            selectDetails: (order) => [first(order, 'public_id'), first(order, 'status')],
+            facts: (order) => [
+                fact('status', first(order, 'status'), { format: 'humanize' }),
+                relatedFact('customer', relation(owner, order, 'customer'), polymorphicType(order, 'customer', 'customer_type'), first(order, 'customer_name')),
+                relatedFact('driver', relation(owner, order, 'driver_assigned'), 'driver', first(order, 'driver_name')),
+                fact('route', join([first(order, 'pickupName', 'pickup_name'), first(order, 'dropoffName', 'dropoff_name')], ' → ')),
+                fact('scheduled', get(order, 'scheduled_at'), { format: 'date' }),
+                fact('order-config', first(order, 'order_config.name', 'type')),
+            ],
+            open: (order) => {
+                if (!order || order.isIdentityStub || !first(order, 'id', 'uuid')) {
+                    return false;
+                }
+
+                return panelOpener(owner, 'order-actions')(order);
+            },
+        },
+        {
+            key: 'order-config',
+            labelKey: 'resource.order-config',
+            icon: 'diagram-project',
+            modelNames: ['order-config'],
+            polymorphicTypes: ['fleet-ops:order-config', 'Fleetbase\\FleetOps\\Models\\OrderConfig'],
+            title: (config) => first(config, 'name', 'key', 'public_id'),
+            identifier: (config) => first(config, 'key', 'namespace'),
+            image: () => icon('diagram-project'),
+            status: (config) => first(config, 'status'),
+            selectDetails: (config) => [first(config, 'key', 'namespace'), first(config, 'description')],
+            facts: (config) => [
+                fact('key', first(config, 'key')),
+                fact('namespace', first(config, 'namespace')),
+                fact('version', get(config, 'version')),
+                fact('type', first(config, 'type'), { format: 'humanize' }),
+                fact('core-service', typeof get(config, 'core_service') === 'boolean' ? get(config, 'core_service') : null),
+                fact('description', first(config, 'description')),
+            ],
+            open: routeOpener(owner, 'operations.order-config'),
+        },
+        {
+            key: 'service-rate',
+            labelKey: 'resource.service-rate',
+            icon: 'file-invoice-dollar',
+            modelNames: ['service-rate'],
+            polymorphicTypes: ['fleet-ops:service-rate', 'Fleetbase\\FleetOps\\Models\\ServiceRate'],
+            permission: 'fleet-ops view service-rate',
+            title: (rate) => first(rate, 'service_name', 'public_id'),
+            identifier: (rate) => first(rate, 'service_type', 'rate_calculation_method'),
+            image: () => icon('file-invoice-dollar'),
+            selectDetails: (rate) => [first(rate, 'service_type'), first(rate, 'rate_calculation_method')],
+            facts: (rate) => [
+                fact('calculation', first(rate, 'rate_calculation_method'), { format: 'humanize' }),
+                fact('base-fee', money(get(rate, 'base_fee'), get(rate, 'currency'))),
+                relatedFact('service-area', relation(owner, rate, 'service_area'), 'service-area', first(rate, 'service_area_name')),
+                relatedFact('zone', relation(owner, rate, 'zone'), 'zone', first(rate, 'zone_name')),
+                relatedFact('order-config', relation(owner, rate, 'order_config'), 'order-config', first(rate, 'order_config.name')),
+                fact('fees', join([get(rate, 'has_cod_fee') ? 'COD' : null, get(rate, 'has_peak_hours_fee') ? 'peak hours' : null], ' · ')),
+            ],
+            open: panelOpener(owner, 'service-rate-actions'),
+        },
+        {
+            key: 'service-area',
+            labelKey: 'resource.service-area',
+            icon: 'map',
+            modelNames: ['service-area'],
+            polymorphicTypes: ['fleet-ops:service-area', 'Fleetbase\\FleetOps\\Models\\ServiceArea'],
+            title: (area) => first(area, 'name', 'public_id'),
+            identifier: (area) => first(area, 'country', 'type'),
+            image: (area) => colourTile(area, 'map'),
+            status: (area) => first(area, 'status'),
+            selectDetails: (area) => [first(area, 'type'), first(area, 'country')],
+            facts: (area) => [
+                fact('type', first(area, 'type'), { format: 'humanize' }),
+                fact('country', first(area, 'country')),
+                fact('zones', relation(owner, area, 'zones')?.length ?? null),
+                fact('speed-limit', present(get(area, 'speed_limit_kmh')) ? `${get(area, 'speed_limit_kmh')} km/h` : null),
+                fact('triggers', join([get(area, 'trigger_on_entry') ? 'entry' : null, get(area, 'trigger_on_exit') ? 'exit' : null], ' · ')),
+            ],
+            open: panelOpener(owner, 'service-area-actions'),
+        },
+        {
+            key: 'zone',
+            labelKey: 'resource.zone',
+            icon: 'draw-polygon',
+            modelNames: ['zone'],
+            polymorphicTypes: ['fleet-ops:zone', 'Fleetbase\\FleetOps\\Models\\Zone'],
+            title: (zone) => first(zone, 'name', 'public_id'),
+            identifier: (zone) => first(zone, 'service_area.name', 'service_area_name'),
+            image: (zone) => colourTile(zone, 'draw-polygon'),
+            status: (zone) => first(zone, 'status'),
+            selectDetails: (zone) => [first(zone, 'service_area.name', 'service_area_name'), first(zone, 'description')],
+            facts: (zone) => [
+                relatedFact('service-area', relation(owner, zone, 'service_area'), 'service-area', first(zone, 'service_area_name')),
+                fact('description', first(zone, 'description')),
+                fact('speed-limit', present(get(zone, 'speed_limit_kmh')) ? `${get(zone, 'speed_limit_kmh')} km/h` : null),
+                fact('dwell', present(get(zone, 'dwell_threshold_minutes')) ? `${get(zone, 'dwell_threshold_minutes')} min` : null),
+                fact('triggers', join([get(zone, 'trigger_on_entry') ? 'entry' : null, get(zone, 'trigger_on_exit') ? 'exit' : null], ' · ')),
+            ],
+            open: panelOpener(owner, 'zone-actions'),
+        },
+        {
+            key: 'entity',
+            labelKey: 'resource.entity',
+            icon: 'box-open',
+            modelNames: ['entity'],
+            polymorphicTypes: ['fleet-ops:entity', 'Fleetbase\\FleetOps\\Models\\Entity'],
+            title: (entity) => first(entity, 'name', 'sku', 'public_id'),
+            identifier: (entity) => first(entity, 'tracking', 'sku'),
+            image: (entity) => (present(get(entity, 'photo_url')) ? { url: get(entity, 'photo_url'), shape: 'square' } : icon('box-open')),
+            selectDetails: (entity) => [first(entity, 'tracking', 'sku'), first(entity, 'type')],
+            facts: (entity) => [
+                fact('type', first(entity, 'type'), { format: 'humanize' }),
+                fact('dimensions', first(entity, 'dimensions') ?? join([get(entity, 'length'), get(entity, 'width'), get(entity, 'height')], ' × ')),
+                fact('weight', first(entity, 'displayWeight') ?? join([get(entity, 'weight'), first(entity, 'weight_unit')])),
+                fact('declared-value', money(get(entity, 'declared_value'), get(entity, 'currency'))),
+                relatedFact('customer', relation(owner, entity, 'customer'), polymorphicType(entity, 'customer'), first(entity, 'customer.name')),
+                relatedFact('destination', relation(owner, entity, 'destination'), 'place', first(entity, 'destination.address')),
+            ],
+            open: panelOpener(owner, 'entity-actions', { mode: 'modal' }),
+        },
+        {
+            key: 'manifest',
+            labelKey: 'resource.manifest',
+            icon: 'list-ol',
+            modelNames: ['manifest'],
+            polymorphicTypes: ['fleet-ops:manifest', 'Fleetbase\\FleetOps\\Models\\Manifest'],
+            title: (manifest) => first(manifest, 'public_id', 'internal_id'),
+            identifier: (manifest) => first(manifest, 'scheduledDateFormatted', 'scheduled_date'),
+            image: () => icon('list-ol'),
+            status: (manifest) => first(manifest, 'status'),
+            selectDetails: (manifest) => [first(manifest, 'driver_name'), first(manifest, 'status')],
+            facts: (manifest) => [
+                relatedFact('driver', relation(owner, manifest, 'driver'), 'driver', first(manifest, 'driver_name')),
+                relatedFact('vehicle', relation(owner, manifest, 'vehicle'), 'vehicle', first(manifest, 'vehicle_name')),
+                fact('status', first(manifest, 'status'), { format: 'humanize' }),
+                fact('progress', present(get(manifest, 'stop_count')) ? `${get(manifest, 'completed_stops') ?? 0} of ${get(manifest, 'stop_count')} stops` : null),
+                fact('distance', first(manifest, 'totalDistanceKm') ? `${get(manifest, 'totalDistanceKm')} km` : null),
+                fact('scheduled', get(manifest, 'scheduled_date'), { format: 'date' }),
+            ],
+        },
+        {
+            key: 'recurring-order-schedule',
+            labelKey: 'resource.recurring-order-schedule',
+            icon: 'repeat',
+            modelNames: ['recurring-order-schedule'],
+            polymorphicTypes: ['fleet-ops:recurring-order-schedule', 'Fleetbase\\FleetOps\\Models\\RecurringOrderSchedule'],
+            statusTones: { active: 'text-green-500', paused: 'text-yellow-500', canceled: 'text-red-500' },
+            title: (schedule) => first(schedule, 'name', 'public_id'),
+            identifier: (schedule) => dateLabel(get(schedule, 'next_occurrence_at')),
+            image: () => icon('repeat'),
+            status: (schedule) => first(schedule, 'status'),
+            selectDetails: (schedule) => [first(schedule, 'status'), first(schedule, 'timezone')],
+            facts: (schedule) => [
+                relatedFact('customer', relation(owner, schedule, 'customer'), polymorphicType(schedule, 'customer', 'customer_type'), first(schedule, 'customer.name')),
+                relatedFact('driver', relation(owner, schedule, 'driver_assigned'), 'driver', first(schedule, 'driver_assigned.name')),
+                relatedFact('vehicle', relation(owner, schedule, 'vehicle_assigned'), 'vehicle', first(schedule, 'vehicle_assigned.displayName')),
+                relatedFact('order-config', relation(owner, schedule, 'order_config'), 'order-config', first(schedule, 'order_config.name')),
+                fact('next-occurrence', get(schedule, 'next_occurrence_at'), { format: 'date' }),
+                fact('timezone', first(schedule, 'timezone')),
+            ],
+        },
+    ];
+}

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

@@ -0,0 +1,173 @@
+import { get } from '@ember/object';
+import { first, present, relation, photo, badge, badges, fact, relatedFact, join, panelOpener, dateLabel, typeLabel } from './helpers';
+
+/**
+ * Drivers, vendors, contacts, customers and fleets.
+ */
+export default function buildPeopleDescriptors(owner) {
+    return [
+        {
+            key: 'driver',
+            labelKey: 'resource.driver',
+            icon: 'id-card',
+            modelNames: ['driver'],
+            aliases: ['attachable-driver', 'facilitator-driver', 'fleet-driver'],
+            polymorphicTypes: ['fleet-ops:driver', 'Fleetbase\\FleetOps\\Models\\Driver'],
+            permission: 'fleet-ops view driver',
+            statusTones: {
+                available: 'text-green-500',
+                active: 'text-green-500',
+                on_duty: 'text-green-500',
+                busy: 'text-yellow-500',
+                assigned: 'text-yellow-500',
+                unavailable: 'text-gray-400',
+                offline: 'text-gray-400',
+                suspended: 'text-red-500',
+            },
+            title: (driver) => first(driver, 'name', 'displayName', 'display_name', 'public_id'),
+            identifier: (driver) => first(driver, 'phone', 'email'),
+            image: (driver) => photo(driver, 'driver'),
+            online: (driver) => {
+                const online = get(driver, 'online');
+
+                return typeof online === 'boolean' ? online : undefined;
+            },
+            status: (driver) => first(driver, 'status'),
+            badges: (driver) => {
+                const vehicle = relation(owner, driver, 'vehicle');
+                const label = first(vehicle, 'displayName', 'display_name', 'name') ?? first(driver, 'vehicle_assigned.display_name', 'vehicle_name');
+
+                return badges(badge('vehicle', 'car', label, { relatedType: 'vehicle', relatedId: vehicle?.id ?? get(driver, 'vehicle_uuid') }));
+            },
+            selectDetails: (driver) => [first(driver, 'phone'), first(driver, 'email')],
+            facts: (driver) => [
+                fact('phone', first(driver, 'phone')),
+                fact('email', first(driver, 'email')),
+                relatedFact('vehicle', relation(owner, driver, 'vehicle'), 'vehicle', first(driver, 'vehicle_name')),
+                fact(
+                    'licence',
+                    join(
+                        [
+                            first(driver, 'drivers_license_number'),
+                            dateLabel(get(driver, 'license_expiry'), 'dd MMM yyyy') ? `expires ${dateLabel(get(driver, 'license_expiry'), 'dd MMM yyyy')}` : null,
+                        ],
+                        ' · '
+                    )
+                ),
+                relatedFact('vendor', relation(owner, driver, 'vendor'), 'vendor', first(driver, 'vendor_name')),
+                fact('status', first(driver, 'status'), { format: 'humanize' }),
+            ],
+            open: panelOpener(owner, 'driver-actions'),
+            components: { identity: 'cell/driver-identity' },
+        },
+        {
+            key: 'vendor',
+            labelKey: 'resource.vendor',
+            icon: 'building',
+            modelNames: ['vendor'],
+            aliases: ['facilitator-vendor', 'customer-vendor'],
+            polymorphicTypes: ['fleet-ops:vendor', 'Fleetbase\\FleetOps\\Models\\Vendor'],
+            permission: 'fleet-ops view vendor',
+            title: (vendor) => first(vendor, 'name', 'public_id'),
+            identifier: (vendor) => first(vendor, 'prettyType', 'internal_id', 'business_id'),
+            image: (vendor) => photo(vendor, 'vendor', 'logo_url'),
+            status: (vendor) => first(vendor, 'status'),
+            selectDetails: (vendor) => [first(vendor, 'email'), first(vendor, 'phone')],
+            facts: (vendor) => [
+                fact('type', first(vendor, 'prettyType', 'type'), { format: 'humanize' }),
+                fact('email', first(vendor, 'email')),
+                fact('phone', first(vendor, 'phone')),
+                fact('website', first(vendor, 'website_url')),
+                fact('address', first(vendor, 'address', 'place.address', 'address_street')),
+                fact('country', first(vendor, 'country')),
+            ],
+            open: panelOpener(owner, 'vendor-actions'),
+        },
+        {
+            key: 'integrated-vendor',
+            labelKey: 'resource.integrated-vendor',
+            icon: 'plug',
+            modelNames: ['integrated-vendor'],
+            aliases: ['facilitator-integrated-vendor'],
+            polymorphicTypes: ['fleet-ops:integrated-vendor', 'Fleetbase\\FleetOps\\Models\\IntegratedVendor'],
+            title: (vendor) => first(vendor, 'name', 'provider', 'public_id'),
+            identifier: (vendor) => first(vendor, 'provider'),
+            image: (vendor) => photo(vendor, 'vendor', 'logo_url'),
+            status: (vendor) => first(vendor, 'status'),
+            selectDetails: (vendor) => [first(vendor, 'provider'), get(vendor, 'sandbox') ? 'sandbox' : null],
+            facts: (vendor) => [
+                fact('provider', first(vendor, 'provider')),
+                fact('status', first(vendor, 'status'), { format: 'humanize' }),
+                fact('sandbox', typeof get(vendor, 'sandbox') === 'boolean' ? get(vendor, 'sandbox') : null),
+                fact('host', first(vendor, 'host')),
+                fact('countries', Array.isArray(get(vendor, 'supported_countries')) ? get(vendor, 'supported_countries').join(', ') : null),
+                fact('service-types', Array.isArray(get(vendor, 'service_types')) ? get(vendor, 'service_types').join(', ') : null),
+            ],
+            open: panelOpener(owner, 'integrated-vendor-actions'),
+        },
+        {
+            key: 'contact',
+            labelKey: 'resource.contact',
+            icon: 'address-book',
+            modelNames: ['contact'],
+            aliases: ['facilitator-contact', 'customer-contact'],
+            polymorphicTypes: ['fleet-ops:contact', 'Fleetbase\\FleetOps\\Models\\Contact'],
+            permission: 'fleet-ops view contact',
+            title: (contact) => first(contact, 'name', 'public_id'),
+            identifier: (contact) => first(contact, 'title') ?? typeLabel(first(contact, 'type')),
+            image: (contact) => photo(contact, 'contact'),
+            selectDetails: (contact) => [first(contact, 'email'), first(contact, 'phone')],
+            facts: (contact) => [
+                fact('title', first(contact, 'title')),
+                fact('email', first(contact, 'email')),
+                fact('phone', first(contact, 'phone')),
+                relatedFact('place', relation(owner, contact, 'place'), 'place', first(contact, 'address', 'place.address')),
+                relatedFact('user', relation(owner, contact, 'user'), 'user', first(contact, 'user.name')),
+            ],
+            open: panelOpener(owner, 'contact-actions'),
+        },
+        {
+            key: 'customer',
+            labelKey: 'resource.customer',
+            icon: 'user-tag',
+            modelNames: ['customer'],
+            aliases: ['facilitator-customer'],
+            polymorphicTypes: ['fleet-ops:customer', 'Fleetbase\\FleetOps\\Models\\Customer'],
+            permission: 'fleet-ops view contact',
+            title: (customer) => first(customer, 'name', 'public_id'),
+            identifier: (customer) => typeLabel(first(customer, 'customer_type', 'type')) ?? 'Customer',
+            image: (customer) => photo(customer, 'customer'),
+            selectDetails: (customer) => [first(customer, 'email'), first(customer, 'phone')],
+            facts: (customer) => [
+                fact('type', typeLabel(first(customer, 'customer_type', 'type'))),
+                fact('email', first(customer, 'email')),
+                fact('phone', first(customer, 'phone')),
+                fact('address', first(customer, 'address', 'address_street')),
+                relatedFact('place', relation(owner, customer, 'place'), 'place', first(customer, 'place.address')),
+            ],
+            open: panelOpener(owner, 'customer-actions'),
+        },
+        {
+            key: 'fleet',
+            labelKey: 'resource.fleet',
+            icon: 'layer-group',
+            modelNames: ['fleet'],
+            polymorphicTypes: ['fleet-ops:fleet', 'Fleetbase\\FleetOps\\Models\\Fleet'],
+            permission: 'fleet-ops view fleet',
+            title: (fleet) => first(fleet, 'name', 'public_id'),
+            identifier: (fleet) => first(fleet, 'task', 'public_id'),
+            image: (fleet) => photo(fleet, 'fleet'),
+            status: (fleet) => first(fleet, 'status'),
+            selectDetails: (fleet) => [first(fleet, 'task'), present(get(fleet, 'drivers_count')) ? `${get(fleet, 'drivers_count')} drivers` : null],
+            facts: (fleet) => [
+                fact('task', first(fleet, 'task')),
+                relatedFact('service-area', relation(owner, fleet, 'service_area'), 'service-area', first(fleet, 'service_area.name')),
+                relatedFact('zone', relation(owner, fleet, 'zone'), 'zone', first(fleet, 'zone.name')),
+                relatedFact('vendor', relation(owner, fleet, 'vendor'), 'vendor', first(fleet, 'vendor.name')),
+                fact('drivers', present(get(fleet, 'drivers_count')) ? `${get(fleet, 'drivers_online_count') ?? 0} online of ${get(fleet, 'drivers_count')}` : null),
+                fact('vehicles', present(get(fleet, 'vehicles_count')) ? `${get(fleet, 'vehicles_online_count') ?? 0} online of ${get(fleet, 'vehicles_count')}` : null),
+            ],
+            open: panelOpener(owner, 'fleet-actions'),
+        },
+    ];
+}

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

@@ -0,0 +1,123 @@
+import { get } from '@ember/object';
+import { first } from './helpers';
+
+/**
+ * The abstract polymorphic bases. A record of one of these model names
+ * carries its concrete type in a `*_type` attribute (or is itself a
+ * subtype model), so the descriptor resolves the concrete descriptor and
+ * delegates to it. The subtype models themselves (attachable-vehicle,
+ * facilitator-driver, …) are aliases on the concrete descriptors.
+ */
+const BASES = [
+    { key: 'attachable', labelKey: 'resource.attachable', icon: 'link', typeAttrs: ['attachable_type', 'type'] },
+    { key: 'customer', skip: true },
+    { key: 'facilitator', labelKey: 'resource.facilitator', icon: 'handshake', typeAttrs: ['facilitator_type', 'type'] },
+    { key: 'maintenance-subject', labelKey: 'resource.maintenance-subject', icon: 'truck', typeAttrs: ['subject_type', 'type'] },
+];
+
+function concreteKey(owner, record, typeAttrs) {
+    const registry = owner.lookup('service:resource-registry');
+
+    if (!registry || !record) {
+        return null;
+    }
+
+    const modelName = record.constructor?.modelName;
+
+    if (modelName) {
+        const key = registry.resolveKey(modelName);
+
+        if (key && !BASES.some((base) => base.key === key)) {
+            return key;
+        }
+    }
+
+    for (const attr of typeAttrs) {
+        const key = registry.resolveKey(get(record, attr));
+
+        if (key && !BASES.some((base) => base.key === key)) {
+            return key;
+        }
+    }
+
+    return null;
+}
+
+function delegate(owner, typeAttrs, field, fallback) {
+    return (record, ...rest) => {
+        const registry = owner.lookup('service:resource-registry');
+        const key = concreteKey(owner, record, typeAttrs);
+        const descriptor = key ? registry.getDescriptor(key) : null;
+        const value = descriptor?.[field];
+
+        if (typeof value === 'function') {
+            return value(record, ...rest);
+        }
+
+        return typeof fallback === 'function' ? fallback(record, ...rest) : fallback;
+    };
+}
+
+/**
+ * The concrete record behind a polymorphic base record: an index payload
+ * normalizes a facilitator as a bare `facilitator` model, which the concrete
+ * resource's panel cannot use. A record that already is the concrete model or
+ * one of its subtypes is returned as it is.
+ */
+export async function loadConcreteRecord(owner, descriptor, record) {
+    const modelName = record?.constructor?.modelName;
+    const known = [...(descriptor.modelNames ?? []), ...(descriptor.aliases ?? [])];
+    const id = record ? (get(record, 'id') ?? get(record, 'uuid')) : null;
+    const canonical = descriptor.modelNames?.[0];
+    const store = owner.lookup('service:store');
+
+    if (!modelName || known.includes(modelName) || !id || !canonical || !store) {
+        return record;
+    }
+
+    try {
+        return store.peekRecord(canonical, id) ?? (await store.findRecord(canonical, id)) ?? record;
+    } catch {
+        return record;
+    }
+}
+
+export function resolveConcreteResourceKey(owner, record, typeAttrs = ['attachable_type', 'facilitator_type', 'subject_type', 'customer_type', 'maintainable_type', 'type']) {
+    return concreteKey(owner, record, typeAttrs);
+}
+
+export default function buildPolymorphicDescriptors(owner) {
+    return BASES.filter((base) => !base.skip).map((base) => ({
+        key: base.key,
+        labelKey: base.labelKey,
+        icon: base.icon,
+        modelNames: [base.key],
+        polymorphicTypes: [`fleet-ops:${base.key}`],
+        title: delegate(owner, base.typeAttrs, 'title', (record) => first(record, 'displayName', 'display_name', 'name', 'public_id')),
+        identifier: delegate(owner, base.typeAttrs, 'identifier', null),
+        image: delegate(owner, base.typeAttrs, 'image', () => ({ icon: base.icon })),
+        online: delegate(owner, base.typeAttrs, 'online', undefined),
+        status: delegate(owner, base.typeAttrs, 'status', (record) => first(record, 'status')),
+        badges: delegate(owner, base.typeAttrs, 'badges', []),
+        selectDetails: delegate(owner, base.typeAttrs, 'selectDetails', (record) => [first(record, 'type')]),
+        facts: delegate(owner, base.typeAttrs, 'facts', []),
+        canOpen: (record) => Boolean(concreteKey(owner, record, base.typeAttrs)),
+        open: async (record, context) => {
+            const registry = owner.lookup('service:resource-registry');
+            const key = concreteKey(owner, record, base.typeAttrs);
+            const descriptor = key ? registry.getDescriptor(key) : null;
+
+            if (typeof descriptor?.open !== 'function') {
+                return false;
+            }
+
+            // Open through the concrete descriptor directly. Handing the base
+            // record back to `registry.open` resolves it to this descriptor
+            // again, and the promise loop froze the page with no error.
+            const concrete = await loadConcreteRecord(owner, descriptor, record);
+
+            return descriptor.open(concrete, { ...context, resourceType: key });
+        },
+        components: { identity: `cell/${base.key}-identity` },
+    }));
+}