@fleetbase/fleetops-engine 0.6.50 → 0.6.52

package/addon/services/getting-started.js

@@ -0,0 +1,44 @@
+import Service from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { task } from 'ember-concurrency';
+
+export default class GettingStartedService extends Service {
+    @service fetch;
+
+    @tracked data = null;
+    @tracked error = null;
+
+    get isCompleted() {
+        return this.data?.is_completed === true;
+    }
+
+    get steps() {
+        return this.data?.steps ?? [];
+    }
+
+    get recommendations() {
+        return this.data?.recommendations ?? [];
+    }
+
+    get progress() {
+        return this.data?.progress ?? { completed: 0, total: 0, percent: 0 };
+    }
+
+    get nextStepKey() {
+        return this.data?.next_step;
+    }
+
+    get nextStep() {
+        return this.steps.find((step) => step.key === this.nextStepKey) ?? this.steps.find((step) => !step.completed);
+    }
+
+    @task({ drop: true }) *load() {
+        try {
+            this.data = yield this.fetch.get('fleet-ops/getting-started/status');
+            this.error = null;
+        } catch (error) {
+            this.error = error?.message ?? 'Failed to load getting started status';
+        }
+    }
+}

package/addon/services/issue-actions.js

@@ -2,6 +2,7 @@ import ResourceActionService from '@fleetbase/ember-core/services/resource-actio
 import { inject as service } from '@ember/service';
 import { action } from '@ember/object';
 import { format } from 'date-fns';
