@fleetbase/fleetops-engine 0.4.16 → 0.4.17

package/addon/controllers/application.js

@@ -5,7 +5,7 @@ import { computed, action } from '@ember/object';
 
 export default class ApplicationController extends BaseController {
     @service hostRouter;
-
+    @service contextPanel;
     @tracked routes = ['console.fleet-ops.operations', 'console.fleet-ops.management', 'console.fleet-ops.comms'];
     @tracked settingsContext;
 
@@ -21,6 +21,10 @@ export default class ApplicationController extends BaseController {
         this.settingsContext?.close();
     }
 
+    @action openOrderConfigManager() {
+        this.contextPanel.focus('orderConfigManager');
+    }
+
     @action isRouteActive(route) {
         const currentRouteName = this.hostRouter.currentRouteName;
         const contains = (haystack, needle) => haystack.includes(needle);

package/addon/controllers/operations/order-config.js

@@ -0,0 +1,42 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { action } from '@ember/object';
+
+export default class OperationsOrderConfigController extends Controller {
+    @tracked tab = 'details';
+    @tracked config;
+    @tracked context;
+    @tracked contextModel;
+    queryParams = ['tab', 'config', 'context', 'contextModel'];
+
+    /**
+     * Handle tab change.
+     *
+     * @param {string} tab
+     * @memberof OperationsOrderConfigController
+     */
+    @action onTabChanged(tab) {
+        this.tab = tab;
+    }
+
+    /**
+     * Handle order config change.
+     *
+     * @param {*} config
+     * @memberof OperationsOrderConfigController
+     */
+    @action onConfigChanged(config) {
+        this.config = config.id;
+    }
+
+    /**
+     * Handle order config change.
+     *
+     * @param {*} config
+     * @memberof OperationsOrderConfigController
+     */
+    @action onContextChanged(context, contextModel) {
+        this.context = context;
+        this.contextModel = contextModel;
+    }
+}

package/addon/controllers/operations/orders/index/new.js

@@ -5,14 +5,15 @@ import { tracked } from '@glimmer/tracking';
 import { action, computed, setProperties, set, get } from '@ember/object';
 import { not, equal, alias } from '@ember/object/computed';
 import { isArray } from '@ember/array';
+import { isBlank } from '@ember/utils';
 import { dasherize } from '@ember/string';
 import { later, next } from '@ember/runloop';
+import { task } from 'ember-concurrency-decorators';
 import { OSRMv1, Control as RoutingControl } from '@fleetbase/leaflet-routing-machine';
 import polyline from '@fleetbase/ember-core/utils/polyline';
 import findClosestWaypoint from '@fleetbase/ember-core/utils/find-closest-waypoint';
 import isNotEmpty from '@fleetbase/ember-core/utils/is-not-empty';
 import getRoutingHost from '@fleetbase/ember-core/utils/get-routing-host';
-import groupBy from '@fleetbase/ember-core/utils/macros/group-by';
 import getWithDefault from '@fleetbase/ember-core/utils/get-with-default';
 import isModel from '@fleetbase/ember-core/utils/is-model';
 
@@ -125,10 +126,15 @@ export default class OperationsOrdersIndexNewController extends BaseController {
     @tracked entities = [];
     @tracked waypoints = [];
     @tracked payloadCoordinates = [];
-    @tracked types = [];
+    @tracked orderConfig;
+    @tracked orderConfigs = [];
+    @tracked customFieldGroups = [];
+    @tracked customFields = [];
+    @tracked customFieldValues = {};
     @tracked serviceRates = [];
     @tracked selectedServiceRate;
     @tracked selectedServiceQuote;
+    @tracked isCustomFieldsValid = true;
     @tracked isCreatingOrder = false;
     @tracked isMultipleDropoffOrder = false;
     @tracked isViewingRoutePreview = false;
@@ -145,7 +151,7 @@ export default class OperationsOrdersIndexNewController extends BaseController {
     @tracked leafletLayers = [];
     @tracked routeProfile = 'driving';
     @tracked routeProfileOptions = ['driving', 'bycicle', 'walking'];
-    @tracked podOptions = ['scan', 'signature'];
+    @tracked podOptions = ['scan', 'signature', 'photo'];
     @tracked isCsvImportedOrder = false;
     @tracked routePreviewArray = [];
     @tracked previewRouteControl;
@@ -184,14 +190,18 @@ export default class OperationsOrdersIndexNewController extends BaseController {
         'application/x-tar',
     ];
 
+    get renderableComponents() {
+        const renderableComponents = this.universe.getRenderableComponentsFromRegistry('fleet-ops:template:operations:orders:new');
+        return renderableComponents;
+    }
+
     @not('isServicable') isNotServicable;
     @alias('currentUser.latitude') userLatitude;
     @alias('currentUser.longitude') userLongitude;
     @alias('ordersController.leafletMap') leafletMap;
     @equal('isCsvImportedOrder', false) isNotCsvImportedOrder;
-    @groupBy('typeConfig.meta.fields', 'group') groupedMetaFields;
 
-    @computed('entities.length', 'isMultipleDropoffOrder', 'isFetchingQuotes', 'isSubscriptionValid', 'order.type', 'payload.{dropoff,pickup}', 'waypoints.length')
+    @computed('isCustomFieldsValid', 'entities.length', 'isMultipleDropoffOrder', 'isFetchingQuotes', 'isSubscriptionValid', 'order.type', 'payload.{dropoff,pickup}', 'waypoints.length')
     get isValid() {
         const { isMultipleDropoffOrder, isSubscriptionValid, isFetchingQuotes } = this;
         const isOrderTypeSet = isNotEmpty(this.order?.type);
@@ -212,7 +222,7 @@ export default class OperationsOrdersIndexNewController extends BaseController {
             return isOrderTypeSet && isWaypointsSet;
         }
 
-        return isOrderTypeSet && isPickupSet && isDropoffSet;
+        return isOrderTypeSet && isPickupSet && isDropoffSet && this.isCustomFieldsValid;
     }
 
     updatePayloadCoordinates() {
@@ -246,14 +256,6 @@ export default class OperationsOrdersIndexNewController extends BaseController {
         );
     }
 
-    @computed('order.type', 'types') get typeConfig() {
-        return this.types.find((type) => type.key === this.order.type);
-    }
-
-    @computed('order.type', 'types') get typeConfigIndex() {
-        return this.types.findIndex((type) => type.key === this.order.type);
-    }
-
     @computed('entities.[]', 'waypoints.[]') get entitiesByImportId() {
         const groups = [];
 
@@ -276,6 +278,16 @@ export default class OperationsOrdersIndexNewController extends BaseController {
         return groups;
     }
 
+    checkIfCustomFieldsValid() {
+        this.isCustomFieldsValid = this.customFields.every((customField) => {
+            if (!customField.required) {
+                return true;
+            }
+            const customFieldValue = this.customFieldValues[customField.id];
+            return customFieldValue && !isBlank(customFieldValue.value);
+        });
+    }
+
     @action createOrder() {
         if (!this.isValid) {
             return;
@@ -307,6 +319,29 @@ export default class OperationsOrdersIndexNewController extends BaseController {
             return;
         }
 
+        // valiadate custom field inputs
+        for (let i = 0; i < this.customFields.length; i++) {
+            const customField = this.customFields[i];
+            if (customField.required) {
+                const customFieldValue = this.customFieldValues[customField.id];
+                if (!customFieldValue || isBlank(customFieldValue.value)) {
+                    this.loader.removeLoader();
+                    return this.notifications.error(this.intl.t('fleet-ops.operations.orders.index.new.input-field-required', { inputFieldName: customField.label }));
+                }
+            }
+        }
+
+        // create custom field values
+        for (let customFieldId in this.customFieldValues) {
+            const { value, value_type } = this.customFieldValues[customFieldId];
+            const customFieldValue = this.store.createRecord('custom-field-value', {
+                custom_field_uuid: customFieldId,
+                value,
+                value_type,
+            });
+            this.order.custom_field_values.push(customFieldValue);
+        }
+
         // send event that fleetops is `creating` an order
         this.universe.trigger('fleet-ops.order.creating', order);
         this.isCreatingOrder = true;
@@ -1033,7 +1068,8 @@ export default class OperationsOrdersIndexNewController extends BaseController {
         const meta = [];
         const entities = [];
         const waypoints = [];
-        const types = [];
+        const orderConfigs = [];
+        const orderConfig = undefined;
         const isCreatingOrder = false;
         const isMultipleDropoffOrder = false;
         const leafletRoute = undefined;
@@ -1051,7 +1087,8 @@ export default class OperationsOrdersIndexNewController extends BaseController {
             meta,
             entities,
             waypoints,
-            types,
+            orderConfigs,
+            orderConfig,
             isCreatingOrder,
             isMultipleDropoffOrder,
             leafletRoute,
@@ -1063,14 +1100,72 @@ export default class OperationsOrdersIndexNewController extends BaseController {
         this.resetInterface();
     }
 
-    @action setConfig(type) {
-        if (!type) {
+    @action setConfig(event) {
+        const orderConfigId = event.target.value;
+        if (!orderConfigId) {
             return;
         }
 
-        set(this, 'order.type', type);
-        this.meta = [];
-        this.applyCustomMetaFields(type);
+        const orderConfig = this.store.peekRecord('order-config', orderConfigId);
+        this.orderConfig = orderConfig;
+        this.order.set('order_config_uuid', orderConfig.id);
+        this.order.set('type', orderConfig.key);
+
+        // load custom fields
+        this.loadCustomFields.perform(orderConfig);
+    }
+
+    /**
+     * A task method to load custom fields from the store and group them.
+     * @task
+     */
+    @task *loadCustomFields(orderConfig) {
+        this.customFieldGroups = yield this.store.query('category', { owner_uuid: orderConfig.id, for: 'custom_field_group' });
+        this.customFields = yield this.store.query('custom-field', { subject_uuid: orderConfig.id });
+        this.groupCustomFields();
+        this.checkIfCustomFieldsValid();
+    }
+
+    /**
+     * Organizes custom fields into their respective groups.
+     */
+    groupCustomFields() {
+        for (let i = 0; i < this.customFieldGroups.length; i++) {
+            const group = this.customFieldGroups[i];
+            group.set(
+                'customFields',
+                this.customFields.filter((customField) => {
+                    return customField.category_uuid === group.id;
+                })
+            );
+        }
+    }
+
+    @action setCustomFieldValue(value, customField) {
+        this.customFieldValues = {
+            ...this.customFieldValues,
+            [customField.id]: {
+                value,
+                value_type: this._getCustomFieldValueType(customField),
+            },
+        };
+        this.checkIfCustomFieldsValid();
+    }
+
+    _getCustomFieldValueType(customField) {
+        if (customField.type === 'file-upload') {
+            return 'file';
+        }
+
+        if (customField.type === 'date-time-input') {
+            return 'date';
+        }
+
+        if (customField.type === 'model-select') {
+            return 'model';
+        }
+
+        return 'text';
     }
 
     @action setOrderFacilitator(model) {
@@ -1302,6 +1397,15 @@ export default class OperationsOrdersIndexNewController extends BaseController {
         this.entities[index].destination_uuid = value;
     }
 
+    @action addFromCustomEntity(customEntity) {
+        const entity = this.store.createRecord('entity', {
+            ...customEntity,
+            id: undefined,
+        });
+
+        this.entities.pushObject(entity);
+    }
+
     @action addEntity(importId = null) {
         const entity = this.store.createRecord('entity', {
             _import_id: importId,

package/addon/controllers/operations/orders/index/view.js

@@ -7,7 +7,6 @@ import { later } from '@ember/runloop';
 import { not, notEmpty, alias } from '@ember/object/computed';
 import { task } from 'ember-concurrency-decorators';
 import { OSRMv1, Control as RoutingControl } from '@fleetbase/leaflet-routing-machine';
-import groupBy from '@fleetbase/ember-core/utils/macros/group-by';
 import getRoutingHost from '@fleetbase/ember-core/utils/get-routing-host';
 
 export default class OperationsOrdersIndexViewController extends BaseController {
@@ -111,9 +110,12 @@ export default class OperationsOrdersIndexViewController extends BaseController
 
     @tracked isLoadingAdditionalData = false;
     @tracked isWaypointsCollapsed;
+    @tracked isEditingOrderNotes = false;
     @tracked leafletRoute;
     @tracked routeControl;
     @tracked commentInput = '';
+    @tracked customFieldGroups = [];
+    @tracked customFields = [];
     @tracked uploadQueue = [];
     acceptedFileTypes = [
         'application/vnd.ms-excel',
@@ -166,10 +168,26 @@ export default class OperationsOrdersIndexViewController extends BaseController
         },
     ];
 
+    @tracked notesPanelButtons = [
+        {
+            type: 'default',
+            text: 'Edit',
+            icon: 'pencil',
+            iconPrefix: 'fas',
+            onClick: () => {
+                this.editOrderNotes();
+            },
+        },
+    ];
+
     @not('isWaypointsCollapsed') waypointsIsNotCollapsed;
     @notEmpty('model.payload.waypoints') isMultiDropOrder;
     @alias('ordersController.leafletMap') leafletMap;
-    @groupBy('model.order_config.meta.fields', 'group') groupedMetaFields;
+
+    get renderableComponents() {
+        const renderableComponents = this.universe.getRenderableComponentsFromRegistry('fleet-ops:template:operations:orders:view');
+        return renderableComponents;
+    }
 
     /** @var entitiesByDestination */
     @computed('model.payload.{entities.[],waypoints.[]}')
@@ -220,14 +238,53 @@ export default class OperationsOrdersIndexViewController extends BaseController
     }
 
     @task *loadOrderRelations(order) {
+        yield order.loadOrderConfig();
         yield order.loadPayload();
         yield order.loadDriver();
         yield order.loadTrackingNumber();
         yield order.loadCustomer();
         yield order.loadTrackingActivity();
-        yield order.loadOrderConfig();
         yield order.loadPurchaseRate();
         yield order.loadFiles();
+        this.loadCustomFields.perform(order);
+    }
+
+    /**
+     * A task method to load custom fields from the store and group them.
+     * @task
+     */
+    @task *loadCustomFields(order) {
+        const orderConfig = order.order_config;
+        if (orderConfig) {
+            this.customFieldGroups = yield this.store.query('category', { owner_uuid: orderConfig.id, for: 'custom_field_group' });
+            this.customFields = yield this.store.query('custom-field', { subject_uuid: orderConfig.id });
+            this.groupCustomFields(order);
+        }
+    }
+
+    /**
+     * Organizes custom fields into their respective groups.
+     */
+    groupCustomFields(order) {
+        const customFields = Array.from(this.customFields);
+        const customFieldValues = Array.from(order.custom_field_values);
+        // map values to the custom fields
+        const customFieldsWithValues = customFields.map((customField) => {
+            customField.value = customFieldValues.find((customFieldValue) => customFieldValue.custom_field_uuid === customField.id);
+            return customField;
+        });
+        // update custom fields with values
+        this.customFields = customFieldsWithValues;
+        // group custom fields
+        for (let i = 0; i < this.customFieldGroups.length; i++) {
+            const group = this.customFieldGroups[i];
+            group.set(
+                'customFields',
+                customFieldsWithValues.filter((customField) => {
+                    return customField.category_uuid === group.id;
+                })
+            );
+        }
     }
 
     @action resetView() {
@@ -495,6 +552,25 @@ export default class OperationsOrdersIndexViewController extends BaseController
         });
     }
 
+    @action editOrderNotes() {
+        this.isEditingOrderNotes = true;
+    }
+
+    @task *saveOrderNotes() {
+        const { notes } = this.model;
+        yield this.model.persistProperty('notes', notes).then(() => {
+            this.notifications.success(this.intl.t('fleet-ops.operations.orders.index.view.order-notes-updated'));
+        });
+        this.isEditingOrderNotes = false;
+    }
+
+    /**
+     * Prompt to unassign driver from otder.
+     *
+     * @param {OrderModel} order
+     * @param {*} [options={}]
+     * @memberof OperationsOrdersIndexViewController
+     */
     @action unassignDriver(order, options = {}) {
         this.modalsManager.confirm({
             title: this.intl.t('fleet-ops.operations.orders.index.view.edit-order-title', { driverName: order.driver_assigned.name }),
@@ -593,7 +669,7 @@ export default class OperationsOrdersIndexViewController extends BaseController
     @action dispatchOrder(order) {
         this.ordersController.dispatchOrder(order, {
             onConfirm: () => {
-                order.loadTrackingActivity();
+                this.loadOrderRelations.perform(order);
             },
         });
     }
@@ -916,4 +992,11 @@ export default class OperationsOrdersIndexViewController extends BaseController
     @action removeFile(file) {
         return file.destroyRecord();
     }
+
+    @action removeCustomFieldFile(customFieldValue, file) {
+        customFieldValue.set('value', null);
+        customFieldValue.save().then(() => {
+            return file.destroyRecord();
+        });
+    }
 }

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

@@ -491,7 +491,7 @@ export default class OperationsOrdersIndexController extends BaseController {
         },
         {
             label: this.intl.t('fleet-ops.common.created-at'),
-            valuePath: 'createdAt',
+            valuePath: 'createdAtShort',
             sortParam: 'created_at',
             filterParam: 'created_at',
             width: '140px',
@@ -502,7 +502,7 @@ export default class OperationsOrdersIndexController extends BaseController {
         },
         {
             label: this.intl.t('fleet-ops.common.updated-at'),
-            valuePath: 'updatedAt',
+            valuePath: 'updatedAtShort',
             sortParam: 'updated_at',
             filterParam: 'updated_at',
             width: '125px',

package/addon/engine.js

@@ -65,7 +65,16 @@ export default class FleetOpsEngine extends Engine {
         universe.registerDashboardWidgets([KeyMetricsWidgetDefinition]);
 
         // create all registries necessary
-        universe.createRegistries(['engine:fleet-ops', 'component:vehicle-panel', 'component:driver-panel', 'contextmenu:vehicle', 'contextmenu:driver', 'view:order', 'view:create-order']);
+        universe.createRegistries([
+            'engine:fleet-ops',
+            'component:vehicle-panel',
+            'component:driver-panel',
+            'component:order-config-manager',
+            'contextmenu:vehicle',
+            'contextmenu:driver',
+            'fleet-ops:template:operations:orders:view',
+            'fleet-ops:template:operations:orders:new',
+        ]);
     };
 }
 

package/addon/initializers/load-jointjs.js

@@ -0,0 +1,16 @@
+export function initialize() {
+    // Add jointjs script
+    const jointJsScript = document.createElement('script');
+    jointJsScript.src = '/engines-dist/joint.min.js';
+    document.body.appendChild(jointJsScript);
+
+    // Add jointjs directed graph lib
+    const jointJsDirectedGraphScript = document.createElement('script');
+    jointJsDirectedGraphScript.src = '/engines-dist/DirectedGraph.min.js';
+    document.body.appendChild(jointJsDirectedGraphScript);
+}
+
+export default {
+    initialize,
+    after: 'load-leaflet-assets',
+};

package/addon/routes/application.js

@@ -17,7 +17,7 @@ export default class ApplicationRoute extends Route {
     }
 
     beforeModel() {
-        return this.location.getUserLocation();
+        this.location.getUserLocation();
     }
 
     model() {

package/addon/routes/operations/order-config.js

@@ -0,0 +1,28 @@
+import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+
+export default class OperationsOrderConfigRoute extends Route {
+    @service loader;
+
+    queryParams = {
+        config: {
+            refreshModel: true,
+        },
+        tab: {
+            refreshModel: false,
+        },
+        context: {
+            refreshModel: false,
+        },
+        contextModel: {
+            refreshModel: false,
+        },
+    };
+
+    @action loading(transition) {
+        this.loader.showOnInitialTransition(transition, 'section.next-view-section', {
+            loadingMessage: this.intl.t('fleet-ops.operations.order-config.route-loading-message'),
+        });
+    }
+}

package/addon/routes/operations/orders/index/new.js

@@ -3,8 +3,7 @@ import { inject as service } from '@ember/service';
 import { action } from '@ember/object';
 
 export default class OperationsOrdersIndexNewRoute extends Route {
-    @service currentUser;
-    @service loader;
+    @service store;
 
     @action willTransition() {
         if (this.controller) {
@@ -13,6 +12,6 @@ export default class OperationsOrdersIndexNewRoute extends Route {
     }
 
     async setupController(controller) {
-        controller.types = await this.currentUser.getInstalledOrderConfigs();
+        controller.orderConfigs = await this.store.findAll('order-config');
     }
 }

package/addon/routes/operations/orders/index/view.js

@@ -29,7 +29,7 @@ export default class OperationsOrdersIndexViewRoute extends Route {
         return this.store.queryRecord('order', {
             public_id,
             single: true,
-            with: ['payload', 'driverAssigned', 'customer', 'facilitator', 'trackingStatuses', 'trackingNumber', 'purchaseRate', 'comments', 'files'],
+            with: ['payload', 'driverAssigned', 'orderConfig', 'customer', 'facilitator', 'trackingStatuses', 'trackingNumber', 'purchaseRate', 'comments', 'files'],
         });
     }
 

package/addon/routes.js

@@ -5,6 +5,7 @@ export default buildRoutes(function () {
     this.route('operations', { path: '/' }, function () {
         this.route('dispatch');
         this.route('zones', function () {});
+        this.route('order-config', function () {});
         this.route('service-rates', function () {
             this.route('index', { path: '/' }, function () {
                 this.route('new');