@fleetbase/fleetops-engine 0.6.18 → 0.6.20

package/addon/services/order-import.js

@@ -0,0 +1,149 @@
+import Service, { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { action } from '@ember/object';
+import { isArray } from '@ember/array';
+import { debug } from '@ember/debug';
+import { task } from 'ember-concurrency';
+
+export default class OrderImportService extends Service {
+    @service fetch;
+    @service modalsManager;
+    @service notifications;
+    @service currentUser;
+    @tracked queuedFiles = [];
+    @tracked uploadedFiles = [];
+
+    @action promptImport(order, options = {}) {
+        return this.modalsManager.show('modals/order-import', {
+            title: 'Import order(s) with spreadsheets',
+            acceptButtonText: 'Start Upload',
+            acceptButtonScheme: 'magic',
+            acceptButtonIcon: 'upload',
+            acceptButtonDisabled: true,
+            isProcessing: false,
+            fileQueueColumns: [
+                { name: 'Type', valuePath: 'extension', key: 'type' },
+                { name: 'File Name', valuePath: 'name', key: 'fileName' },
+                { name: 'File Size', valuePath: 'size', key: 'fileSize' },
+                { name: 'Upload Date', valuePath: 'file.lastModifiedDate', key: 'uploadDate' },
+                { name: '', valuePath: '', key: 'delete' },
+            ],
+            acceptedFileTypes: ['application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', 'text/csv'],
+            uploadQueue: this.queuedFiles,
+            queueFile: this.#addFileToQueue,
+            removeFile: this.#removeFileFromQueue,
+            confirm: async (modal) => {
+                if (!this.#importValid()) return this.notifications.warning(this.intl.t('fleet-ops.operations.orders.index.new.warning-message'));
+
+                modal.startLoading();
+                modal.setOption('acceptButtonText', 'Uploading...');
+
+                const uploadedFiles = await this.queuedFiles.perform();
+
+                this.modalsManager.setOption('acceptButtonText', 'Processing...');
+                this.modalsManager.setOption('isProcessing', true);
+
+                const results = await this.importFiles.perform(uploadedFiles);
+                const { places, entities } = results;
+
+                if (isArray(places)) {
+                    order.payload.set(
+                        'waypoints',
+                        places.map((p) => {
+                            const place = this.store.createRecord('place', p);
+                            return this.store.createRecord('waypoint', { place });
+                        })
+                    );
+                }
+
+                if (isArray(entities)) {
+                    order.payload.set(
+                        'entities',
+                        entities.map((entity) => this.store.createRecord('entity', entity))
+                    );
+                }
+
+                this.notifications.success(this.intl.t('fleet-ops.operations.orders.index.new.import-success'));
+
+                modal.done();
+            },
+            decline: (modal) => {
+                this.#reset();
+                modal.done();
+            },
+            ...options,
+        });
+    }
+
+    @task *importFiles(files = []) {
+        const ids = files.map((file) => file.id);
+
+        try {
+            const results = yield this.fetch.post('orders/process-imports', { files: ids });
+            return results;
+        } catch (err) {
+            debug('Error processing file imports: ' + err.message);
+            this.notifications.serverError(err);
+        }
+    }
+
+    @task *uploadQueue() {
+        const uploaded = [];
+
+        try {
+            for (let i = 0; i < this.queuedFiles.length; i++) {
+                const file = this.queuedFiles[i];
+                if (!file) continue;
+
+                const uploadedFile = yield this.uploadFile(file);
+                uploaded.push(uploadedFile);
+            }
+
+            return uploaded;
+        } catch (err) {
+            debug('Error uploading import queue: ' + err.message);
+        }
+    }
+
+    @task *uploadFile(file) {
+        try {
+            const uploadedFile = yield this.fetch.uploadFile.perform(file, {
+                path: `uploads/fleet-ops/order-imports/${this.currentUser.companyId}`,
+                type: `order_import`,
+            });
+
+            this.uploadedFiles.pushObject(uploadedFile);
+            return uploadedFile;
+        } catch (err) {
+            debug('Error uploading order import source: ' + err.message);
+        }
+    }
+
+    #reset() {
+        this.queuedFiles = [];
+        this.uploadedFiles = [];
+    }
+
+    #importValid() {
+        return this.queuedFiles.length > 0;
+    }
+
+    #checkqueuedFiles() {
+        if (this.queuedFiles.length) {
+            this.modalsManager.setOption('acceptButtonDisabled', false);
+        } else {
+            this.modalsManager.setOption('acceptButtonDisabled', true);
+        }
+    }
+
+    #addFileToQueue(file) {
+        this.queuedFiles.pushObject(file);
+        this.#checkqueuedFiles();
+    }
+
+    #removeFileFromQueue(file) {
+        file.queue?.remove(file);
+        this.queuedFiles.removeObject(file);
+        this.#checkqueuedFiles();
+    }
+}

