@fleetbase/fleetops-engine 0.6.25 → 0.6.26

package/addon/controllers/operations/scheduler/index.js

@@ -1,21 +1,105 @@
 import Controller from '@ember/controller';
 import { tracked } from '@glimmer/tracking';
 import { inject as service } from '@ember/service';
-import { action } from '@ember/object';
+import { action, computed } from '@ember/object';
+import { later } from '@ember/runloop';
+import { task } from 'ember-concurrency';
 import { format, isValid as isValidDate } from 'date-fns';
 import isObject from '@fleetbase/ember-core/utils/is-object';
 import isJson from '@fleetbase/ember-core/utils/is-json';
 import createFullCalendarEventFromOrder, { createOrderEventTitle } from '../../../utils/create-full-calendar-event-from-order';
 
+function createFullCalendarEventFromScheduleItem(item, driver) {
+    return {
+        id: item.id,
+        resourceId: driver.id,
+        title: `${driver.name} - Shift`,
+        start: item.start_at,
+        end: item.end_at,
+        backgroundColor: getScheduleItemColor(item),
+        extendedProps: {
+            scheduleItem: item,
+            driver: driver,
+        },
+    };
+}
+
+function getScheduleItemColor(item) {
+    const statusColors = {
+        pending: '#FFA500',
+        confirmed: '#4CAF50',
+        in_progress: '#2196F3',
+        completed: '#9E9E9E',
+        cancelled: '#F44336',
+        no_show: '#FF5722',
+    };
+    return statusColors[item.status] || '#4CAF50';
+}
+
 export default class OperationsSchedulerIndexController extends Controller {
     @service modalsManager;
     @service notifications;
     @service store;
     @service intl;
     @service hostRouter;
+    @service scheduling;
     @tracked scheduledOrders = [];
     @tracked unscheduledOrders = [];
-    @tracked events = [];
+    @tracked drivers = [];
+    @tracked scheduleItems = [];
+    @tracked viewMode = 'orders'; // 'orders' or 'drivers'
+
+    @computed('drivers', 'scheduleItems.[]', 'scheduledOrders.[]', 'viewMode') get events() {
+        if (this.viewMode === 'drivers') {
+            return this.scheduleItems.map((item) => {
+                const driver = this.drivers.find((d) => d.id === item.assignee_uuid);
+                return createFullCalendarEventFromScheduleItem(item, driver);
+            });
+        }
+        return this.scheduledOrders.map(createFullCalendarEventFromOrder);
+    }
+
+    @computed('drivers.[]') get calendarResources() {
+        return this.drivers.map((driver) => ({
+            id: driver.id,
+            title: driver.name,
+            extendedProps: { driver },
+        }));
+    }
+
+    get calendarStartDate() {
+        const now = new Date();
+        const dayOfWeek = now.getDay();
+        const diff = now.getDate() - dayOfWeek;
+        return new Date(now.setDate(diff)).toISOString();
+    }
+
+    get calendarEndDate() {
+        const now = new Date();
+        return new Date(now.setDate(now.getDate() + 28)).toISOString();
+    }
+
+    @task *loadDrivers() {
+        try {
+            const drivers = yield this.store.query('driver', { limit: 100 });
+            this.drivers = drivers.toArray();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    @task *loadScheduleItems() {
+        try {
+            const items = yield this.store.query('schedule-item', {
+                assignee_type: 'driver',
+                start_at_after: this.calendarStartDate,
+                end_at_before: this.calendarEndDate,
+            });
+            this.scheduleItems = items.toArray();
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
 
     @action setCalendarApi(calendar) {
         this.calendar = calendar;
@@ -79,13 +163,70 @@ export default class OperationsSchedulerIndexController extends Controller {
         });
     }
 
+    @action async switchViewMode(mode) {
+        this.viewMode = mode;
+        if (mode === 'drivers') {
+            await this.loadDrivers.perform();
+            await this.loadScheduleItems.perform();
+            later(() => {
+                if (this.calendar) {
+                    this.calendar.changeView('resourceTimelineWeek');
+                }
+            }, 100);
+        } else {
+            later(() => {
+                if (this.calendar) {
+                    this.calendar.changeView('dayGridMonth');
+                }
+            }, 100);
+        }
+    }
+
     @action viewOrderAsEvent(eventClickInfo) {
         const { event } = eventClickInfo;
+        if (event.extendedProps && event.extendedProps.scheduleItem) {
+            return this.viewScheduleItem(event.extendedProps.scheduleItem, event.extendedProps.driver);
+        }
         const order = this.store.peekRecord('order', event.id);
-
         this.viewEvent(order, eventClickInfo);
     }
 
+    @action viewScheduleItem(scheduleItem, driver) {
+        this.modalsManager.show('modals/driver-shift', {
+            title: `${driver.name} - Shift Details`,
+            acceptButtonText: 'Save Changes',
+            acceptButtonIcon: 'save',
+            scheduleItem,
+            driver,
+            confirm: async (modal) => {
+                modal.startLoading();
+                try {
+                    await scheduleItem.save();
+                    this.notifications.success('Shift updated successfully');
+                    await this.loadScheduleItems.perform();
+                    modal.done();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+            delete: async (modal) => {
+                if (confirm('Are you sure you want to delete this shift?')) {
+                    modal.startLoading();
+                    try {
+                        await scheduleItem.destroyRecord();
+                        this.notifications.success('Shift deleted successfully');
+                        await this.loadScheduleItems.perform();
+                        modal.done();
+                    } catch (error) {
+                        this.notifications.serverError(error);
+                        modal.stopLoading();
+                    }
+                }
+            },
+        });
+    }
+
     @action async scheduleEventFromDrop(dropInfo) {
         const { draggedEl, date } = dropInfo;
         const { dataset } = draggedEl;
@@ -112,17 +253,35 @@ export default class OperationsSchedulerIndexController extends Controller {
 
     @action async rescheduleEventFromDrag(eventDropInfo) {
         const { event } = eventDropInfo;
-        const { start } = event;
+        const { start, end } = event;
+
+        if (event.extendedProps && event.extendedProps.scheduleItem) {
+            const scheduleItem = event.extendedProps.scheduleItem;
+            const newResourceId = event.getResources()[0]?.id;
+            try {
+                scheduleItem.set('start_at', start);
+                scheduleItem.set('end_at', end || start);
+                if (newResourceId && newResourceId !== scheduleItem.assignee_uuid) {
+                    scheduleItem.set('assignee_uuid', newResourceId);
+                }
+                await scheduleItem.save();
+                this.notifications.success('Shift rescheduled successfully');
+                await this.loadScheduleItems.perform();
+            } catch (error) {
+                this.notifications.serverError(error);
+                eventDropInfo.revert();
+            }
+            return;
+        }
+
         const order = this.store.peekRecord('order', event.id);
         const scheduledTime = order.scheduledAtTime;
         const newDate = new Date(`${format(start, 'PP')} ${scheduledTime}`);
 
         try {
-            // set and save order props
             order.set('scheduled_at', isValidDate(newDate) ? newDate : start);
             await order.save();
             this.setEventProperty(event, 'title', createOrderEventTitle(order));
-
             return this.hostRouter.refresh();
         } catch (error) {
             this.notifications.serverError(error);
@@ -130,6 +289,36 @@ export default class OperationsSchedulerIndexController extends Controller {
         }
     }
 
+    @action async addDriverShift() {
+        this.modalsManager.show('modals/add-driver-shift', {
+            title: 'Add Driver Shift',
+            acceptButtonText: 'Create Shift',
+            acceptButtonIcon: 'plus',
+            drivers: this.drivers,
+            confirm: async (modal) => {
+                modal.startLoading();
+                const { driver, startAt, endAt, duration } = modal.getOptions();
+                try {
+                    const scheduleItem = this.store.createRecord('schedule-item', {
+                        assignee_type: 'driver',
+                        assignee_uuid: driver.id,
+                        start_at: startAt,
+                        end_at: endAt,
+                        duration: duration,
+                        status: 'pending',
+                    });
+                    await scheduleItem.save();
+                    this.notifications.success('Shift created successfully');
+                    await this.loadScheduleItems.perform();
+                    modal.done();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+        });
+    }
+
     removeEvent(event) {
         if (isObject(event) && typeof event.remove === 'function') {
             event.remove();

package/addon/controllers/operations/service-rates/index.js

@@ -14,43 +14,47 @@ export default class OperationsServiceRatesIndexController extends Controller {
     @tracked sort = '-created_at';
 
     /** action buttons */
-    @tracked actionButtons = [
-        {
-            icon: 'refresh',
-            onClick: this.serviceRateActions.refresh,
-            helpText: this.intl.t('common.refresh'),
-        },
-        {
-            text: this.intl.t('common.new'),
-            type: 'primary',
-            icon: 'plus',
-            onClick: this.serviceRateActions.transition.create,
-        },
-        {
-            text: this.intl.t('common.export'),
-            icon: 'long-arrow-up',
-            iconClass: 'rotate-icon-45',
-            wrapperClass: 'hidden md:flex',
-            onClick: this.serviceRateActions.export,
-        },
-    ];
+    get actionButtons() {
+        return [
+            {
+                icon: 'refresh',
+                onClick: this.serviceRateActions.refresh,
+                helpText: this.intl.t('common.refresh'),
+            },
+            {
+                text: this.intl.t('common.new'),
+                type: 'primary',
+                icon: 'plus',
+                onClick: this.serviceRateActions.transition.create,
+            },
+            {
+                text: this.intl.t('common.export'),
+                icon: 'long-arrow-up',
+                iconClass: 'rotate-icon-45',
+                wrapperClass: 'hidden md:flex',
+                onClick: this.serviceRateActions.export,
+            },
+        ];
+    }
 
     /** bulk action buttons */
-    @tracked bulkActions = [
-        {
-            label: 'Delete selected...',
-            class: 'text-red-500',
-            fn: this.serviceRateActions.bulkDelete,
-        },
-    ];
+    get bulkActions() {
+        return [
+            {
+                label: 'Delete selected...',
+                class: 'text-red-500',
+                fn: this.serviceRateActions.bulkDelete,
+            },
+        ];
+    }
 
     /** columns **/
     get columns() {
         return [
             {
+                sticky: true,
                 label: this.intl.t('column.id'),
                 valuePath: 'public_id',
-                width: '150px',
                 cellComponent: 'table/cell/anchor',
                 permission: 'fleet-ops view service-rate',
                 onClick: this.serviceRateActions.transition.view,
@@ -63,7 +67,6 @@ export default class OperationsServiceRatesIndexController extends Controller {
                 label: this.intl.t('column.service'),
                 valuePath: 'service_name',
                 cellComponent: 'table/cell/base',
-                width: '125px',
                 resizable: true,
                 sortable: true,
                 filterable: false,
@@ -72,7 +75,6 @@ export default class OperationsServiceRatesIndexController extends Controller {
                 label: this.intl.t('column.service-area'),
                 valuePath: 'service_area.name',
                 cellComponent: 'table/cell/base',
-                width: '125px',
                 resizable: true,
                 sortable: true,
                 filterable: true,
@@ -85,7 +87,6 @@ export default class OperationsServiceRatesIndexController extends Controller {
                 label: this.intl.t('column.zone'),
                 valuePath: 'zone.name',
                 cellComponent: 'table/cell/base',
-                width: '125px',
                 resizable: true,
                 sortable: true,
                 filterable: true,
@@ -98,7 +99,6 @@ export default class OperationsServiceRatesIndexController extends Controller {
                 label: this.intl.t('column.created-at'),
                 valuePath: 'createdAt',
                 sortParam: 'created_at',
-                width: '125px',
                 resizable: true,
                 sortable: true,
                 filterable: true,
@@ -108,7 +108,6 @@ export default class OperationsServiceRatesIndexController extends Controller {
                 label: this.intl.t('column.updated-at'),
                 valuePath: 'updatedAt',
                 sortParam: 'updated_at',
-                width: '125px',
                 resizable: true,
                 sortable: true,
                 hidden: true,
@@ -123,7 +122,8 @@ export default class OperationsServiceRatesIndexController extends Controller {
                 ddButtonIconPrefix: 'fas',
                 cellClassNames: 'overflow-visible',
                 wrapperClass: 'flex items-center justify-end mx-2',
-                width: '10%',
+                sticky: 'right',
+                width: 60,
                 actions: [
                     {
                         label: this.intl.t('column.edit-service'),

package/addon/controllers/settings/payments/index.js

@@ -19,35 +19,29 @@ export default class SettingsPaymentsIndexController extends Controller {
             label: 'Purchase Rate ID',
             valuePath: 'public_id',
             cellComponent: 'click-to-copy',
-            width: '20%',
         },
         {
             label: 'Service Quote',
             valuePath: 'service_quote_id',
             cellComponent: 'click-to-copy',
-            width: '20%',
         },
         {
             label: 'Order',
             valuePath: 'order_id',
             cellComponent: 'click-to-copy',
-            width: '20%',
         },
         {
             label: 'Customer',
             valuePath: 'customer.name',
-            width: '20%',
         },
         {
             label: 'Amount',
             valuePath: 'amount',
             cellComponent: 'table/cell/currency',
-            width: '20%',
         },
         {
             label: 'Date',
             valuePath: 'created_at',
-            width: '20%',
         },
     ];
 

package/addon/routes.js

@@ -63,6 +63,7 @@ export default buildRoutes(function () {
                 this.route('details', { path: '/:public_id' }, function () {
                     this.route('index', { path: '/' });
                     this.route('positions');
+                    this.route('schedule');
                 });
                 this.route('edit', { path: '/edit/:public_id' });
             });

package/addon/services/driver-scheduling.js

@@ -0,0 +1,171 @@
+import Service, { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { task } from 'ember-concurrency';
+
+export default class DriverSchedulingService extends Service {
+    @service store;
+    @service fetch;
+    @service notifications;
+    @tracked currentSchedule = null;
+    @tracked scheduleItems = [];
+    @tracked constraints = [];
+
+    /**
+     * Load a schedule by ID
+     */
+    @task *loadSchedule(scheduleId) {
+        try {
+            const schedule = yield this.store.findRecord('schedule', scheduleId, {
+                include: 'items',
+                reload: true,
+            });
+            this.currentSchedule = schedule;
+            return schedule;
+        } catch (error) {
+            this.notifications.serverError(error);
+            throw error;
+        }
+    }
+
+    /**
+     * Create a new schedule
+     */
+    @task *createSchedule(data) {
+        try {
+            const schedule = this.store.createRecord('schedule', data);
+            yield schedule.save();
+            this.notifications.success('Schedule created successfully');
+            return schedule;
+        } catch (error) {
+            this.notifications.serverError(error);
+            throw error;
+        }
+    }
+
+    /**
+     * Create a new schedule item
+     */
+    @task *createScheduleItem(data) {
+        try {
+            const item = this.store.createRecord('schedule-item', data);
+            yield item.save();
+            this.notifications.success('Schedule item created successfully');
+            return item;
+        } catch (error) {
+            this.notifications.serverError(error);
+            throw error;
+        }
+    }
+
+    /**
+     * Update a schedule item
+     */
+    @task *updateScheduleItem(item, data) {
+        try {
+            item.setProperties(data);
+            yield item.save();
+            this.notifications.success('Schedule item updated successfully');
+            return item;
+        } catch (error) {
+            this.notifications.serverError(error);
+            throw error;
+        }
+    }
+
+    /**
+     * Delete a schedule item
+     */
+    @task *deleteScheduleItem(item) {
+        try {
+            yield item.destroyRecord();
+            this.notifications.success('Schedule item deleted successfully');
+        } catch (error) {
+            this.notifications.serverError(error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get schedule items for an assignee
+     */
+    @task *getScheduleItemsForAssignee(assigneeType, assigneeUuid, filters = {}) {
+        try {
+            const items = yield this.store.query('schedule-item', {
+                assignee_type: assigneeType,
+                assignee_uuid: assigneeUuid,
+                ...filters,
+            });
+            this.scheduleItems = items.toArray();
+            return items;
+        } catch (error) {
+            this.notifications.serverError(error);
+            throw error;
+        }
+    }
+
+    /**
+     * Check availability for a subject
+     */
+    @task *checkAvailability(subjectType, subjectUuid, startAt, endAt) {
+        try {
+            const response = yield this.fetch.get('schedule-availability/check', {
+                subject_type: subjectType,
+                subject_uuid: subjectUuid,
+                start_at: startAt,
+                end_at: endAt,
+            });
+            return response.available;
+        } catch (error) {
+            this.notifications.serverError(error);
+            return false;
+        }
+    }
+
+    /**
+     * Set availability for a subject
+     */
+    @task *setAvailability(data) {
+        try {
+            const availability = this.store.createRecord('schedule-availability', data);
+            yield availability.save();
+            this.notifications.success('Availability set successfully');
+            return availability;
+        } catch (error) {
+            this.notifications.serverError(error);
+            throw error;
+        }
+    }
+
+    /**
+     * Load constraints for a subject
+     */
+    @task *loadConstraints(subjectType, subjectUuid) {
+        try {
+            const constraints = yield this.store.query('schedule-constraint', {
+                subject_type: subjectType,
+                subject_uuid: subjectUuid,
+                is_active: true,
+            });
+            this.constraints = constraints.toArray();
+            return constraints;
+        } catch (error) {
+            this.notifications.serverError(error);
+            throw error;
+        }
+    }
+
+    /**
+     * Validate a schedule item against constraints
+     */
+    @task *validateScheduleItem(item) {
+        try {
+            const response = yield this.fetch.post('schedule-items/validate', {
+                schedule_item: item.serialize(),
+            });
+            return response.violations || [];
+        } catch (error) {
+            this.notifications.serverError(error);
+            return [];
+        }
+    }
+}

package/addon/services/leaflet-layer-visibility-manager.js

@@ -1,5 +1,6 @@
 import Service, { inject as service } from '@ember/service';
 import { next } from '@ember/runloop';
+import { isNone } from '@ember/utils';
 
 const L = window.L || window.leaflet;
 export default class LeafletLayerVisibilityService extends Service {
@@ -203,7 +204,9 @@ export default class LeafletLayerVisibilityService extends Service {
             if (layer.setStyle) {
                 const base = { opacity: 1 };
                 // leaflets default fillOpacity if fill:true is ~0.2
-                base.fillOpacity = layer.options?.fill ? (layer.options?.fillOpacity ?? 0.2) : 0;
+                const fillOpacity = layer.options?.fillOpacity ?? 0.2;
+                const hasFillOpacity = !isNone(layer.options?.fill);
+                base.fillOpacity = hasFillOpacity ? fillOpacity : 0;
                 layer.setStyle(base);
             } else if (layer.setOpacity) {
                 layer.setOpacity(1);

package/addon/services/service-rate-actions.js

@@ -1,5 +1,6 @@
 import ResourceActionService from '@fleetbase/ember-core/services/resource-action';
 import { task } from 'ember-concurrency';
+import { isNone } from '@ember/utils';
 import serializePayload from '../utils/serialize-payload';
 
 export default class ServiceRateActionsService extends ResourceActionService {
@@ -115,12 +116,15 @@ export default class ServiceRateActionsService extends ResourceActionService {
     @task *getServiceQuotes(serviceRate, order) {
         if (order.payload.payloadCoordinates.length < 2) return;
 
+        const hasFacilitator = !isNone(order.facilitator);
+        const facilitatorServiceType = order.facilitator?.get('service_types.firstObject.key') ?? order.type;
+
         try {
             const serviceQuotes = yield this.fetch.post('service-quotes/preliminary', {
                 payload: serializePayload(order.payload),
                 distance: order.route.summary?.totalDistance,
                 time: order.route.summary?.totalTime,
-                service_type: order.facilitator ? (this.args.facilitator.get('service_types.firstObject.key') ?? order.type) : order.type,
+                service_type: hasFacilitator ? facilitatorServiceType : order.type,
                 facilitator: order.facilitator?.public_id,
                 scheduled_at: order.scheduled_at,
                 is_route_optimized: order.optimized,

package/addon/templates/management/drivers/index/details/positions.hbs

@@ -1,2 +1 @@
-{{page-title "Positions"}}
-{{outlet}}
+<PositionsReplay @resource={{@model}} />

package/addon/templates/management/drivers/index/details/schedule.hbs

@@ -1,2 +1 @@
-
-{{outlet}}
+<Driver::Schedule @resource={{@model}} />