@fleetbase/fleetops-engine 0.6.49 → 0.6.50

package/addon/services/geofence.js

@@ -9,6 +9,7 @@ import Service, { inject as service } from '@ember/service';
 import { action } from '@ember/object';
 import { debug } from '@ember/debug';
 import { dasherize } from '@ember/string';
+import { later } from '@ember/runloop';
 import toMultiPolygon from '../utils/to-multi-polygon';
 
 export default class GeofenceService extends Service {
@@ -173,9 +174,11 @@ export default class GeofenceService extends Service {
                 },
                 {
                     callback: (serviceArea) => {
-                        this.#resetDraftSession({ hideControl: true, removeDraft: true });
-                        this.#showServiceArea(serviceArea);
+                        this.#finishDraftSave((draftLayer) => {
+                            this.#reloadThenFocusServiceArea(serviceArea, { draftLayer });
+                        });
                     },
+                    refresh: false,
                 }
             );
             return;
@@ -184,7 +187,7 @@ export default class GeofenceService extends Service {
         if (this._draftSession.mode === 'zone') {
             const serviceArea = this._draftSession.serviceArea;
             this.zoneActions.modal.create(
-                { border: geoJson, service_area_uuid: serviceArea.id },
+                { border: geoJson, service_area: serviceArea },
                 {
                     decline: (modal) => {
                         this.#resetDraftSession({ hideControl: true, removeDraft: true });
@@ -193,10 +196,11 @@ export default class GeofenceService extends Service {
                 },
                 {
                     callback: (zone) => {
-                        serviceArea?.zones?.pushObject?.(zone);
-                        this.#resetDraftSession({ hideControl: true, removeDraft: true });
-                        this.#showZone(zone);
+                        this.#finishDraftSave((draftLayer) => {
+                            this.#reloadThenFocusZone(serviceArea, zone, { draftLayer });
+                        });
                     },
+                    refresh: false,
                 }
             );
             return;
@@ -246,19 +250,19 @@ export default class GeofenceService extends Service {
                 } else {
                     record.setProperties({
                         border: geoJson,
-                        service_area_uuid: selectedServiceArea.id,
-                        serviceArea: selectedServiceArea,
+                        service_area: selectedServiceArea,
                     });
                 }
 
                 return record.save().then((savedRecord) => {
-                    this.#resetDraftSession({ hideControl: true, removeDraft: true });
-
                     if (selectedLayerType === 'Service Area') {
-                        this.#showServiceArea(savedRecord);
+                        this.#finishDraftSave((draftLayer) => {
+                            this.#reloadThenFocusServiceArea(savedRecord, { draftLayer });
+                        });
                     } else {
-                        selectedServiceArea?.zones?.pushObject?.(savedRecord);
-                        this.#showZone(savedRecord);
+                        this.#finishDraftSave((draftLayer) => {
+                            this.#reloadThenFocusZone(selectedServiceArea, savedRecord, { draftLayer });
+                        });
                     }
 
                     return savedRecord;
@@ -289,28 +293,168 @@ export default class GeofenceService extends Service {
         this._draftSession = null;
     }
 
+    #finishDraftSave(callback) {
+        const draftLayer = this._draftSession?.draftLayer ?? null;
+        callback?.(draftLayer);
+        this.#resetDraftSession({ hideControl: true, removeDraft: false });
+    }
+
     async #editPolygonLayer(originalLayer, { focusBounds = null } = {}) {
         return this.mapManager.editPolygon(originalLayer, { focusBounds });
     }
 
     #showZone(zone, { pin = false } = {}) {
-        const layer = this.mapManager.getOverlay(zone.id) ?? zone?.leafletLayer ?? null;
+        const overlay = this.mapManager.getOverlay(zone.id);
+        const layer = overlay ?? zone?.leafletLayer ?? null;
         this.#setLayerPinned(layer, pin);
