@fleetbase/fleetops-engine 0.6.50 → 0.6.51

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;
@@ -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;
     }