@fleetbase/fleetops-engine 0.6.38 → 0.6.39

package/addon/services/maintenance-schedule-actions.js

@@ -0,0 +1,118 @@
+import ResourceActionService from '@fleetbase/ember-core/services/resource-action';
+import { action } from '@ember/object';
+import { inject as service } from '@ember/service';
+
+export default class MaintenanceScheduleActionsService extends ResourceActionService {
+    @service fetch;
+    @service notifications;
+    @service intl;
+
+    constructor() {
+        super(...arguments);
+        this.initialize('maintenance-schedule');
+    }
+
+    transition = {
+        view: (schedule) => this.transitionTo('maintenance.schedules.index.details', schedule),
+        edit: (schedule) => this.transitionTo('maintenance.schedules.index.edit', schedule),
+        create: () => this.transitionTo('maintenance.schedules.index.new'),
+    };
+
+    panel = {
+        create: (attributes = {}) => {
+            const schedule = this.createNewInstance(attributes);
+            return this.resourceContextPanel.open({
+                content: 'maintenance-schedule/form',
+                title: this.intl.t('common.create-a-new-resource', { resource: this.intl.t('resource.maintenance-schedule')?.toLowerCase() }),
+                useDefaultSaveTask: true,
+                saveOptions: {
+                    callback: this.refresh,
+                },
+                schedule,
+            });
+        },
+        edit: (schedule) => {
+            return this.resourceContextPanel.open({
+                content: 'maintenance-schedule/form',
+                title: this.intl.t('common.edit-resource-name', { resourceName: schedule.name }),
+                useDefaultSaveTask: true,
+                schedule,
+            });
+        },
+        view: (schedule) => {
+            return this.resourceContextPanel.open({
+                schedule,
+                tabs: [
+                    {
+                        label: this.intl.t('common.overview'),
+                        component: 'maintenance-schedule/details',
+                    },
+                ],
+            });
+        },
+    };
+
+    modal = {
+        create: (attributes = {}, options = {}, saveOptions = {}) => {
+            const schedule = this.createNewInstance(attributes);
+            return this.modalsManager.show('modals/resource', {
+                resource: schedule,
+                title: this.intl.t('common.create-a-new-resource', { resource: this.intl.t('resource.maintenance-schedule')?.toLowerCase() }),
+                acceptButtonText: this.intl.t('common.create-resource', { resource: this.intl.t('resource.maintenance-schedule') }),
+                component: 'maintenance-schedule/form',
+                confirm: (modal) => this.modalTask.perform(modal, 'saveTask', schedule, { refresh: true, ...saveOptions }),
+                ...options,
+            });
+        },
+        edit: (schedule, options = {}, saveOptions = {}) => {
+            return this.modalsManager.show('modals/resource', {
+                resource: schedule,
+                title: this.intl.t('common.edit-resource-name', { resourceName: schedule.name }),
+                acceptButtonText: this.intl.t('common.save-changes'),
+                saveButtonIcon: 'save',
+                component: 'maintenance-schedule/form',
+                confirm: (modal) => this.modalTask.perform(modal, 'saveTask', schedule, { refresh: true, ...saveOptions }),
+                ...options,
+            });
+        },
+    };
+
+    /**
+     * Pause a maintenance schedule.
+     */
+    @action async pause(schedule) {
+        try {
+            await this.fetch.post(`maintenance-schedules/${schedule.id}/pause`);
+            schedule.set('status', 'paused');
+            this.notifications.success('Schedule paused successfully.');
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    /**
+     * Resume a paused maintenance schedule.
+     */
+    @action async resume(schedule) {
+        try {
+            await this.fetch.post(`maintenance-schedules/${schedule.id}/resume`);
+            schedule.set('status', 'active');
+            this.notifications.success('Schedule resumed successfully.');
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    /**
+     * Manually trigger a work order from a schedule immediately.
+     */
+    @action async triggerNow(schedule) {
+        try {
+            const response = await this.fetch.post(`maintenance-schedules/${schedule.id}/trigger`);
+            this.notifications.success(`Work order ${response?.work_order?.public_id ?? ''} created from schedule.`);
+            this.refresh();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+}

package/addon/services/orchestration-engine-interface.js

@@ -0,0 +1,49 @@
+import Service from '@ember/service';
+
+/**
+ * OrchestrationEngineInterfaceService
+ *
+ * Base class that all allocation engine adapters must extend.
+ * The interface mirrors the backend OrchestrationEngineInterface contract.
+ *
+ * Third-party engines extend this class, implement allocate(), and register
+ * themselves via an instance initializer:
+ *
+ *   // addon/instance-initializers/register-my-engine.js
+ *   export function initialize(appInstance) {
+ *       const registry = appInstance.lookup('service:orchestration-engine');
+ *       const engine   = appInstance.lookup('service:my-allocation-engine');
+ *       registry.register('my-engine', engine);
+ *   }
+ *   export default { name: 'register-my-engine', initialize };
+ *
+ * @abstract
+ */
+export default class OrchestrationEngineInterfaceService extends Service {
+    /**
+     * Human-readable display name shown in the settings dropdown.
+     * @type {string}
+     */
+    name = 'Unknown Engine';
+
+    /**
+     * Machine-readable identifier. Must be unique across all registered engines.
+     * @type {string}
+     */
+    identifier = 'unknown';
+
+    /**
+     * Run the allocation algorithm.
+     *
+     * @param {Array}  orders   Array of order records to allocate.
+     * @param {Array}  vehicles Array of vehicle records (with loaded driver).
+     * @param {Object} options  Engine-specific options.
+     * @returns {Promise<{assignments: Array, unassigned: Array, summary: Object}>}
+     *
+     * @abstract
+     */
+    // eslint-disable-next-line no-unused-vars
+    async allocate(orders, vehicles, options = {}) {
+        throw new Error(`OrchestrationEngineInterfaceService: allocate() must be implemented by ${this.constructor.name}`);
+    }
+}

package/addon/services/orchestration-engine.js

@@ -0,0 +1,74 @@
+import Service from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+
+/**
+ * AllocationEngineService
+ *
+ * Registry service for allocation engine adapters. Mirrors the backend
+ * OrchestrationEngineRegistry pattern. Engines register themselves from
+ * instance initializers and the settings UI reads availableEngines to
+ * populate the engine selector dropdown.
+ *
+ * This service is intentionally engine-agnostic — it has no knowledge of
+ * VROOM or any other specific solver.
+ */
+export default class AllocationEngineService extends Service {
+    /**
+     * Map of registered engines keyed by identifier.
+     * @type {Map<string, OrchestrationEngineInterfaceService>}
+     */
+    @tracked _engines = new Map();
+
+    /**
+     * Register an allocation engine adapter.
+     *
+     * @param {string}                            identifier  Unique engine key.
+     * @param {OrchestrationEngineInterfaceService}  engine      Engine service instance.
+     * @throws {Error} if an engine with the same identifier is already registered.
+     */
+    register(identifier, engine) {
+        if (this._engines.has(identifier)) {
+            throw new Error(`AllocationEngineService: engine '${identifier}' is already registered.`);
+        }
+        this._engines.set(identifier, engine);
+    }
+
+    /**
+     * Resolve an engine by identifier.
+     *
+     * @param  {string} identifier
+     * @returns {OrchestrationEngineInterfaceService}
+     * @throws {Error} if no engine with the given identifier is registered.
+     */
+    resolve(identifier) {
+        const engine = this._engines.get(identifier);
+        if (!engine) {
+            const available = [...this._engines.keys()].join(', ');
+            throw new Error(`AllocationEngineService: no engine registered for '${identifier}'. Available: ${available}`);
+        }
+        return engine;
+    }
+
+    /**
+     * Return all registered engines as an array of {id, name} objects.
+     * Used by the settings UI to populate the engine selector dropdown.
+     *
+     * @returns {Array<{id: string, name: string}>}
+     */
+    get availableEngines() {
+        return [...this._engines.values()].map((engine) => ({
+            id: engine.identifier,
+            name: engine.name,
+        }));
+    }
+
+    /**
+     * Check whether an engine with the given identifier is registered.
+     *
+     * @param  {string} identifier
+     * @returns {boolean}
+     */
+    has(identifier) {
+        return this._engines.has(identifier);
+    }
+}

package/addon/services/order-actions.js

@@ -483,6 +483,21 @@ export default class OrderActionsService extends ResourceActionService {
         }
     }
 
+    // ── Import orders ─────────────────────────────────────────────────────
+    // Opens the three-step orchestrator import modal. Accepts an optional
+    // onImportComplete callback that is called after a successful import.
+    @action importOrders(options = {}) {
+        return this.modalsManager.show('modals/orchestrator-import', {
+            title: this.intl.t('orchestrator.import-orders'),
+            modalClass: 'modal-xl fleetops-order-import',
+            modalHeaderClass: 'import-modal-header',
+            hideAcceptButton: true,
+            onImportComplete: options.onImportComplete ?? this.refresh,
+            onImportTemplate: options.onImportTemplate,
+            ...options,
+        });
+    }
+
     #serializeWaypoints(waypoints = []) {
         if (!waypoints) return [];
 

package/addon/services/order-allocation.js

@@ -0,0 +1,116 @@
+import Service, { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { task } from 'ember-concurrency';
+
+/**
+ * OrderAllocationService
+ *
+ * Orchestrates the full allocation workflow:
+ *   1. Fetch unassigned orders and available vehicles
+ *   2. Run the active orchestration engine (via the orchestration-engine registry)
+ *   3. Present the proposed plan to the dispatcher
+ *   4. Commit confirmed assignments to the backend
+ *
+ * This service is injected into the Dispatcher Workbench component and the
+ * orchestrator settings controller.
+ */
+export default class OrderAllocationService extends Service {
+    @service fetch;
+    @service store;
+    @service notifications;
+    @service intl;
+
+    /** The proposed allocation plan returned by the last run. */
+    @tracked currentPlan = null;
+
+    /** Whether an allocation run is in progress. */
+    @tracked isRunning = false;
+
+    /** The identifier of the currently active engine (from settings). */
+    @tracked activeEngineId = 'greedy';
+
+    /**
+     * Load orchestrator settings from the backend.
+     */
+    @task *loadSettings() {
+        try {
+            const settings = yield this.fetch.get('fleet-ops/settings/orchestrator-settings');
+            this.activeEngineId = settings.orchestrator_engine ?? 'greedy';
+            return settings;
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    /**
+     * Save orchestrator settings to the backend.
+     *
+     * @param {Object} settings
+     */
+    @task *saveSettings(settings) {
+        try {
+            yield this.fetch.post('fleet-ops/settings/orchestrator-settings', settings);
+            this.notifications.success(this.intl.t('orchestrator.settings-saved'));
+        } catch (error) {
+            this.notifications.serverError(error);
+            throw error;
+        }
+    }
+
+    /**
+     * Run the orchestration engine and store the proposed plan.
+     *
+     * @param {Array}  orderIds   Optional list of order public_ids to allocate.
+     * @param {Array}  vehicleIds Optional list of vehicle public_ids to use.
+     * @param {Object} options    Engine-specific options.
+     */
+    @task *run(orderIds = [], vehicleIds = [], options = {}) {
+        this.isRunning = true;
+        try {
+            const result = yield this.fetch.post('fleet-ops/orchestrator/run', {
+                order_ids: orderIds,
+                vehicle_ids: vehicleIds,
+                options,
+            });
+            this.currentPlan = result;
+            return result;
+        } catch (error) {
+            this.notifications.serverError(error);
+            throw error;
+        } finally {
+            this.isRunning = false;
+        }
+    }
+
+    /**
+     * Commit a (possibly modified) orchestration plan.
+     * The dispatcher may have adjusted assignments via drag-and-drop before
+     * calling commit.
+     *
+     * @param {Array} assignments  Array of {order_id, vehicle_id, driver_id, sequence}
+     */
+    @task *commit(assignments) {
+        try {
+            const result = yield this.fetch.post('fleet-ops/orchestrator/commit', { assignments });
+            this.notifications.success(this.intl.t('orchestrator.committed', { count: result.committed?.length ?? 0 }));
+            this.currentPlan = null;
+            return result;
+        } catch (error) {
+            this.notifications.serverError(error);
+            throw error;
+        }
+    }
+
+    /**
+     * Fetch the list of available orchestration engines from the backend.
+     * Used to cross-validate that the backend and frontend registries are in sync.
+     */
+    @task *fetchAvailableEngines() {
+        try {
+            const response = yield this.fetch.get('fleet-ops/orchestrator/engines');
+            return response.engines ?? [];
+        } catch (error) {
+            return [];
+        }
+    }
+}

package/addon/services/part-actions.js

@@ -1,9 +1,19 @@
-import ResourceActionService from '@fleetbase/ember-core/services/resource-action';
+import ResourceActionService, { inject as service } from '@fleetbase/ember-core/services/resource-action';
 
 export default class PartActionsService extends ResourceActionService {
+    @service currentUser;
+
     constructor() {
         super(...arguments);
-        this.initialize('part');
+        this.initialize('part', {
+            defaultAttributes: {
+                currency: this.defaultCurrency,
+            },
+        });
+    }
+
+    get defaultCurrency() {
+        return this.currentUser?.company?.currency || 'USD';
     }
 
     transition = {