+import { issueStatuses } from '../utils/fleet-ops-options';
 
 export default class IssueActionsService extends ResourceActionService {
     @service driverActions;
@@ -65,7 +66,7 @@ export default class IssueActionsService extends ResourceActionService {
             return this.modalsManager.show('modals/resource', {
                 resource: issue,
                 title: this.intl.t('common.create-a-new-resource', { resource: this.intl.t('resource.issue')?.toLowerCase() }),
-                acceptButtonText: this.intl.t('common.create-resource', { resource: this.intl.t('resource.Issue') }),
+                acceptButtonText: this.intl.t('common.create-resource', { resource: this.intl.t('resource.issue') }),
                 component: 'issue/form',
                 confirm: (modal) => this.modalTask.perform(modal, 'saveTask', issue, { refresh: true, ...saveOptions }),
                 ...options,
@@ -92,6 +93,76 @@ export default class IssueActionsService extends ResourceActionService {
         },
     };
 
+    get closedStatuses() {
+        return ['closed', 'resolved', 'completed'];
+    }
+
+    openStatusModal(issue, options = {}) {
+        return this.modalsManager.show('modals/issue-status', {
+            issue,
+            statusOptions: issueStatuses,
+            onSaved: options.onSaved,
+        });
+    }
+
+    openAssignModal(issue, options = {}) {
+        return this.modalsManager.show('modals/issue-assign', {
+            issue,
+            onSaved: options.onSaved,
+        });
+    }
+
+    openCloseIssueModal(issue, options = {}) {
+        return this.modalsManager.show('modals/issue-close', {
+            issue,
+            onSaved: options.onSaved,
+        });
+    }
+
+    confirmReopenIssue(issue, options = {}) {
+        this.modalsManager.confirm({
+            title: `Re-open ${issue.public_id || 'issue'}?`,
+            body: 'This will move the issue back into an active re-opened state and clear the active resolution date.',
+            acceptButtonText: 'Re-open Issue',
+            acceptButtonIcon: 'rotate-left',
+            confirm: async (modal) => {
+                modal.startLoading();
+
+                try {
+                    const meta = issue.meta ?? {};
+                    const reopenHistory = Array.isArray(meta.reopen_history) ? meta.reopen_history : [];
+                    const user = this.currentUser.user;
+
+                    issue.status = 're_opened';
+                    issue.resolved_at = null;
+                    issue.meta = {
+                        ...meta,
+                        reopen_history: [
+                            ...reopenHistory,
+                            {
+                                reopened_at: new Date().toISOString(),
+                                reopened_by_uuid: user?.id,
+                                reopened_by_name: user?.name,
+                            },
+                        ],
+                    };
+
+                    await issue.save();
+                    this.notifications.success('Issue re-opened.');
+
+                    if (typeof options.onSaved === 'function') {
+                        await options.onSaved(issue);
+                    }
+
+                    modal.done();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+        });
+    }
+
     @action async viewDriver(issue) {
         const driver = await issue.loadDriver();
         if (driver) {

package/addon/services/leaflet-map-manager.js

@@ -7,6 +7,7 @@ import { renderCompleted, waitForInsertedAndSized } from '@fleetbase/ember-ui/ut
 import { Control as RoutingControl } from '@fleetbase/leaflet-routing-machine';
 import { getLayerById, findLayer, flyToLayer } from '../utils/leaflet';
 import isUuid from '@fleetbase/ember-core/utils/is-uuid';
+import ensureLeafletPluginsReady from '../utils/leaflet-plugin-loader';
 
 export default class LeafletMapManagerService extends Service {
     @service leafletRoutingControl;
@@ -92,6 +93,7 @@ export default class LeafletMapManagerService extends Service {
     }
 
     async ensureInteractive({ timeoutMs = 8000 } = {}) {
+        await ensureLeafletPluginsReady({ timeoutMs });
         await this.whenMapLoaded({ timeoutMs });
 
         // always ask Leaflet for the live container

package/addon/services/map-adapter/leaflet.js

@@ -21,9 +21,16 @@ import { isNone } from '@ember/utils';
 import { next } from '@ember/runloop';
 import { createGeoJsonFromLayer } from '../../utils/leaflet-to-geojson';
 import { waypointIconHtml } from '../../utils/route-colors';
+import ensureLeafletDrawEditNamespace from '../../utils/leaflet-draw-namespace-guard';
+import ensureLeafletPluginsReady from '../../utils/leaflet-plugin-loader';
 
 const L = window.leaflet || window.L;
 
+function ensureLeafletConstructorNamespace() {
+    ensureLeafletDrawEditNamespace(L);
+    ensureLeafletDrawEditNamespace();
+}
+
 export default class LeafletAdapter extends MapAdapterInterface {
     // ─── Internal State ────────────────────────────────────────────────────────
 
@@ -65,6 +72,8 @@ export default class LeafletAdapter extends MapAdapterInterface {
             return this._map;
         }
 
+        ensureLeafletConstructorNamespace();
+
         const mapOptions = {
             center: [options.lat ?? 1.3521, options.lng ?? 103.8198],
             zoom: options.zoom ?? 12,
@@ -113,6 +122,11 @@ export default class LeafletAdapter extends MapAdapterInterface {
         this._map?.invalidateSize(false);
     }
 
+    async ensureInteractive({ timeoutMs = 8000, map = null } = {}) {
+        await ensureLeafletPluginsReady({ timeoutMs });
+        return map ?? this._map;
+    }
+
     // ─── Viewport ──────────────────────────────────────────────────────────────
 
     setCenter(lat, lng, zoom) {
@@ -183,6 +197,7 @@ export default class LeafletAdapter extends MapAdapterInterface {
 
     addMarker(id, lat, lng, options = {}) {
         if (!this._map) return null;
+        ensureLeafletConstructorNamespace();
 
         const iconOptions = options.iconUrl
             ? L.icon({
@@ -258,6 +273,7 @@ export default class LeafletAdapter extends MapAdapterInterface {
 
     addPolygon(id, coordinates, options = {}) {
         if (!this._map) return null;
+        ensureLeafletConstructorNamespace();
         const polygon = L.polygon(coordinates, {
             color: options.color ?? '#3388ff',
             fillColor: options.fillColor ?? options.color ?? '#3388ff',
@@ -276,6 +292,7 @@ export default class LeafletAdapter extends MapAdapterInterface {
 
     addPolyline(id, coordinates, options = {}) {
         if (!this._map) return null;
+        ensureLeafletConstructorNamespace();
         const polyline = L.polyline(coordinates, {
             color: options.color ?? '#3388ff',
             weight: options.weight ?? 3,
@@ -289,6 +306,7 @@ export default class LeafletAdapter extends MapAdapterInterface {
 
     addCircle(id, lat, lng, radiusMeters, options = {}) {
         if (!this._map) return null;
+        ensureLeafletConstructorNamespace();
         const circle = L.circle([lat, lng], {
             radius: radiusMeters,
             color: options.color ?? '#3388ff',
@@ -671,6 +689,7 @@ export default class LeafletAdapter extends MapAdapterInterface {
             return Promise.reject(new Error('LeafletAdapter editPolygon: layer has no coordinates'));
         }
 
+        ensureLeafletConstructorNamespace();
         const proxy = L.polygon(latlngs, {
             color: originalLayer.options?.color || '#3388ff',
             weight: 3,

package/addon/services/service-areas.js

@@ -10,6 +10,7 @@ import MultiPolygon from '@fleetbase/fleetops-data/utils/geojson/multi-polygon';
 import Polygon from '@fleetbase/fleetops-data/utils/geojson/polygon';
 import FeatureCollection from '@fleetbase/fleetops-data/utils/geojson/feature-collection';
 import wrapCoordinates from '../utils/leaflet-wrap-coordinates';
+import ensureLeafletDrawEditNamespace from '../utils/leaflet-draw-namespace-guard';
 
 const L = window.L;
 export default class ServiceAreasService extends Service {
@@ -194,6 +195,8 @@ export default class ServiceAreasService extends Service {
 
         // If you need a Leaflet polygon, you might need to convert back to LatLng arrays.
         // Here we assume Leaflet can work with [lng, lat] arrays, or you convert them as needed.
+        ensureLeafletDrawEditNamespace(L);
+        ensureLeafletDrawEditNamespace();
         const polygon = L.polygon(latLngs, options);
         return polygon;
     }

package/addon/services/telematic-actions.js

@@ -7,9 +7,15 @@ export default class TelematicActionsService extends ResourceActionService {
     }
 
     transition = {
-        view: (telematic) => this.transitionTo('connectivity.telematics.index.details', telematic),
-        edit: (telematic) => this.transitionTo('connectivity.telematics.index.edit', telematic),
-        create: () => this.transitionTo('connectivity.telematics.index.new'),
+        view: (telematic) => this.transitionTo('connectivity.telematics.details', telematic),
+        edit: (telematic) => this.transitionTo('connectivity.telematics.edit', telematic),
+        create: (provider) => {
+            if (provider) {
+                return this.transitionTo('connectivity.telematics.new', { queryParams: { setupProvider: provider } });
+            }
+
+            return this.transitionTo('connectivity.telematics.new');
+        },
     };
 
     panel = {

package/addon/services/vehicle-actions.js

@@ -7,6 +7,7 @@ import { dasherize } from '@ember/string';
 
 export default class VehicleActionsService extends ResourceActionService {
     @service('universe/menu-service') menuService;
+    @service fetch;
     @service maintenanceScheduleActions;
     @service workOrderActions;
     @service maintenanceActions;
@@ -183,6 +184,107 @@ export default class VehicleActionsService extends ResourceActionService {
         this.maintenanceActions.modal.create({ maintainable: vehicle });
     }
 
+    @action attachDevice(vehicle, options = {}) {
+        this.modalsManager.show('modals/attach-device', {
+            title: this.intl.t('vehicle.prompts.attach-device-title', { vehicleName: vehicle.displayName ?? vehicle.name }),
+            acceptButtonText: this.intl.t('vehicle.actions.attach-device'),
+            acceptButtonIcon: 'link',
+            selectedDevice: null,
+            vehicle,
+            confirm: async (modal) => {
+                const selectedDevice = modal.getOption('selectedDevice');
+
+                if (!selectedDevice) {
+                    return this.notifications.warning(this.intl.t('vehicle.prompts.select-device-warning'));
+                }
+
+                modal.startLoading();
+
+                try {
+                    await this.fetch.post(`vehicles/${vehicle.id}/attach-device`, { device: selectedDevice.id });
+                    await vehicle.reload?.();
+                    this.notifications.success(this.intl.t('vehicle.prompts.attach-device-success', { vehicleName: vehicle.displayName ?? vehicle.name }));
+                    modal.done();
+                    this.refresh();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+            ...options,
+        });
+    }
+
+    @action async unassignOrders(vehicle, options = {}) {
+        let response;
+
+        try {
+            response = await this.fetch.get(`vehicles/${vehicle.id}/assigned-orders`);
+        } catch (error) {
+            return this.notifications.serverError(error);
+        }
+
+        const currentOrderId = response.current;
+        const orders = (response.orders ?? response.data ?? []).map((order) => ({
+            ...order,
+            is_current_job: [order.id, order.uuid, order.public_id].includes(currentOrderId),
+        }));
+        const vehicleName = vehicle.displayName ?? vehicle.display_name ?? vehicle.name;
+
+        if (orders.length === 0) {
+            return this.notifications.warning(this.intl.t('vehicle.prompts.no-assigned-orders-warning', { vehicleName }));
+        }
+
+        this.modalsManager.show('modals/assigned-orders', {
+            title: this.intl.t('vehicle.prompts.unassign-orders-title', { vehicleName }),
+            acceptButtonText: this.intl.t('vehicle.actions.unassign-orders'),
+            acceptButtonIcon: 'truck-ramp-box',
+            acceptButtonDisabled: true,
+            subjectLabel: this.intl.t('resource.vehicle'),
+            subjectName: vehicleName,
+            orders,
+            selectedOrderIds: [],
+            toggleOrder: (order) => {
+                const orderId = order.id;
+                const selected = this.modalsManager.getOption('selectedOrderIds') ?? [];
+                const selectedOrderIds = selected.includes(orderId) ? selected.filter((id) => id !== orderId) : [...selected, orderId];
+                this.modalsManager.setOption('selectedOrderIds', selectedOrderIds);
+                this.modalsManager.setOption('acceptButtonDisabled', selectedOrderIds.length === 0);
+            },
+            confirm: async (modal) => {
+                const selectedOrderIds = modal.getOption('selectedOrderIds') ?? [];
+                const selectedOrders = orders.filter((order) => selectedOrderIds.includes(order.id));
+
+                if (selectedOrders.length === 0) {
+                    return this.notifications.warning(this.intl.t('vehicle.prompts.select-orders-warning'));
+                }
+
+                const confirmed = await this.confirmUnassignOrders({
+                    title: this.intl.t('vehicle.prompts.confirm-unassign-orders-title', { count: selectedOrders.length, vehicleName }),
+                    body: this.intl.t('vehicle.prompts.confirm-unassign-orders-body', { vehicleName, orders: this.orderReferenceList(selectedOrders) }),
+                });
+
+                if (!confirmed) {
+                    return;
+                }
+
+                modal.startLoading();
+
+                try {
+                    await this.fetch.post(`vehicles/${vehicle.id}/unassign-orders`, { orders: selectedOrderIds });
+                    await vehicle.reload?.();
+                    this.notifications.success(this.intl.t('vehicle.prompts.unassign-orders-success', { count: selectedOrders.length, vehicleName }));
+                    modal.done();
+                    this.refresh();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+            ...options,
+        });
+    }
+
     @action locate(vehicle, options = {}) {
         const { latitude, longitude, location } = vehicle;
 
@@ -203,4 +305,27 @@ export default class VehicleActionsService extends ResourceActionService {
             ...options,
         });
     }
+
+    orderReferenceList(orders) {
+        const references = orders.map((order) => order.tracking ?? order.public_id ?? order.id).filter(Boolean);
+
+        return references.length > 5 ? `${references.slice(0, 5).join(', ')} +${references.length - 5}` : references.join(', ');
+    }
+
+    async confirmUnassignOrders({ title, body }) {
+        return new Promise((resolve) => {
+            this.modalsManager.confirm({
+                title,
+                body,
+                confirm: (_modal, done) => {
+                    done();
+                    resolve(true);
+                },
+                decline: (_modal, done) => {
+                    done();
+                    resolve(false);
+                },
+            });
+        });
+    }
 }