@fleetbase/fleetops-engine 0.6.37 → 0.6.39

package/addon/controllers/operations/scheduler.js

@@ -0,0 +1,21 @@
+import Controller from '@ember/controller';
+import { inject as service } from '@ember/service';
+
+export default class OperationsSchedulerController extends Controller {
+    @service intl;
+
+    get tabs() {
+        return [
+            {
+                route: 'operations.scheduler.index',
+                label: this.intl.t('scheduler.orders-tab'),
+                icon: 'box',
+            },
+            {
+                route: 'operations.scheduler.fleet-schedule',
+                label: this.intl.t('scheduler.fleet-schedule-tab'),
+                icon: 'calendar-week',
+            },
+        ];
+    }
+}

package/addon/controllers/settings/orchestrator.js

@@ -0,0 +1,70 @@
+import Controller from '@ember/controller';
+import { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { action } from '@ember/object';
+import { task } from 'ember-concurrency';
+
+/**
+ * Settings::OrchestratorController
+ *
+ * Manages the Orchestrator settings page at /settings/orchestrator.
+ * Loads current settings, presents the engine selector dropdown (populated
+ * from the allocation-engine registry), and saves changes.
+ */
+export default class SettingsOrchestratorController extends Controller {
+    @service fetch;
+    @service notifications;
+    @service intl;
+    @service('orchestration-engine') engineRegistry;
+
+    @tracked allocationEngine = 'vroom';
+    @tracked autoAllocateOnCreate = false;
+    @tracked autoReallocateOnComplete = false;
+    @tracked maxTravelTimeSeconds = 3600;
+    @tracked balanceWorkload = false;
+    @tracked isLoading = false;
+
+    /**
+     * Engine options for the selector dropdown.
+     * Populated from the allocation-engine registry so new engines appear
+     * automatically without modifying this controller.
+     */
+    get engineOptions() {
+        return this.engineRegistry.availableEngines;
+    }
+
+    @task *loadSettings() {
+        this.isLoading = true;
+        try {
+            const settings = yield this.fetch.get('fleet-ops/settings/orchestrator-settings');
+            this.allocationEngine = settings.allocation_engine ?? 'vroom';
+            this.autoAllocateOnCreate = settings.auto_allocate_on_create ?? false;
+            this.autoReallocateOnComplete = settings.auto_reallocate_on_complete ?? false;
+            this.maxTravelTimeSeconds = settings.max_travel_time_seconds ?? 3600;
+            this.balanceWorkload = settings.balance_workload ?? false;
+        } catch (error) {
+            this.notifications.serverError(error);
+        } finally {
+            this.isLoading = false;
+        }
+    }
+
+    @task *saveSettings() {
+        try {
+            yield this.fetch.post('fleet-ops/settings/orchestrator-settings', {
+                allocation_engine: this.allocationEngine,
+                auto_allocate_on_create: this.autoAllocateOnCreate,
+                auto_reallocate_on_complete: this.autoReallocateOnComplete,
+                max_travel_time_seconds: this.maxTravelTimeSeconds,
+                balance_workload: this.balanceWorkload,
+            });
+            this.notifications.success(this.intl.t('orchestrator.settings-saved'));
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    @action selectEngine(engine) {
+        this.allocationEngine = engine.id;
+    }
+}

package/addon/controllers/settings/scheduling.js

@@ -0,0 +1,155 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+import { task } from 'ember-concurrency';
+
+/**
+ * Settings::SchedulingController
+ *
+ * Manages global scheduling settings for Fleet-Ops:
+ *   - Default schedule horizon (how many days ahead to materialise shifts)
+ *   - Default shift duration
+ *   - HOS (Hours of Service) daily/weekly limits
+ *   - Whether to auto-activate schedules on first shift creation
+ *   - Whether to notify drivers of new/changed shifts
+ *   - Reusable schedule templates library
+ */
+export default class SettingsSchedulingController extends Controller {
+    @service fetch;
+    @service notifications;
+    @service intl;
+    @service store;
+    @service modalsManager;
+
+    /** How many days ahead to materialise schedule items (default 60) */
+    @tracked horizonDays = 60;
+
+    /** Default shift duration in hours (default 8) */
+    @tracked defaultShiftDuration = 8;
+
+    /** HOS daily driving limit in hours (default 11) */
+    @tracked hosDailyLimit = 11;
+
+    /** HOS weekly driving limit in hours (default 70) */
+    @tracked hosWeeklyLimit = 70;
+
+    /** Whether to auto-activate a draft schedule when the first shift is added */
+    @tracked autoActivateSchedule = true;
+
+    /** Whether to notify drivers when shifts are created or modified */
+    @tracked notifyDriversOnShiftChange = false;
+
+    /** Reusable (library) schedule templates */
+    @tracked scheduleTemplates = [];
+
+    get templateActionButtons() {
+        return [
+            {
+                type: 'primary',
+                icon: 'plus',
+                iconPrefix: 'fas',
+                text: this.intl.t('settings.scheduling.new-template'),
+                onClick: this.createTemplate,
+            },
+        ];
+    }
+
+    constructor() {
+        super(...arguments);
+        this.getSettings.perform();
+        this.loadTemplates.perform();
+    }
+
+    /**
+     * Load scheduling settings from the backend.
+     */
+    @task *getSettings() {
+        try {
+            const settings = yield this.fetch.get('fleet-ops/settings/scheduling-settings');
+            if (settings) {
+                this.horizonDays = settings.horizon_days ?? 60;
+                this.defaultShiftDuration = settings.default_shift_duration ?? 8;
+                this.hosDailyLimit = settings.hos_daily_limit ?? 11;
+                this.hosWeeklyLimit = settings.hos_weekly_limit ?? 70;
+                this.autoActivateSchedule = settings.auto_activate_schedule ?? true;
+                this.notifyDriversOnShiftChange = settings.notify_drivers_on_shift_change ?? false;
+            }
+        } catch {
+            // Settings may not exist yet — use defaults silently
+        }
+    }
+
+    /**
+     * Save scheduling settings to the backend.
+     */
+    @task *saveSettings() {
+        try {
+            yield this.fetch.post('fleet-ops/settings/scheduling-settings', {
+                horizon_days: this.horizonDays,
+                default_shift_duration: this.defaultShiftDuration,
+                hos_daily_limit: this.hosDailyLimit,
+                hos_weekly_limit: this.hosWeeklyLimit,
+                auto_activate_schedule: this.autoActivateSchedule,
+                notify_drivers_on_shift_change: this.notifyDriversOnShiftChange,
+            });
+            this.notifications.success(this.intl.t('settings.scheduling.settings-saved'));
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    /**
+     * Load reusable (library) schedule templates — those without a subject_uuid.
+     */
+    @task *loadTemplates() {
+        try {
+            const templates = yield this.store.query('schedule-template', { is_library: true });
+            this.scheduleTemplates = templates.toArray();
+        } catch {
+            this.scheduleTemplates = [];
+        }
+    }
+
+    /**
+     * Open the create-template modal.
+     */
+    @action createTemplate() {
+        this.modalsManager.show('modals/add-driver-shift', {
+            title: this.intl.t('settings.scheduling.new-template'),
+            isLibraryTemplate: true,
+            onConfirm: () => this.loadTemplates.perform(),
+        });
+    }
+
+    /**
+     * Open the edit-template modal.
+     */
+    @action editTemplate(template) {
+        this.modalsManager.show('modals/add-driver-shift', {
+            title: this.intl.t('settings.scheduling.edit-template'),
+            isLibraryTemplate: true,
+            template,
+            onConfirm: () => this.loadTemplates.perform(),
+        });
+    }
+
+    /**
+     * Delete a schedule template after confirmation.
+     */
+    @action async deleteTemplate(template) {
+        await this.modalsManager.confirm({
+            title: this.intl.t('settings.scheduling.delete-template'),
+            body: this.intl.t('settings.scheduling.delete-template-confirm', { name: template.name }),
+            onConfirm: async () => {
+                try {
+                    await template.destroyRecord();
+                    this.scheduleTemplates = this.scheduleTemplates.filter((t) => t.id !== template.id);
+                    this.notifications.success(this.intl.t('settings.scheduling.template-deleted'));
+                } catch (error) {
+                    this.notifications.serverError(error);
+                }
+            },
+        });
+    }
+}

package/addon/extension.js

@@ -7,7 +7,67 @@ export default {
         const widgetService = universe.getService('widget');
 
         // Register header navigation
-        menuService.registerHeaderMenuItem('Fleet-Ops', 'console.fleet-ops', { icon: 'route', priority: 0 });
+        menuService.registerHeaderMenuItem('Fleet-Ops', 'console.fleet-ops', {
+            icon: 'route',
+            priority: 0,
+            description: 'Dispatch, fleet management, driver tracking, and logistics operations.',
+            shortcuts: [
+                {
+                    title: 'Orders',
+                    description: 'Create, dispatch, and track delivery orders in real time.',
+                    icon: 'boxes-stacked',
+                    route: 'console.fleet-ops.operations.orders',
+                },
+                {
+                    title: 'Places',
+                    description: 'Manage saved locations, addresses, and points of interest.',
+                    icon: 'location-dot',
+                    route: 'console.fleet-ops.management.places',
+                },
+                {
+                    title: 'Drivers',
+                    description: 'Manage driver profiles, assignments, and live locations.',
+                    icon: 'id-card',
+                    route: 'console.fleet-ops.management.drivers',
+                },
+                {
+                    title: 'Vehicles',
+                    description: 'View and manage your vehicle fleet and telematics.',
+                    icon: 'truck',
+                    route: 'console.fleet-ops.management.vehicles',
+                },
+                {
+                    title: 'Fleets',
+                    description: 'Organise drivers and vehicles into operational fleets.',
+                    icon: 'layer-group',
+                    route: 'console.fleet-ops.management.fleets',
+                },
+                {
+                    title: 'Service Rates',
+                    description: 'Configure pricing rules and service rate cards.',
+                    icon: 'tags',
+                    route: 'console.fleet-ops.operations.service-rates',
+                },
+                {
+                    title: 'Devices',
+                    description: 'Manage connected telematics devices and their sensor data.',
+                    icon: 'microchip',
+                    route: 'console.fleet-ops.connectivity.devices',
+                },
+                {
+                    title: 'Reports',
+                    description: 'Generate and review operational analytics reports.',
+                    icon: 'chart-bar',
+                    route: 'console.fleet-ops.analytics.reports',
+                },
+                {
+                    title: 'Orchestrator',
+                    description: 'Intelligently allocate and dispatch orders to available drivers.',
+                    icon: 'diagram-project',
+                    route: 'console.fleet-ops.operations.orchestrator',
+                },
+            ],
+        });
 
         // Register admin sections
         menuService.registerAdminMenuPanel(
@@ -99,6 +159,18 @@ export default {
             'fleet-ops:component:issue:form:details',
             'fleet-ops:component:fuel-report:form',
             'fleet-ops:component:fuel-report:form:details',
+            'fleet-ops:component:maintenance:form',
+            'fleet-ops:component:maintenance:form:details',
+            'fleet-ops:component:maintenance:details',
+            'fleet-ops:component:work-order:form',
+            'fleet-ops:component:work-order:form:details',
+            'fleet-ops:component:work-order:details',
+            'fleet-ops:component:equipment:form',
+            'fleet-ops:component:equipment:form:details',
+            'fleet-ops:component:equipment:details',
+            'fleet-ops:component:part:form',
+            'fleet-ops:component:part:form:details',
+            'fleet-ops:component:part:details',
             'fleet-ops:contextmenu:vehicle',
             'fleet-ops:contextmenu:driver',
             'fleet-ops:component:order:details',
@@ -106,6 +178,7 @@ export default {
             'fleet-ops:component:order:form:payload:entity',
             'fleet-ops:component:order:form:payload:entity:form',
             'fleet-ops:template:settings:routing',
+            'fleet-ops:template:settings:orchestrator',
         ]);
     },
 };

package/addon/instance-initializers/register-vroom-allocation.js

@@ -0,0 +1,27 @@
+/**
+ * register-vroom-allocation
+ *
+ * Instance initializer that registers the VROOM orchestration engine adapter
+ * into the orchestration-engine registry service.
+ *
+ * This pattern is identical to how register-osrm.js registers the OSRM
+ * routing engine into the route-optimization registry.
+ *
+ * Third-party orchestration engines follow the same pattern:
+ *   1. Create a service extending OrchestrationEngineInterfaceService
+ *   2. Create an instance initializer that calls orchestrationEngine.register()
+ *   3. The engine will appear in the FleetOps orchestrator settings dropdown
+ */
+export function initialize(appInstance) {
+    const orchestrationEngine = appInstance.lookup('service:orchestration-engine');
+    const vroomEngine = appInstance.lookup('service:vroom-allocation-engine');
+
+    if (orchestrationEngine && vroomEngine && !orchestrationEngine.has('vroom')) {
+        orchestrationEngine.register('vroom', vroomEngine);
+    }
+}
+
+export default {
+    name: 'register-vroom-allocation',
+    initialize,
+};

package/addon/models/maintenance-schedule.js

@@ -0,0 +1,61 @@
+import Model, { attr, belongsTo } from '@ember-data/model';
+
+/**
+ * Local maintenance-schedule model used by the fleetops engine.
+ * The canonical model with full computed properties lives in fleetops-data.
+ * This local copy adds the polymorphic @belongsTo relationships so the
+ * engine's form and details components can use relationship accessors
+ * directly instead of raw _type / _uuid attrs.
+ */
+export default class MaintenanceScheduleModel extends Model {
+    // Identification
+    @attr('string') public_id;
+    @attr('string') name;
+    @attr('string') type;
+    @attr('string') status;
+
+    // Polymorphic subject (the asset this schedule applies to)
+    @belongsTo('maintenance-subject', { polymorphic: true, async: false }) subject;
+
+    // Polymorphic default_assignee (who should be assigned to generated work orders)
+    @belongsTo('facilitator', { polymorphic: true, async: false }) default_assignee;
+
+    // Interval definition
+    @attr('string') interval_method;
+    @attr('string') interval_type;
+    @attr('number') interval_value;
+    @attr('string') interval_unit;
+    @attr('number') interval_distance;
+    @attr('number') interval_engine_hours;
+
+    // Baseline readings
+    @attr('number') last_service_odometer;
+    @attr('number') last_service_engine_hours;
+    @attr('date') last_service_date;
+
+    // Next-due thresholds
+    @attr('date') next_due_date;
+    @attr('number') next_due_odometer;
+    @attr('number') next_due_engine_hours;
+
+    // Work order defaults
+    @attr('string') default_priority;
+    @attr('string') instructions;
+    @attr() meta;
+
+    @attr('date') created_at;
+    @attr('date') updated_at;
+
+    // Computed display helpers
+    get nextDueDate() {
+        return this.next_due_date;
+    }
+
+    get isActive() {
+        return this.status === 'active';
+    }
+
+    get isPaused() {
+        return this.status === 'paused';
+    }
+}

package/addon/routes/maintenance/equipment/index/details.js

@@ -1,3 +1,29 @@
 import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
 
-export default class MaintenanceEquipmentIndexDetailsRoute extends Route {}
+export default class MaintenanceEquipmentIndexDetailsRoute extends Route {
+    @service store;
+    @service notifications;
+    @service hostRouter;
+    @service abilities;
+    @service intl;
+
+    @action error(error) {
+        this.notifications.serverError(error);
+        if (typeof error.message === 'string' && error.message.endsWith('not found')) {
+            return this.hostRouter.transitionTo('maintenance.equipment.index');
+        }
+    }
+
+    beforeModel() {
+        if (this.abilities.cannot('fleet-ops view equipment')) {
+            this.notifications.warning(this.intl.t('common.unauthorized-access'));
+            return this.hostRouter.transitionTo('maintenance.equipment.index');
+        }
+    }
+
+    model({ public_id }) {
+        return this.store.findRecord('equipment', public_id);
+    }
+}

package/addon/routes/maintenance/equipment/index/edit.js

@@ -1,3 +1,29 @@
 import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
 
-export default class MaintenanceEquipmentIndexEditRoute extends Route {}
+export default class MaintenanceEquipmentIndexEditRoute extends Route {
+    @service store;
+    @service notifications;
+    @service hostRouter;
+    @service abilities;
+    @service intl;
+
+    @action error(error) {
+        this.notifications.serverError(error);
+        if (typeof error.message === 'string' && error.message.endsWith('not found')) {
+            return this.hostRouter.transitionTo('maintenance.equipment.index');
+        }
+    }
+
+    beforeModel() {
+        if (this.abilities.cannot('fleet-ops update equipment')) {
+            this.notifications.warning(this.intl.t('common.unauthorized-access'));
+            return this.hostRouter.transitionTo('maintenance.equipment.index');
+        }
+    }
+
+    model({ public_id }) {
+        return this.store.findRecord('equipment', public_id);
+    }
+}

package/addon/routes/maintenance/maintenances/index/details/index.js

@@ -0,0 +1,3 @@
+import Route from '@ember/routing/route';
+
+export default class MaintenanceMaintenancesIndexDetailsIndexRoute extends Route {}

package/addon/routes/maintenance/maintenances/index/details.js

@@ -0,0 +1,29 @@
+import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+
+export default class MaintenanceMaintenancesIndexDetailsRoute extends Route {
+    @service store;
+    @service notifications;
+    @service hostRouter;
+    @service abilities;
+    @service intl;
+
+    @action error(error) {
+        this.notifications.serverError(error);
+        if (typeof error.message === 'string' && error.message.endsWith('not found')) {
+            return this.hostRouter.transitionTo('maintenance.maintenances.index');
+        }
+    }
+
+    beforeModel() {
+        if (this.abilities.cannot('fleet-ops view maintenance')) {
+            this.notifications.warning(this.intl.t('common.unauthorized-access'));
+            return this.hostRouter.transitionTo('maintenance.maintenances.index');
+        }
+    }
+
+    model({ public_id }) {
+        return this.store.findRecord('maintenance', public_id);
+    }
+}

package/addon/routes/maintenance/maintenances/index/edit.js

@@ -0,0 +1,29 @@
+import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+
+export default class MaintenanceMaintenancesIndexEditRoute extends Route {
+    @service store;
+    @service notifications;
+    @service hostRouter;
+    @service abilities;
+    @service intl;
+
+    @action error(error) {
+        this.notifications.serverError(error);
+        if (typeof error.message === 'string' && error.message.endsWith('not found')) {
+            return this.hostRouter.transitionTo('maintenance.maintenances.index');
+        }
+    }
+
+    beforeModel() {
+        if (this.abilities.cannot('fleet-ops update maintenance')) {
+            this.notifications.warning(this.intl.t('common.unauthorized-access'));
+            return this.hostRouter.transitionTo('maintenance.maintenances.index');
+        }
+    }
+
+    model({ public_id }) {
+        return this.store.findRecord('maintenance', public_id);
+    }
+}

package/addon/routes/maintenance/maintenances/index/new.js

@@ -0,0 +1,3 @@
+import Route from '@ember/routing/route';
+
+export default class MaintenanceMaintenancesIndexNewRoute extends Route {}

package/addon/routes/maintenance/maintenances/index.js

@@ -0,0 +1,23 @@
+import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+
+export default class MaintenanceMaintenancesIndexRoute extends Route {
+    @service store;
+
+    queryParams = {
+        page: { refreshModel: true },
+        limit: { refreshModel: true },
+        sort: { refreshModel: true },
+        query: { refreshModel: true },
+        type: { refreshModel: true },
+        status: { refreshModel: true },
+        priority: { refreshModel: true },
+        public_id: { refreshModel: true },
+        created_at: { refreshModel: true },
+        updated_at: { refreshModel: true },
+    };
+
+    model(params) {
+        return this.store.query('maintenance', { ...params });
+    }
+}

package/addon/routes/maintenance/maintenances.js

@@ -0,0 +1,3 @@
+import Route from '@ember/routing/route';
+
+export default class MaintenanceMaintenancesRoute extends Route {}

package/addon/routes/maintenance/parts/index/details.js

@@ -1,3 +1,29 @@
 import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
 
-export default class MaintenancePartsIndexDetailsRoute extends Route {}
+export default class MaintenancePartsIndexDetailsRoute extends Route {
+    @service store;
+    @service notifications;
+    @service hostRouter;
+    @service abilities;
+    @service intl;
+
+    @action error(error) {
+        this.notifications.serverError(error);
+        if (typeof error.message === 'string' && error.message.endsWith('not found')) {
+            return this.hostRouter.transitionTo('maintenance.parts.index');
+        }
+    }
+
+    beforeModel() {
+        if (this.abilities.cannot('fleet-ops view part')) {
+            this.notifications.warning(this.intl.t('common.unauthorized-access'));
+            return this.hostRouter.transitionTo('maintenance.parts.index');
+        }
+    }
+
+    model({ public_id }) {
+        return this.store.findRecord('part', public_id);
+    }
+}

package/addon/routes/maintenance/parts/index/edit.js

@@ -1,3 +1,29 @@
 import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
 
-export default class MaintenancePartsIndexEditRoute extends Route {}
+export default class MaintenancePartsIndexEditRoute extends Route {
+    @service store;
+    @service notifications;
+    @service hostRouter;
+    @service abilities;
+    @service intl;
+
+    @action error(error) {
+        this.notifications.serverError(error);
+        if (typeof error.message === 'string' && error.message.endsWith('not found')) {
+            return this.hostRouter.transitionTo('maintenance.parts.index');
+        }
+    }
+
+    beforeModel() {
+        if (this.abilities.cannot('fleet-ops update part')) {
+            this.notifications.warning(this.intl.t('common.unauthorized-access'));
+            return this.hostRouter.transitionTo('maintenance.parts.index');
+        }
+    }
+
+    model({ public_id }) {
+        return this.store.findRecord('part', public_id);
+    }
+}

package/addon/routes/maintenance/schedules/index/details/index.js

@@ -0,0 +1,2 @@
+import Route from '@ember/routing/route';
+export default class MaintenanceSchedulesIndexDetailsIndexRoute extends Route {}

package/addon/routes/maintenance/schedules/index/details/work-orders.js

@@ -0,0 +1,11 @@
+import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+
+export default class MaintenanceSchedulesIndexDetailsWorkOrdersRoute extends Route {
+    @service store;
+
+    model() {
+        const schedule = this.modelFor('maintenance.schedules.index.details');
+        return this.store.query('work-order', { schedule_uuid: schedule.id });
+    }
+}