-        this.mapManager.showPolygon(zone.id);
+        if (overlay) {
+            this.mapManager.showPolygon(zone.id);
+        } else if (layer) {
+            this.mapManager.showLayer?.(layer);
+        }
+    }
+
+    #includeServiceArea(serviceArea) {
+        if (!serviceArea?.id) return;
+
+        const currentServiceAreas = this.serviceAreaActions.serviceAreas;
+        if (!currentServiceAreas) {
+            this.serviceAreaActions.serviceAreas = [serviceArea];
+            return;
+        }
+
+        const serviceAreas = Array.from(currentServiceAreas);
+        const exists = serviceAreas.some((existingServiceArea) => existingServiceArea?.id === serviceArea.id);
+        if (exists) return;
+
+        this.serviceAreaActions.serviceAreas = [...serviceAreas, serviceArea];
+    }
+
+    #includeZone(serviceArea, zone) {
+        if (!serviceArea?.id || !zone?.id) return;
+
+        const zones = serviceArea.zones;
+        if (!zones) {
+            serviceArea.set?.('zones', [zone]);
+            this.serviceAreaActions.serviceAreas = Array.from(this.serviceAreaActions.serviceAreas ?? []);
+            return;
+        }
+
+        const exists = Array.from(zones).some((existingZone) => existingZone?.id === zone.id);
+        if (exists) return;
+
+        if (typeof zones.pushObject === 'function') {
+            zones.pushObject(zone);
+        } else if (typeof zones.addObject === 'function') {
+            zones.addObject(zone);
+        } else if (typeof zones.push === 'function') {
+            zones.push(zone);
+        }
+
+        this.serviceAreaActions.serviceAreas = Array.from(this.serviceAreaActions.serviceAreas ?? []);
+    }
+
+    #reloadThenFocusServiceArea(serviceArea, options = {}) {
+        this.#reloadServiceAreas()
+            .then((serviceAreas) => {
+                const canonicalServiceArea = this.#findResource(serviceAreas, serviceArea) ?? serviceArea;
+                this.#focusServiceAreaAfterCreate(canonicalServiceArea, options);
+            })
+            .catch(() => {
+                this.#includeServiceArea(serviceArea);
+                this.#focusServiceAreaAfterCreate(serviceArea, options);
+            });
+    }
+
+    #reloadThenFocusZone(serviceArea, zone, options = {}) {
+        this.#reloadServiceAreas()
+            .then((serviceAreas) => {
+                const canonicalServiceArea = this.#findResource(serviceAreas, serviceArea) ?? serviceArea;
+                const canonicalZone = this.#findResource(canonicalServiceArea?.zones, zone) ?? zone;
+                this.#focusZoneAfterCreate(canonicalZone, options);
+            })
+            .catch(() => {
+                this.#includeZone(serviceArea, zone);
+                this.#focusZoneAfterCreate(zone, options);
+            });
+    }
+
+    #reloadServiceAreas() {
+        return Promise.resolve(this.serviceAreaActions.loadAll.perform()).then(() => this.serviceAreaActions.serviceAreas ?? []);
+    }
+
+    #findResource(resources, resource) {
+        if (!resource || !resources) return null;
+
+        const resourceId = resource.id ?? resource.public_id;
+        const publicId = resource.public_id ?? resource.id;
+
+        return (
+            Array.from(resources).find((candidate) => {
+                return candidate?.id === resourceId || candidate?.id === publicId || candidate?.public_id === publicId || candidate?.public_id === resourceId;
+            }) ?? null
+        );
+    }
+
+    #focusServiceAreaAfterCreate(serviceArea, options = {}) {
+        this.#focusWhenReady([serviceArea], () => this.focusServiceArea(serviceArea), options);
+    }
+
+    #focusZoneAfterCreate(zone, options = {}) {
+        this.#focusWhenReady([zone], () => this.focusZone(zone), options);
+    }
+
+    #focusWhenReady(models, focus, { attempts = 60, delay = 100, draftLayer = null } = {}) {
+        const overlays = models
+            .map((model) => {
+                const overlay = this.mapManager.getOverlay(model?.id);
+                if (overlay) {
+                    return overlay;
+                }
+
+                return model?.leafletLayer === draftLayer ? null : model?.leafletLayer;
+            })
+            .filter(Boolean);
+        const allRegistered = overlays.length === models.length;
+
+        if (allRegistered || attempts <= 0) {
+            focus();
+            if (draftLayer && !draftLayer.__removedAfterCreate && !overlays.includes(draftLayer)) {
+                draftLayer.__removedAfterCreate = true;
+                this.mapManager.removeLayer(draftLayer);
+            }
+            return;
+        }
+
+        later(this, () => this.#focusWhenReady(models, focus, { attempts: attempts - 1, delay, draftLayer }), delay);
     }
 
     #showServiceArea(serviceArea, { pin = false } = {}) {
         [serviceArea, ...(serviceArea.zones ?? [])].forEach((model) => {
-            const layer = this.mapManager.getOverlay(model.id) ?? model?.leafletLayer ?? null;
+            const overlay = this.mapManager.getOverlay(model.id);
+            const layer = overlay ?? model?.leafletLayer ?? null;
             this.#setLayerPinned(layer, pin);
-            this.mapManager.showPolygon(model.id);
+            if (overlay) {
+                this.mapManager.showPolygon(model.id);
+            } else if (layer) {
+                this.mapManager.showLayer?.(layer);
+            }
         });
     }
 
     #hideServiceArea(serviceArea) {
         [serviceArea, ...(serviceArea.zones ?? [])].forEach((model) => {
-            this.#setLayerPinned(model?.leafletLayer ?? this.mapManager.getOverlay(model.id), false);
-            this.mapManager.hidePolygon(model.id);
+            const overlay = this.mapManager.getOverlay(model.id);
+            const layer = model?.leafletLayer;
+
+            this.#setLayerPinned(layer ?? overlay, false);
+            if (overlay) {
+                this.mapManager.hidePolygon(model.id);
+            }
+
+            if (layer && layer !== overlay) {
+                this.mapManager.hideLayer?.(layer);
+            }
         });
     }
 

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

