@fleetbase/fleetops-engine 0.6.50 → 0.6.52

package/addon/services/contact-actions.js

@@ -1,9 +1,15 @@
 import ResourceActionService from '@fleetbase/ember-core/services/resource-action';
 import { inject as service } from '@ember/service';
-import { action } from '@ember/object';
+import { action, get } from '@ember/object';
+
+const INTERNAL_NAMESPACE = 'int/v1';
 
 export default class ContactActionsService extends ResourceActionService {
+    @service fetch;
     @service placeActions;
+    @service notifications;
+    @service hostRouter;
+    @service('universe/extension-manager') extensionManager;
 
     constructor() {
         super(...arguments);
@@ -112,4 +118,228 @@ export default class ContactActionsService extends ResourceActionService {
             }
         );
     }
+
+    hasLinkedUser(contact) {
+        const user = contact?.user;
+        return Boolean(contact?.user_uuid || (user && (get(user, 'id') || get(user, 'uuid'))));
+    }
+
+    linkedUserStatus(contact) {
+        const user = contact?.user;
+        return (user ? (get(user, 'status') ?? get(user, 'session_status')) : null) ?? 'active';
+    }
+
+    hasInactiveLogin(contact) {
+        return ['inactive', 'disabled', 'suspended'].includes(this.linkedUserStatus(contact));
+    }
+
+    isCustomerPortalInstalled() {
+        return this.extensionManager.isInstalled('@fleetbase/customer-portal-engine');
+    }
+
+    accountActionButton(contact, options = {}) {
+        if (!this.hasLinkedUser(contact)) {
+            return null;
+        }
+
+        return {
+            icon: 'ellipsis-h',
+            iconPrefix: 'fas',
+            renderInPlace: true,
+            items: this.accountActionItems(contact, options),
+        };
+    }
+
+    accountActionItems(contact, options = {}) {
+        const actions = [
+            {
+                text: 'Reset Password',
+                icon: 'key',
+                fn: () => this.openResetPasswordModal(contact),
+            },
+            {
+                text: 'Send Credentials',
+                icon: 'paper-plane',
+                fn: () => this.confirmSendCredentials(contact),
+            },
+            this.hasInactiveLogin(contact)
+                ? {
+                      text: 'Reactivate Login',
+                      icon: 'unlock',
+                      fn: () => this.confirmReactivatePortalLogin(contact),
+                  }
+                : {
+                      text: 'Deactivate Login',
+                      icon: 'lock',
+                      fn: () => this.confirmDeactivatePortalLogin(contact),
+                      class: 'text-red-500 hover:text-red-600',
+                  },
+        ];
+
+        if (this.isCustomerPortalInstalled()) {
+            actions.push(
+                {
+                    separator: true,
+                },
+                {
+                    text: 'Convert to Vendor',
+                    icon: 'building',
+                    fn: () => this.openConvertToVendorModal(contact, options),
+                }
+            );
+        }
+
+        return actions;
+    }
+
+    accountRowActionItems(options = {}) {
+        const hasCustomerPortal = this.isCustomerPortalInstalled();
+        const hasLinkedUser = (contact) => this.hasLinkedUser(contact);
+
+        const actions = [
+            {
+                label: 'Reset Password',
+                icon: 'key',
+                fn: (contact) => this.openResetPasswordModal(contact),
+                isVisible: hasLinkedUser,
+            },
+            {
+                label: 'Send Credentials',
+                icon: 'paper-plane',
+                fn: (contact) => this.confirmSendCredentials(contact),
+                isVisible: hasLinkedUser,
+            },
+            {
+                label: 'Deactivate Login',
+                icon: 'lock',
+                class: 'text-red-500 hover:text-red-600',
+                fn: (contact) => this.confirmDeactivatePortalLogin(contact),
+                isVisible: (contact) => hasLinkedUser(contact) && !this.hasInactiveLogin(contact),
+            },
+            {
+                label: 'Reactivate Login',
+                icon: 'unlock',
+                fn: (contact) => this.confirmReactivatePortalLogin(contact),
+                isVisible: (contact) => hasLinkedUser(contact) && this.hasInactiveLogin(contact),
+            },
+        ];
+
+        if (hasCustomerPortal) {
+            actions.push({
+                label: 'Convert to Vendor',
+                icon: 'building',
+                fn: (contact) => this.openConvertToVendorModal(contact, options),
+                isVisible: hasLinkedUser,
+            });
+        }
+
+        return actions;
+    }
+
+    openResetPasswordModal(contact) {
+        this.modalsManager.show('modals/reset-customer-credentials', {
+            customer: contact,
+        });
+    }
+
+    openConvertToVendorModal(contact, options = {}) {
+        this.modalsManager.show('modals/convert-customer-to-vendor', {
+            customer: contact,
+            onConverted: (vendor) => {
+                if (typeof options.onConverted === 'function') {
+                    options.onConverted(vendor);
+                    return;
+                }
+
+                if (vendor?.id) {
+                    this.hostRouter.transitionTo('console.fleet-ops.management.vendors.index.details', vendor.id);
+                }
+            },
+        });
+    }
+
+    confirmSendCredentials(contact) {
+        this.confirmLoginAction(contact, {
+            title: 'Send Portal Credentials',
+            body: 'Generate a new temporary password and email this contact their portal credentials.',
+            acceptButtonText: 'Send Credentials',
+            endpoint: 'customers/send-credentials',
+            successMessage: 'Portal credentials sent.',
+        });
+    }
+
+    confirmDeactivatePortalLogin(contact) {
+        this.confirmLoginAction(contact, {
+            title: 'Deactivate Login',
+            body: 'Deactivate portal access for this contact. Their profile and history will be preserved.',
+            acceptButtonText: 'Deactivate Login',
+            acceptButtonScheme: 'danger',
+            endpoint: 'customers/deactivate-portal-login',
+            successMessage: 'Portal login deactivated.',
+        });
+    }
+
+    confirmReactivatePortalLogin(contact) {
+        this.confirmLoginAction(contact, {
+            title: 'Reactivate Login',
+            body: 'Reactivate portal access for this contact.',
+            acceptButtonText: 'Reactivate Login',
+            endpoint: 'customers/reactivate-portal-login',
+            successMessage: 'Portal login reactivated.',
+        });
+    }
+
+    confirmLoginAction(contact, { title, body, acceptButtonText, acceptButtonScheme, endpoint, successMessage }) {
+        this.modalsManager.confirm({
+            title,
+            body,
+            acceptButtonText,
+            acceptButtonScheme,
+            confirm: async (modal) => {
+                modal.startLoading();
+
+                try {
+                    const response = await this.fetch.post(endpoint, { customer: contact?.id }, { namespace: INTERNAL_NAMESPACE });
+                    await this.updateContactFromResponse(contact, response);
+                    this.notifications.success(successMessage);
+                    modal.done();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+        });
+    }
+
+    async updateContactFromResponse(contact, response) {
+        const payload = response.customer ?? response.contact;
+
+        if (!payload || typeof contact?.setProperties !== 'function') {
+            return;
+        }
+
+        contact.setProperties(
+            this.withoutIdentityFields({
+                user_uuid: payload.user_uuid,
+            })
+        );
+
+        if (payload.user) {
+            const user = await contact.user;
+
+            if (typeof user?.setProperties === 'function') {
+                user.setProperties(this.withoutIdentityFields(payload.user));
+            }
+        }
+    }
+
+    withoutIdentityFields(payload = {}) {
+        const attributes = { ...payload };
+
+        delete attributes.id;
+        delete attributes.uuid;
+        delete attributes.public_id;
+
+        return attributes;
+    }
 }

package/addon/services/device-actions.js

@@ -1,6 +1,9 @@
-import ResourceActionService from '@fleetbase/ember-core/services/resource-action';
+import ResourceActionService, { inject as service } from '@fleetbase/ember-core/services/resource-action';
+import { action } from '@ember/object';
 
 export default class DeviceActionsService extends ResourceActionService {
+    @service fetch;
+
     constructor() {
         super(...arguments);
         this.initialize('device');
@@ -78,4 +81,64 @@ export default class DeviceActionsService extends ResourceActionService {
             });
         },
     };