package/addon/services/order-list-overlay.js

@@ -0,0 +1,206 @@
+import Service, { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { action } from '@ember/object';
+import { debug } from '@ember/debug';
+import { task, timeout } from 'ember-concurrency';
+
+export default class OrderListOverlayService extends Service {
+    @service store;
+    @service fetch;
+    @service appCache;
+    @tracked overlay = null;
+    @tracked isOpen = false;
+    @tracked width = 400;
+    @tracked fleets = [];
+    @tracked selectedOrders = [];
+    @tracked activeOrders = [];
+    @tracked unassignedOrders = [];
+    @tracked searchQuery = '';
+    @tracked loaded = false;
+
+    constructor() {
+        super(...arguments);
+        // Initialize from cache only once (avoids service access during field init)
+        this.isOpen = this.appCache.get('fleetops:component:map:order-list:open', false);
+    }
+
+    get orderGroups() {
+        return {
+            activeOrders: this.activeOrders,
+            unassignedOrders: this.unassignedOrders,
+        };
+    }
+
+    get hasSelection() {
+        return this.selectedOrders.length > 0;
+    }
+
+    get activeOrdersCount() {
+        return this.activeOrders.length;
+    }
+
+    @action handleLoad(overlay) {
+        this.setOverlay(overlay);
+        this.load.perform();
+    }
+
+    @action open() {
+        this.setOpen(true);
+    }
+
+    @action close() {
+        this.setOpen(false);
+    }
+
+    @action toggle() {
+        this.setOpen(!this.isOpen);
+    }
+
+    @action toggleSelectOrder(order) {
+        if (!order) return;
+
+        const id = order.public_id ?? order.id;
+        const index = this.selectedOrders.findIndex((o) => (o.public_id ?? o.id) === id);
+
+        if (index === -1) {
+            this.selectedOrders = [...this.selectedOrders, order];
+        } else {
+            this.selectedOrders = [...this.selectedOrders.slice(0, index), ...this.selectedOrders.slice(index + 1)];
+        }
+    }
+
+    @action clearSelection() {
+        if (this.selectedOrders.length === 0) return;
+        this.selectedOrders = [];
+    }
+
+    @action setSearch(query) {
+        this.searchTask.perform(query ?? '');
+    }
+
+    @task *load() {
+        const loadedOrders = this.store.peekAll('order');
+        const excludeIds = loadedOrders.map((o) => o.public_id);
+
+        try {
+            // Run requests in sequence for clarity; convert to Promise.all if backend allows
+            yield this.loadFleets(excludeIds);
+            yield this.loadUnassignedOrders(excludeIds);
+            yield this.loadActiveOrders(excludeIds);
+            this.loaded = true;
+        } catch (err) {
+            debug(`OrderListOverlayService.load: ${err?.message ?? err}`);
+        }
+    }
+
+    @task *searchTask(query) {
+        yield timeout(300);
+        this.searchQuery = String(query ?? '').trim();
+    }
+
+    async loadFleets(excludeOrderIds) {
+        try {
+            const fleets = await this.store.query('fleet', {
+                // Keep param naming as-is to avoid breaking API expectations
+                excludeDriver: excludeOrderIds,
+                with: ['serviceArea', 'drivers.jobs', 'drivers.currentJob'],
+                without: ['drivers.fleets'],
+            });
+
+            // For each driver, expose a consolidated list of active jobs the panel cares about
+            const mapped = fleets.map((fleet) => {
+                fleet.drivers = fleet.drivers.map((driver) => {
+                    driver.set('_panelActiveJobs', [...driver.activeJobs, ...this.#peekDriverActiveOrders(driver)]);
+                    return driver;
+                });
+                return fleet;
+            });
+
+            this.fleets = mapped;
+        } catch (err) {
+            debug(`OrderListOverlayService.#loadFleets: ${err?.message ?? err}`);
+        }
+    }
+
+    async loadUnassignedOrders(excludeOrderIds) {
+        try {
+            const unassigned = await this.fetch.get(
+                'fleet-ops/live/orders',
+                {
+                    unassigned: 1,
+                    exclude: excludeOrderIds,
+                },
+                {
+                    normalizeToEmberData: true,
+                    normalizeModelType: 'order',
+                    expirationInterval: 5,
+                    expirationIntervalUnit: 'minute',
+                }
+            );
+
+            this.unassignedOrders = [...unassigned, ...this.#peekUnassignedOrders()];
+        } catch (err) {
+            debug(`OrderListOverlayService.#loadUnassignedOrders: ${err?.message ?? err}`);
+        }
+    }
+
+    async loadActiveOrders(excludeOrderIds) {
+        try {
+            const active = await this.fetch.get(
+                'fleet-ops/live/orders',
+                {
+                    active: 1,
+                    with_tracker_data: 1,
+                    exclude: excludeOrderIds,
+                },
+                {
+                    normalizeToEmberData: true,
+                    normalizeModelType: 'order',
+                    expirationInterval: 5,
+                    expirationIntervalUnit: 'minute',
+                }
+            );
+
+            this.activeOrders = [...active, ...this.#peekActiveOrders()];
+
+            // If needed later: lazily ensure tracker data exists
+            // for (const order of this.activeOrders) {
+            //   if (!order.tracker_data && typeof order.loadTrackerData === 'function') {
+            //     yield order.loadTrackerData();
+            //   }
+            // }
+        } catch (err) {
+            debug(`OrderListOverlayService.#loadActiveOrders: ${err?.message ?? err}`);
+        }
+    }
+
+    #peekOrders(filterFn) {
+        const records = this.store.peekAll('order');
+        const predicate = typeof filterFn === 'function' ? filterFn : () => true;
+        return records.filter(predicate);
+    }
+
+    #peekUnassignedOrders() {
+        return this.#peekOrders((order) => !order.driver_assigned_uuid);
+    }
+
+    #peekActiveOrders() {
+        // Consider an order "active" if it has an assigned driver and is not terminal
+        const TERMINAL = ['created', 'completed', 'canceled', 'expired'];
+        return this.#peekOrders((order) => !!order.driver_assigned && !TERMINAL.includes(order.status));
+    }
+
+    #peekDriverActiveOrders(driver) {
+        const TERMINAL = ['created', 'completed', 'canceled', 'expired'];
+        return this.#peekOrders((order) => !!order.driver_assigned && order.driver_assigned?.id === driver.id && !TERMINAL.includes(order.status));
+    }
+
+    setOverlay(overlay) {
+        this.overlay = overlay;
+    }
+
+    setOpen(wantsOpen) {
+        this.isOpen = !!wantsOpen;
+        this.appCache.set('fleetops:component:map:order-list:open', this.isOpen);
+    }
+}

package/addon/services/order-socket-events.js

@@ -0,0 +1,296 @@
+import Service, { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { debug } from '@ember/debug';
+
+/**
+ * SocketCluster-driven order event stream manager.
+ *
+ * Usage:
+ *  const { stop } = this.orderSocketEvents.start(this.model, async (msg, { reloadable }) => {
+ *    if (reloadable) await this.hostRouter.refresh();
+ *  }, { debounceMs: 300 });
+ *
+ *  // later: stop()
+ */
+export default class OrderSocketEventsService extends Service {
+    @service socket;
+    @service currentUser;
+    @service hostRouter;
+    @tracked subs = new Map(); // channelId -> { channel, order, onEvent, debounceMs, isActive, pumpPromise, debouncer }
+    @tracked _company = null;
+    reloadableEvents = new Set(['order.created', 'order.completed', 'waypoint.activity', 'entity.activity']);
+
+    start(order, onEvent, { debounceMs = 0 } = {}) {
+        if (!order?.public_id) {
+            throw new Error('order-socket-events.start: order.public_id is required');
+        }
+        const channelId = `order.${order.public_id}`;
+
+        // Idempotent: reuse if already running
+        let sub = this.subs.get(channelId);
+        if (sub?.isActive) return this._handle(channelId);
+
+        const sc = this.socket.instance(); // SocketCluster client
+        const channel = sc.subscribe(channelId); // returns a Channel
+
+        sub = {
+            channel,
+            order,
+            onEvent,
+            debounceMs,
+            isActive: true,
+            pumpPromise: null,
+            debouncer: null,
+            connectConsumer: sc.listener('connect').createConsumer(),
+        };
+        this.subs.set(channelId, sub);
+
+        // ensure we are subscribed before consuming
+        sub.pumpPromise = this.#ensureSubscribedThenPump(channelId).catch((e) => {
+            debug(`SC pump error [${channelId}]: ${e?.message ?? e}`);
+        });
+
+        // reconnect watcher using the consumer
+        this.#watchReconnect(channelId).catch((e) => {
+            debug(`SC reconnect watcher error [${channelId}]: ${e?.message ?? e}`);
+        });
+
+        return this._handle(channelId);
+    }
+
+    _handle(channelId) {
+        return { stop: () => this.stop(channelId) };
+    }
+
+    /* eslint-disable no-empty */
+    async stop(key) {
+        const channelId = typeof key === 'string' ? key : `order.${key?.public_id}`;
+        const sub = this.subs.get(channelId);
+        if (!sub) return;
+
+        sub.isActive = false;
+
+        try {
+            await sub.channel.unsubscribe(); // ends the channel async iterator
+        } catch (e) {
+            debug(`SC unsubscribe failed [${channelId}]: ${e?.message ?? e}`);
+        }
+
+        try {
+            sub.connectConsumer?.close(); // ✅ stop the connect listener stream
+        } catch (_) {}
+
+        if (sub.debouncer) {
+            clearTimeout(sub.debouncer);
+            sub.debouncer = null;
+        }
+
+        this.subs.delete(channelId);
+    }
+
+    stopAll() {
+        for (const id of Array.from(this.subs.keys())) {
+            // fire-and-forget; each stop awaits its own unsubscribe
+            this.stop(id);
+        }
+    }
+
+    /* eslint-disable no-unused-vars */
+    async #watchReconnect(channelId) {
+        const sub = this.subs.get(channelId);
+        if (!sub?.isActive) return;
+
+        // Consume 'connect' events until closed
+        for await (const _evt of sub.connectConsumer) {
+            const current = this.subs.get(channelId);
+            if (!current?.isActive) break;
+
+            // SC usually auto-resubscribes; we just ensure state
+            if (current.channel.state !== 'subscribed') {
+                try {
+                    await current.channel.subscribe();
+                } catch (e) {
+                    debug(`SC resubscribe failed [${channelId}]: ${e?.message ?? e}`);
+                }
+            }
+        }
+    }
+
+    async #ensureSubscribedThenPump(channelId) {
+        const sub = this.subs.get(channelId);
+        if (!sub?.isActive) return;
+
+        const { channel, order, onEvent, debounceMs } = sub;
+
+        if (channel.state !== 'subscribed') {
+            await channel.subscribe(); // throws if ackTimeout/auth error
+        }
+
+        for await (const output of channel) {
+            const current = this.subs.get(channelId);
+            if (!current?.isActive) break;
+
+            const reloadable = this.#isReloadableEvent(output, order);
+            debug(`SC Event [${channelId}] ${output?.event} : ${JSON.stringify(output)}`);
+
+            if (typeof onEvent === 'function') {
+                if (reloadable && debounceMs > 0) {
+                    if (current.debouncer) clearTimeout(current.debouncer);
+                    current.debouncer = setTimeout(() => {
+                        if (this.subs.get(channelId)?.isActive) {
+                            onEvent(output, { order, reloadable });
+                        }
+                        current.debouncer = null;
+                    }, debounceMs);
+                } else {
+                    await onEvent(output, { order, reloadable });
+                }
+            }
+        }
+    }
+
+    #isReloadableEvent(output, order) {
+        const event = output?.event;
+        const data = output?.data;
+        if (!event) return false;
+
+        if (event === 'order.updated' && data && order && data.status !== order.status) {
+            return true;
+        }
+        return this.reloadableEvents.has(event);
+    }
+
+    async startCompany() {
+        // Already running? no-op
+        if (this._company?.isActive) return this._companyHandle();
+
+        // Ensure we have a company id
+        const companyId = await this.#ensureCompanyId();
+        if (!companyId) {
+            debug('[order-socket-events] No companyId; aborting company subscribe.');
+            return this._companyHandle(); // no-op handle
+        }
+
+        // Subscribe
+        const sc = this.socket.instance();
+        const channelId = `company.${companyId}`;
+        const channel = sc.subscribe(channelId);
+
+        // Auto-unsubscribe on route change
+        const onRoute = () => this.stopCompany();
+        this.hostRouter.on('routeWillChange', onRoute);
+
+        this._company = {
+            channel,
+            isActive: true,
+            routeOff: () => this.hostRouter.off('routeWillChange', onRoute),
+        };
+
+        // Consume messages
+        (async () => {
+            try {
+                if (channel.state !== 'subscribed') {
+                    await channel.subscribe();
+                }
+
+                for await (const msg of channel) {
+                    const sub = this._company;
+                    if (!sub?.isActive) break;
+
+                    const { event, data } = msg || {};
+                    debug(`[order-socket-events] company event "${event}" :: ${JSON.stringify(data)}`);
+
+                    switch (event) {
+                        case 'order.driver_assigned': {
+                            // data: { id: <order_public_id>, driver_assigned: <driver_public_id> }
+                            const order = await this.#findOrderByPublicId(data?.id);
+                            const driver = await this.#findDriverByPublicId(data?.driver_assigned);
+
+                            if (order && driver) {
+                                // adjust key if your relationship is named differently (e.g. 'driverAssigned')
+                                order.set?.('driver_assigned', driver);
+                            }
+                            break;
+                        }
+
+                        // add more company-wide events here:
+                        // case 'order.updated': ...
+                        // case 'order.completed': ...
+                    }
+                }
+            } catch (e) {
+                debug(`[order-socket-events] company channel loop error: ${e?.message ?? e}`);
+            }
+        })();
+
+        return this._companyHandle();
+    }
+
+    /** Stop the company-level listener */
+    /* eslint-disable no-empty */
+    async stopCompany() {
+        const sub = this._company;
+        if (!sub) return;
+
+        sub.isActive = false;
+        try {
+            await sub.channel?.unsubscribe?.();
+            await sub.channel?.close?.();
+        } catch (e) {
+            debug(`[order-socket-events] company unsubscribe error: ${e?.message ?? e}`);
+        }
+
+        try {
+            sub.routeOff?.();
+        } catch {}
+        this._company = null;
+    }
+
+    /** tiny handle for symmetry with your per-order API */
+    _companyHandle() {
+        return { stop: () => this.stopCompany() };
+    }
+
+    async #ensureCompanyId() {
+        if (this.currentUser?.companyId) return this.currentUser.companyId;
+
+        // wait once for user.loaded
+        await new Promise((resolve) => {
+            const handler = () => {
+                this.currentUser.off?.('user.loaded', handler);
+                resolve();
+            };
+            this.currentUser.on?.('user.loaded', handler);
+        });
+
+        return this.currentUser?.companyId;
+    }
+
+    async #findOrderByPublicId(publicId) {
+        if (!publicId) return null;
+
+        const hit = this.store.peekAll('order').findBy('public_id', publicId);
+        if (hit) return hit;
+
+        try {
+            return await this.store.queryRecord('order', { public_id: publicId, single: true });
+        } catch (e) {
+            debug(`[order-socket-events] queryRecord order:${publicId} failed -> ${e?.message}`);
+            return null;
+        }
+    }
+
+    async #findDriverByPublicId(publicId) {
+        if (!publicId) return null;
+
+        const hit = this.store.peekAll('driver').findBy('public_id', publicId);
+        if (hit) return hit;
+
+        try {
+            return await this.store.queryRecord('driver', { public_id: publicId, single: true });
+        } catch (e) {
+            debug(`[order-socket-events] queryRecord driver:${publicId} failed -> ${e?.message}`);
+            return null;
+        }
+    }
+}