@@ -85,6 +85,33 @@ export default class LeafletContextmenuManagerService extends Service {
         return null;
     }
 
+    /**
+     * Remove a registered context menu and detach it from its layer when possible.
+     *
+     * @param {string} registryName - The public context menu registry name.
+     * @returns {Object|null} The removed registry, or null when none existed.
+     */
+    removeContextMenu(registryName) {
+        const internalRegistryName = this.createInternalRegistryName(registryName);
+        const registry = this.contextMenuRegistry[internalRegistryName];
+
+        if (!registry) {
+            return null;
+        }
+
+        try {
+            registry.contextmenuApi?.removeAllItems?.();
+            registry.layer?.unbindContextMenu?.();
+        } catch (error) {
+            // Context menus are disposable UI state; stale layer cleanup should not block record deletion.
+        }
+
+        delete this.contextMenuRegistry[internalRegistryName];
+        this.contextMenuRegistry = { ...this.contextMenuRegistry };
+
+        return registry;
+    }
+
     /**
      * Creates an internal registry name by camelizing the provided registry name and appending "ConextmenuRegistry" to it.
      *

package/addon/services/vehicle-actions.js

@@ -62,7 +62,7 @@ export default class VehicleActionsService extends ResourceActionService {
 
     constructor() {
         super(...arguments);
-        this.initialize('vehicle', { status: 'active' });
+        this.initialize('vehicle', { status: 'available' });
     }
 
     transition = {

package/addon/styles/fleetops-engine.css

@@ -345,6 +345,51 @@ body.fleetbase-console .next-content-overlay > .next-content-overlay-panel-conta
     gap: 0.5rem;
 }
 
+.fleetops-order-form-waypoint {
+    position: relative;
+}
+
+.fleetops-order-form-waypoint--required {
+    border-color: #f97316 !important;
+    padding-top: 1.25rem;
+    box-shadow:
+        0 1px 3px 0 rgb(249 115 22 / 15%),
+        0 0 0 1px rgb(249 115 22 / 10%);
+}
+
+.fleetops-order-form-waypoint__required-tab {
+    position: absolute;
+    top: -1px;
+    right: -1px;
+    border-top-right-radius: 0.375rem;
+    border-bottom-left-radius: 0.375rem;
+    background-color: #f97316;
+    color: #fff7ed;
+    padding: 0.15rem 0.5rem;
+    font-size: 0.62rem;
+    font-weight: 700;
+    line-height: 1.2;
+    text-transform: uppercase;
+    letter-spacing: 0.02em;
+}
+
+.fleetops-order-form-waypoint__marker {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 0.6rem;
+    min-width: 3.25rem;
+    padding-top: 0.15rem;
+}
+
+.fleetops-order-form-waypoint__badge {
+    min-width: 1.65rem;
+    width: 1.65rem;
+    height: 1.65rem;
+    font-size: 0.75rem;
+    flex-shrink: 0;
+}
+
 .fleetops-route-editor-empty-state {
     border: 1px dashed rgb(75 85 99 / 75%);
     border-radius: 0.5rem;
@@ -464,7 +509,52 @@ body[data-theme='light'] .flow-activity-status-pill text {
 .activity-flow-graph-container {
     position: relative;
     width: 100%;
-    height: 100%;
+    height: calc(100vh - 16rem);
+    min-height: 24rem;
+    overflow: auto hidden;
+    scrollbar-width: none;
+}
+
+.activity-flow-graph-container > .joint-js-paper {
+    min-width: 100%;
+    max-width: none;
+    overflow: visible;
+}
+
+.activity-flow-graph-container::-webkit-scrollbar {
+    display: none;
+}
+
+.activity-flow-horizontal-scrollbar {
+    position: fixed;
+    bottom: 0;
+    z-index: 100;
+    height: 12px;
+    overflow: auto hidden;
+    background-color: transparent;
+    scrollbar-color: #6b7280 transparent;
+    scrollbar-width: thin;
+}
+
+.activity-flow-horizontal-scrollbar.is-hidden {
+    display: none;
+}
+
+.activity-flow-horizontal-scrollbar-content {
+    height: 1px;
+}
+
+.activity-flow-horizontal-scrollbar::-webkit-scrollbar {
+    height: 8px;
+}
+
+.activity-flow-horizontal-scrollbar::-webkit-scrollbar-thumb {
+    background-color: #6b7280;
+    border-radius: 9999px;
+}
+
+.activity-flow-horizontal-scrollbar::-webkit-scrollbar-track {
+    background-color: transparent;
 }
 
 .activity-flow-zoom-controls {

package/addon/utils/fleet-ops-options.js

@@ -15,7 +15,7 @@ export const driverTypes = [
 ];
 
 export const driverStatuses = [
-    { label: 'Active', value: 'active', description: 'Driver is available for assignments' },
+    { label: 'Available', value: 'available', description: 'Driver is available for assignments' },
     { label: 'Inactive', value: 'inactive', description: 'Driver is not currently active' },
     { label: 'On Duty', value: 'on_duty', description: 'Driver is working and available' },
     { label: 'Off Duty', value: 'off_duty', description: 'Driver is not working' },
@@ -382,6 +382,7 @@ export const podOptions = [
 export const serviceRateCalculationMethods = [
     { label: 'Per Meter', value: 'per_meter', description: 'Calculate cost based on the number of meters traveled.' },
     { label: 'Fixed Rate', value: 'fixed_meter', description: 'Charge a fixed rate per meter regardless of distance.' },
+    { label: 'Multi-zone Distance', value: 'multi_zone_distance', description: 'Calculate cost by splitting route distance across priced service areas and zones.' },
     { label: 'Parcel Rate', value: 'parcel', description: 'Charge a dynamic rate based on parcel/payload weight and dimensions.' },
     { label: 'Per Drop-off', value: 'per_drop', description: 'Cost applied per drop-off point.' },
     { label: 'Algorithm', value: 'algo', description: 'Cost calculated dynamically using algorithmic logic.' },

package/addon/utils/normalize-order-config-flow.js

@@ -0,0 +1,41 @@
+import { isArray } from '@ember/array';
+
+export function getOrderConfigFlowRootCode(flow = {}) {
+    if (flow.created) {
+        return 'created';
+    }
+
+    return Object.keys(flow)[0];
+}
+
+export default function normalizeOrderConfigFlow(flow = {}) {
+    if (isArray(flow)) {
+        return flow.reduce((normalized, activity, index) => {
+            if (!activity || typeof activity !== 'object') {
+                return normalized;
+            }
+
+            const code = activity.code ?? activity.key;
+            if (!code) {
+                return normalized;
+            }
+
+            const nextActivity = flow.slice(index + 1).find((candidate) => candidate && typeof candidate === 'object' && (candidate.code ?? candidate.key));
+
+            normalized[code] = {
+                ...activity,
+                code,
+                key: activity.key ?? code,
+                activities: isArray(activity.activities) ? activity.activities : nextActivity ? [nextActivity.code ?? nextActivity.key] : [],
+            };
+
+            return normalized;
+        }, {});
+    }
+
+    if (flow && typeof flow === 'object') {
+        return flow;
+    }
+
+    return {};
+}

package/addon/utils/place-address-html.js

@@ -11,17 +11,18 @@ function line(content, className = '') {
     return `<div${classAttribute}>${escapeHtml(content)}</div>`;
 }
 
-export default function placeAddressHtml(place) {
+export default function placeAddressHtml(place, options = {}) {
     if (!place) {
         return htmlSafe('');
     }
 
+    const { showTitle = true } = options;
     const name = place.name === place.street1 ? null : place.name;
     const cityStatePostalCode = [place.city, place.province, place.postal_code].filter((value) => !isBlank(value)).join(', ');
     const lines = [];
 
     if (name) {
-        lines.push(line(name, 'font-semibold'));
+        if (showTitle) lines.push(line(name, 'font-semibold'));
         lines.push(line(place.street1));
     } else if (place.street1) {
         lines.push(line(place.street1, 'font-semibold'));

package/addon/utils/route-visualization.js

@@ -8,6 +8,18 @@ export function waypointToPlace(waypoint) {
     return waypoint.place ?? waypoint;
 }
 
+export function endpointTrackingNumberUuid(payload, role) {
+    if (!payload || !role) {
+        return null;
+    }
+
+    return payload[`${role}_tracking_number_uuid`] ?? null;
+}
+
+export function waypointTrackingNumberUuid(waypoint) {
+    return waypoint?.tracking_number_uuid ?? waypoint?.tracking_number?.uuid ?? waypoint?.trackingNumber?.uuid ?? null;
+}
+
 export function buildPlaceAddressTooltip(title, place) {
     if (!place) {
         return title;
@@ -38,30 +50,65 @@ export function buildRoutePointsFromPayload(payload) {
     const waypoints = payload.waypoints ?? [];
 
     if (hasValidCoordinates(payload.pickup)) {
-        points.push({ role: 'pickup', place: payload.pickup });
+        points.push({ role: 'pickup', place: payload.pickup, trackingNumberUuid: endpointTrackingNumberUuid(payload, 'pickup') });
     }
 
     waypoints.forEach((waypoint, index) => {
         const place = waypointToPlace(waypoint);
 
         if (hasValidCoordinates(place)) {
-            points.push({ role: 'waypoint', place, stopNumber: index + 1 });
+            points.push({ role: 'waypoint', place, stopNumber: index + 1, trackingNumberUuid: waypointTrackingNumberUuid(waypoint) });
         }
     });
 
     if (hasValidCoordinates(payload.dropoff)) {
-        points.push({ role: 'dropoff', place: payload.dropoff });
+        points.push({ role: 'dropoff', place: payload.dropoff, trackingNumberUuid: endpointTrackingNumberUuid(payload, 'dropoff') });
+    }
+
+    if (hasValidCoordinates(payload.return)) {
+        points.push({ role: 'return', place: payload.return, trackingNumberUuid: endpointTrackingNumberUuid(payload, 'return') });
     }
 
     return points;
 }
 
+export function buildServiceStopsFromPayload(payload) {
+    if (!payload) {
+        return [];
+    }
+
+    const stops = [];
+    const waypoints = payload.waypoints ?? [];
+
+    if (payload.pickup) {
+        stops.push({ role: 'pickup', place: payload.pickup, trackingNumberUuid: endpointTrackingNumberUuid(payload, 'pickup') });
+    }
+
+    waypoints.forEach((waypoint, index) => {
+        const place = waypointToPlace(waypoint);
+
+        if (place) {
+            stops.push({ role: 'waypoint', place, stopNumber: index + 1, trackingNumberUuid: waypointTrackingNumberUuid(waypoint) });
+        }
+    });
+
+    if (payload.dropoff) {
+        stops.push({ role: 'dropoff', place: payload.dropoff, trackingNumberUuid: endpointTrackingNumberUuid(payload, 'dropoff') });
+    }
+
+    if (payload.return) {
+        stops.push({ role: 'return', place: payload.return, trackingNumberUuid: endpointTrackingNumberUuid(payload, 'return') });
+    }
+
+    return stops;
+}
+
 export function describeRoutePoint(routePoint, routeColor) {
     const role = routePoint?.role;
     const stopNumber = routePoint?.stopNumber ?? 1;
-    const label = role === 'pickup' ? 'P' : role === 'dropoff' ? 'D' : String(stopNumber);
-    const markerColor = role === 'pickup' ? '#22C55E' : role === 'dropoff' ? '#EF4444' : routeColor;
-    const title = role === 'pickup' ? 'Pickup' : role === 'dropoff' ? 'Dropoff' : `Stop ${stopNumber}`;
+    const label = role === 'pickup' ? 'P' : role === 'dropoff' ? 'D' : role === 'return' ? 'R' : String(stopNumber);
+    const markerColor = role === 'pickup' ? '#22C55E' : role === 'dropoff' ? '#EF4444' : role === 'return' ? '#F97316' : routeColor;
+    const title = role === 'pickup' ? 'Pickup' : role === 'dropoff' ? 'Dropoff' : role === 'return' ? 'Return' : `Stop ${stopNumber}`;
 
     return {
         label,
@@ -74,7 +121,7 @@ export function buildRoutePointMarkerPresentation(routePoint, routeColor, option
     const role = routePoint?.role;
     const place = routePoint?.place;
     const { label, markerColor, title } = describeRoutePoint(routePoint, routeColor);
-    const zIndexOffset = role === 'pickup' ? 2200 : role === 'dropoff' ? 2100 : 1800;
+    const zIndexOffset = role === 'pickup' ? 2200 : role === 'dropoff' ? 2100 : role === 'return' ? 2000 : 1800;
 
     return {
         waypointLabel: label,

package/app/components/modals/order-change-destination.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/modals/order-change-destination';

package/app/components/modals/stop-activity.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/modals/stop-activity';

package/composer.json

@@ -1,6 +1,6 @@
 {
     "name": "fleetbase/fleetops-api",
-    "version": "0.6.49",
+    "version": "0.6.50",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "keywords": [
         "fleetbase-extension",

package/extension.json

@@ -1,6 +1,6 @@
 {
     "name": "Fleet-Ops",
-    "version": "0.6.49",
+    "version": "0.6.50",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "repository": "https://github.com/fleetbase/fleetops",
     "license": "AGPL-3.0-or-later",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fleetbase/fleetops-engine",
-    "version": "0.6.49",
+    "version": "0.6.50",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "fleetbase": {
         "route": "fleet-ops"
@@ -43,8 +43,8 @@
     "dependencies": {
         "@babel/core": "^7.23.2",
         "@fleetbase/ember-core": "^0.3.19",
-        "@fleetbase/ember-ui": "^0.3.30",
-        "@fleetbase/fleetops-data": "^0.1.33",
+        "@fleetbase/ember-ui": "^0.3.32",
+        "@fleetbase/fleetops-data": "^0.1.34",
         "@fleetbase/leaflet-routing-machine": "^3.2.17",
         "@fortawesome/ember-fontawesome": "^2.0.0",
         "@fortawesome/fontawesome-svg-core": "6.4.0",

package/server/migrations/2026_05_21_000001_add_geographic_rules_to_service_rate_fees_table.php

@@ -0,0 +1,37 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    /**
+     * Run the migrations.
+     *
+     * @return void
+     */
+    public function up()
+    {
+        Schema::table('service_rate_fees', function (Blueprint $table) {
+            $table->uuid('service_area_uuid')->nullable()->index()->after('service_rate_uuid');
+            $table->uuid('zone_uuid')->nullable()->index()->after('service_area_uuid');
+            $table->string('label')->nullable()->after('zone_uuid');
+            $table->integer('priority')->default(0)->after('label');
+            $table->boolean('is_fallback')->default(false)->after('priority');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     *
+     * @return void
+     */
+    public function down()
+    {
+        Schema::table('service_rate_fees', function (Blueprint $table) {
+            $table->dropIndex(['service_area_uuid']);
+            $table->dropIndex(['zone_uuid']);
+            $table->dropColumn(['service_area_uuid', 'zone_uuid', 'label', 'priority', 'is_fallback']);
+        });
+    }
+};