+
+    @action attachToVehicle(device, options = {}) {
+        this.modalsManager.show('modals/attach-telematic-device', {
+            title: this.intl.t('device.prompts.attach-to-vehicle-title'),
+            acceptButtonText: this.intl.t('device.actions.attach-to-vehicle'),
+            acceptButtonIcon: 'link',
+            device,
+            selectedVehicle: null,
+            confirm: async (modal) => {
+                const selectedVehicle = modal.getOption('selectedVehicle');
+
+                if (!selectedVehicle) {
+                    return this.notifications.warning(this.intl.t('device.prompts.select-vehicle-warning'));
+                }
+
+                modal.startLoading();
+
+                try {
+                    await this.fetch.post(`devices/${device.id}/attach`, { vehicle: selectedVehicle.id });
+                    await device.reload?.();
+                    this.notifications.success(this.intl.t('device.prompts.attach-to-vehicle-success'));
+                    modal.done();
+                    this.refresh();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+            ...options,
+        });
+    }
+
+    @action detachFromVehicle(device, options = {}) {
+        const deviceName = device.displayName ?? device.name ?? this.intl.t('resource.device');
+        const vehicleName = device.attached_to_name ?? device.attachable?.display_name ?? device.attachable?.name;
+
+        if (!device.attachable_uuid && !vehicleName) {
+            return this.notifications.warning(this.intl.t('device.prompts.not-attached-warning', { deviceName }));
+        }
+
+        this.modalsManager.confirm({
+            title: this.intl.t('device.prompts.detach-from-vehicle-title', { deviceName }),
+            body: this.intl.t('device.prompts.detach-from-vehicle-body', { deviceName, vehicleName: vehicleName ?? this.intl.t('resource.vehicle') }),
+            confirm: async (modal) => {
+                modal.startLoading();
+
+                try {
+                    await this.fetch.post(`devices/${device.id}/detach`);
+                    await device.reload?.();
+                    this.notifications.success(this.intl.t('device.prompts.detach-from-vehicle-success'));
+                    modal.done();
+                    this.refresh();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+            ...options,
+        });
+    }
 }

package/addon/services/device-event-actions.js

@@ -1,9 +1,13 @@
+import { inject as service } from '@ember/service';
 import ResourceActionService from '@fleetbase/ember-core/services/resource-action';
 
 export default class DeviceEventActionsService extends ResourceActionService {
+    @service fetch;
+    @service notifications;
+
     constructor() {
         super(...arguments);
-        this.initialize('device');
+        this.initialize('device-event');
     }
 
     transition = {
@@ -34,4 +38,11 @@ export default class DeviceEventActionsService extends ResourceActionService {
             });
         },
     };
+
+    async markProcessed(deviceEvent) {
+        const response = await this.fetch.post(`device-events/${deviceEvent.id}/mark-processed`);
+        this.notifications.success(response?.message ?? 'Event marked processed.');
+
+        return response;
+    }
 }

package/addon/services/driver-actions.js

@@ -7,6 +7,7 @@ import { dasherize } from '@ember/string';
 
 export default class DriverActionsService extends ResourceActionService {
     @service('universe/menu-service') menuService;
+    @service fetch;
 
     get registeredTabs() {
         const registeredTabs = this.menuService.getMenuItems('fleet-ops:component:driver:details');
@@ -176,8 +177,8 @@ export default class DriverActionsService extends ResourceActionService {
 
     @action assignOrder(driver, options = {}) {
         this.modalsManager.show('modals/driver-assign-order', {
-            title: this.intl.t('fleet-ops.management.drivers.index.order-driver'),
-            acceptButtonText: this.intl.t('fleet-ops.management.drivers.index.assign-order'),
+            title: this.intl.t('driver.prompts.assign-order-title', { driverName: driver.name }),
+            acceptButtonText: this.intl.t('driver.actions.assign-order'),
             acceptButtonIcon: 'check',
             acceptButtonIconPrefix: 'fas',
             acceptButtonDisabled: true,
@@ -191,18 +192,20 @@ export default class DriverActionsService extends ResourceActionService {
             confirm: async (modal) => {
                 const selectedOrder = modal.getOption('selectedOrder');
                 if (!selectedOrder) {
-                    return this.notifications.warning(this.intl.t('fleet-ops.management.drivers.index.no-order-warning'));
+                    return this.notifications.warning(this.intl.t('driver.prompts.select-order-warning'));
                 }
 
                 modal.startLoading();
 
                 try {
-                    driver.set('current_job_uuid', selectedOrder.id);
-                    await driver.save();
+                    await this.fetch.post(`drivers/${driver.id}/assign-order`, { order: selectedOrder.id });
+                    await driver.reload?.();
+                    this.notifications.success(this.intl.t('driver.prompts.assign-order-success', { driverName: driver.name }));
+                    modal.done();
+                    this.refresh();
                 } catch (err) {
                     this.notifications.serverError(err);
                     driver.rollbackAttributes();
-                } finally {
                     modal.stopLoading();
                 }
             },
@@ -212,8 +215,8 @@ export default class DriverActionsService extends ResourceActionService {
 
     @action assignVehicle(driver, options = {}) {
         this.modalsManager.show('modals/driver-assign-vehicle', {
-            title: this.intl.t('fleet-ops.management.drivers.index.title-vehicle'),
-            acceptButtonText: this.intl.t('fleet-ops.management.drivers.index.confirm-button'),
+            title: this.intl.t('driver.prompts.assign-vehicle-title', { driverName: driver.name }),
+            acceptButtonText: this.intl.t('driver.actions.assign-vehicle'),
             acceptButtonIcon: 'check',
             hideDeclineButton: true,
             driver,
@@ -221,16 +224,149 @@ export default class DriverActionsService extends ResourceActionService {
                 modal.startLoading();
 
                 try {
-                    await driver.save();
-                    this.notifications.success(this.intl.t('fleet-ops.management.drivers.index.assign-vehicle', { driverName: driver.name }));
+                    const vehicleId = driver.vehicle_uuid ?? driver.vehicle?.id;
+                    if (!vehicleId) {
+                        modal.stopLoading();
+                        return this.notifications.warning(this.intl.t('driver.prompts.select-vehicle-warning'));
+                    }
+
+                    await this.fetch.post(`drivers/${driver.id}/assign-vehicle`, { vehicle: vehicleId });
+                    await driver.reload?.();
+                    this.notifications.success(this.intl.t('driver.prompts.assign-vehicle-success', { driverName: driver.name }));
+                    modal.done();
+                    this.refresh();
                 } catch (err) {
                     this.notifications.serverError(err);
                     driver.rollbackAttributes();
-                } finally {
                     modal.stopLoading();
                 }
             },
             ...options,
         });
     }
+
+    @action unassignOrder(driver, options = {}) {
+        return this.unassignOrders(driver, options);
+    }
+
+    @action async unassignOrders(driver, options = {}) {
+        let response;
+
+        try {
+            response = await this.fetch.get(`drivers/${driver.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),
+        }));
+
+        if (orders.length === 0) {
+            return this.notifications.warning(this.intl.t('driver.prompts.no-assigned-orders-warning', { driverName: driver.name }));
+        }
+
+        this.modalsManager.show('modals/assigned-orders', {
+            title: this.intl.t('driver.prompts.unassign-orders-title', { driverName: driver.name }),
+            acceptButtonText: this.intl.t('driver.actions.unassign-orders'),
+            acceptButtonIcon: 'user-minus',
+            acceptButtonDisabled: true,
+            subjectLabel: this.intl.t('resource.driver'),
+            subjectName: driver.name,
+            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('driver.prompts.select-orders-warning'));
+                }
+
+                const orderList = this.orderReferenceList(selectedOrders);
+                const confirmed = await this.confirmUnassignOrders({
+                    title: this.intl.t('driver.prompts.confirm-unassign-orders-title', { count: selectedOrders.length, driverName: driver.name }),
+                    body: this.intl.t('driver.prompts.confirm-unassign-orders-body', { driverName: driver.name, orders: orderList }),
+                });
+
+                if (!confirmed) {
+                    return;
+                }
+
+                modal.startLoading();
+
+                try {
+                    await this.fetch.post(`drivers/${driver.id}/unassign-orders`, { orders: selectedOrderIds });
+                    await driver.reload?.();
+                    this.notifications.success(this.intl.t('driver.prompts.unassign-orders-success', { count: selectedOrders.length, driverName: driver.name }));
+                    modal.done();
+                    this.refresh();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+            ...options,
+        });
+    }
+
+    @action unassignVehicle(driver, options = {}) {
+        const vehicleName = driver.vehicle?.get?.('display_name') ?? driver.vehicle?.get?.('name') ?? driver.get?.('vehicle_name') ?? driver.vehicle_name;
+
+        if (!driver.vehicle_uuid && !driver.vehicle?.id && !vehicleName) {
+            return this.notifications.warning(this.intl.t('driver.prompts.no-vehicle-assigned-warning', { driverName: driver.name }));
+        }
+
+        this.modalsManager.confirm({
+            title: this.intl.t('driver.prompts.unassign-vehicle-title', { driverName: driver.name, vehicleName }),
+            body: this.intl.t('driver.prompts.unassign-vehicle-body', { driverName: driver.name, vehicleName }),
+            confirm: async (modal) => {
+                modal.startLoading();
+
+                try {
+                    await this.fetch.post(`drivers/${driver.id}/unassign-vehicle`);
+                    await driver.reload?.();
+                    this.notifications.success(this.intl.t('driver.prompts.unassign-vehicle-success', { driverName: driver.name, vehicleName }));
+                    modal.done();
+                    this.refresh();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+            ...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);
+                },
+            });
+        });
+    }
 }

package/addon/services/fleet-actions.js

@@ -1,6 +1,9 @@
-import ResourceActionService from '@fleetbase/ember-core/services/resource-action';
+import ResourceActionService, { inject as service } from '@fleetbase/ember-core/services/resource-action';
+import { action } from '@ember/object';
 
 export default class FleetActionsService extends ResourceActionService {
+    @service fetch;
+
     constructor() {
         super(...arguments);
         this.initialize('fleet', { defaultAttributes: { status: 'active' } });
@@ -81,4 +84,66 @@ export default class FleetActionsService extends ResourceActionService {
             });
         },
     };
+
+    @action assignDriver(fleet, options = {}) {
+        this.modalsManager.show('modals/fleet-assign-driver', {
+            title: this.intl.t('fleet.prompts.assign-driver-title', { fleetName: fleet.name }),
+            acceptButtonText: this.intl.t('fleet.actions.assign-driver'),
+            acceptButtonIcon: 'user-plus',
+            selectedDriver: null,
+            fleet,
+            confirm: async (modal) => {
+                const selectedDriver = modal.getOption('selectedDriver');
+
+                if (!selectedDriver) {
+                    return this.notifications.warning(this.intl.t('fleet.prompts.select-driver-warning'));
+                }
+
+                modal.startLoading();
+
+                try {
+                    await this.fetch.post('fleets/assign-driver', { driver: selectedDriver.id, fleet: fleet.id });
+                    await fleet.reload?.();
+                    this.notifications.success(this.intl.t('fleet.prompts.assign-driver-success', { fleetName: fleet.name }));
+                    modal.done();
+                    this.refresh();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+            ...options,
+        });
+    }
+
+    @action assignVehicle(fleet, options = {}) {
+        this.modalsManager.show('modals/fleet-assign-vehicle', {
+            title: this.intl.t('fleet.prompts.assign-vehicle-title', { fleetName: fleet.name }),
+            acceptButtonText: this.intl.t('fleet.actions.assign-vehicle'),
+            acceptButtonIcon: 'car',
+            selectedVehicle: null,
+            fleet,
+            confirm: async (modal) => {
+                const selectedVehicle = modal.getOption('selectedVehicle');
+
+                if (!selectedVehicle) {
+                    return this.notifications.warning(this.intl.t('fleet.prompts.select-vehicle-warning'));
+                }
+
+                modal.startLoading();
+
+                try {
+                    await this.fetch.post('fleets/assign-vehicle', { vehicle: selectedVehicle.id, fleet: fleet.id });
+                    await fleet.reload?.();
+                    this.notifications.success(this.intl.t('fleet.prompts.assign-vehicle-success', { fleetName: fleet.name }));
+                    modal.done();
+                    this.refresh();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                    modal.stopLoading();
+                }
+            },
+            ...options,
+        });
+    }
 }

package/addon/services/fuel-integration-actions.js

@@ -0,0 +1,31 @@
+import ResourceActionService from '@fleetbase/ember-core/services/resource-action';
+
+export default class FuelIntegrationActionsService extends ResourceActionService {
+    constructor() {
+        super(...arguments);
+        this.initialize('fuel-provider-connection', {
+            defaultAttributes: {
+                status: 'draft',
+                environment: 'production',
+                credentials: {},
+                sync_settings: {
+                    window_days: 7,
+                    matching_order: ['plate_number', 'internal_id', 'vin', 'serial_number', 'call_sign', 'fuel_card_number', 'trip_number'],
+                    auto_create_fuel_reports: true,
+                },
+            },
+        });
+    }
+
+    transition = {
+        view: (connection) => this.transitionTo('connectivity.fuel-providers.details', connection),
+        edit: (connection) => this.transitionTo('connectivity.fuel-providers.edit', connection),
+        create: (provider) => {
+            if (provider) {
+                return this.transitionTo('connectivity.fuel-providers.new', { queryParams: { setupProvider: provider } });
+            }
+
+            return this.transitionTo('connectivity.fuel-providers.new');
+        },
+    };
+}