package/addon/services/order-validation.js

@@ -0,0 +1,51 @@
+import Service, { inject as service } from '@ember/service';
+import isNotEmpty from '@fleetbase/ember-core/utils/is-not-empty';
+
+export default class OrderValidationService extends Service {
+    @service orderCreation;
+
+    get isValid() {
+        const order = this.orderCreation?.context?.order;
+        const cfManager = this.orderCreation?.context?.cfManager;
+        return this.validate(order, cfManager);
+    }
+
+    get isNotValid() {
+        return !this.isValid;
+    }
+
+    validate(order, cfManager = null) {
+        if (!order) return false;
+
+        cfManager = cfManager ?? order?.cfManager ?? this.orderCreation.getContext('cfManager');
+        const hasOrderConfig = isNotEmpty(order.order_config_uuid);
+        const hasOrderType = isNotEmpty(order.type);
+        const hasWaypoints = order.payload.waypoints.length >= 2;
+        const hasPickup = isNotEmpty(order.payload.pickup);
+        const hasDropoff = isNotEmpty(order.payload.dropoff);
+        const hasValidCustomFields = cfManager ? this.isCustomFieldsValid(cfManager) : true;
+
+        if (hasWaypoints) {
+            return hasOrderConfig && hasOrderType && hasValidCustomFields;
+        }
+
+        return hasPickup && hasDropoff && hasOrderConfig && hasOrderType && hasValidCustomFields;
+    }
+
+    validationFails(order, cfManager) {
+        return !this.validate(order, cfManager);
+    }
+
+    validateCustomFields(cfManager) {
+        if (!cfManager) return true;
+
+        return cfManager.validateRequired();
+    }
+
+    isCustomFieldsValid(cfManager) {
+        if (!cfManager) return true;
+
+        const { isValid } = this.validateCustomFields(cfManager);
+        return isValid;
+    }
+}