@fleetbase/fleetops-engine 0.0.1

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

@@ -0,0 +1,110 @@
+import Controller from '@ember/controller';
+import { inject as service } from '@ember/service';
+import { computed, action } from '@ember/object';
+import { format, isValid as isValidDate } from 'date-fns';
+
+export default class OperationsSchedulerIndexController extends Controller {
+    @service modalsManager;
+    @service notifications;
+
+    @computed('model.@each.scheduled_at') get scheduledOrders() {
+        return this.model.filter((order) => isValidDate(order.scheduled_at));
+    }
+
+    @computed('model.@each.scheduled_at') get unscheduledOrders() {
+        return this.model.filter((order) => !order.scheduled_at);
+    }
+
+    @computed('scheduledOrders.@each.scheduled_at') get events() {
+        return this.scheduledOrders.map((order) => ({
+            id: order.id,
+            title: `${order.scheduledAtTime} - ${order.public_id}`,
+            start: order.scheduled_at,
+            allDay: true,
+        }));
+    }
+
+    @action viewEvent(order, eventClickInfo) {
+        const { event } = eventClickInfo;
+
+        this.modalsManager.show('modals/order-event', {
+            title: `Scheduling for ${order.public_id}`,
+            acceptButtonText: 'Save Changes',
+            acceptButtonIcon: 'save',
+            hideDeclineButton: true,
+            order,
+            reschedule: (date) => {
+                if (typeof date?.toDate === 'function') {
+                    date = date.toDate();
+                }
+
+                order.set('scheduled_at', date);
+            },
+            unschedule: () => {
+                order.set('scheduled_at', null);
+            },
+            confirm: (modal) => {
+                modal.startLoading();
+
+                if (!order.get('hasDirtyAttributes')) {
+                    return modal.done();
+                }
+
+                return order.save().then((order) => {
+                    this.notifications.success(`'${order.public_id}' has been updated.`);
+
+                    // update event props
+                    event?.setProp('title', order.eventTitle);
+
+                    // remove event from calendar if unscheduled
+                    if (!order.scheduled_at || !isValidDate(order.scheduled_at)) {
+                        event.remove();
+                    }
+                });
+            },
+        });
+    }
+
+    @action viewOrderAsEvent(eventClickInfo) {
+        const { event } = eventClickInfo;
+        const order = this.store.peekRecord('order', event.id);
+
+        this.viewEvent(order, eventClickInfo);
+    }
+
+    @action scheduleEventFromDrop(dropInfo) {
+        const { draggedEl, date } = dropInfo;
+        const { dataset } = draggedEl;
+        const { event } = dataset;
+        const data = JSON.parse(event);
+        const order = this.store.peekRecord('order', data.id);
+
+        order.set('scheduled_at', date);
+        order.save();
+    }
+
+    @action receivedEvent(eventReceivedInfo) {
+        const { event } = eventReceivedInfo;
+        const order = this.store.peekRecord('order', event.id);
+
+        // update event props
+        event?.setProp('title', order.eventTitle);
+    }
+
+    @action rescheduleEventFromDrag(eventDropInfo) {
+        const { event } = eventDropInfo;
+        const { start } = event;
+        const order = this.store.peekRecord('order', event.id);
+
+        // retain time, only change date
+        const scheduledTime = order.scheduledAtTime;
+        const newDate = new Date(`${format(start, 'PP')} ${scheduledTime}`);
+
+        // set and save order props
+        order.set('scheduled_at', isValidDate(newDate) ? newDate : start);
+        order.save();
+
+        // update event props
+        event?.setProp('title', order.eventTitle);
+    }
+}

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

@@ -0,0 +1,59 @@
+import OperationsServiceRatesIndexNewController from './new';
+import { tracked } from '@glimmer/tracking';
+import { action } from '@ember/object';
+// import { alias } from '@ember/object/computed';
+
+export default class OperationsServiceRatesIndexEditController extends OperationsServiceRatesIndexNewController {
+    /**
+     * True if updating service rate.
+     *
+     * @var {Boolean}
+     */
+    @tracked isUpdatingServiceRate = false;
+
+    // @alias('@model.rate_fees') rateFees;
+    // @alias('@model.parcel_fees') parcelFees;
+
+    /**
+     * Updates the service rate to server
+     *
+     * @void
+     */
+    @action updateServiceRate() {
+        const { serviceRate, rateFees, perDropRateFees, parcelFees } = this;
+
+        if (serviceRate.isFixedMeter) {
+            serviceRate.setServiceRateFees(rateFees);
+        }
+
+        if (serviceRate.isPerDrop) {
+            serviceRate.setServiceRateFees(perDropRateFees);
+        }
+
+        if (serviceRate.isParcelService) {
+            serviceRate.setServiceRateParcelFees(parcelFees);
+        }
+
+        this.isUpdatingServiceRate = true;
+        this.loader.showLoader('.overlay-inner-content', 'Updating service rate...');
+
+        try {
+            return serviceRate
+                .save()
+                .then((serviceRate) => {
+                    return this.transitionToRoute('operations.service-rates.index').then(() => {
+                        this.notifications.success(`Service rate '${serviceRate.service_name}' updated`);
+                        this.resetForm();
+                    });
+                })
+                .catch(this.notifications.serverError)
+                .finally(() => {
+                    this.isUpdatingServiceRate = false;
+                    this.loader.removeLoader();
+                });
+        } catch (error) {
+            this.isUpdatingServiceRate = false;
+            this.loader.removeLoader();
+        }
+    }
+}

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

@@ -0,0 +1,369 @@
+import Controller, { inject as controller } from '@ember/controller';
+import { inject as service } from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { action, computed } from '@ember/object';
+import { isBlank } from '@ember/utils';
+
+export default class OperationsServiceRatesIndexNewController extends Controller {
+    /**
+     * Inject the `operations.service-rates.index` controller
+     *
+     * @var {Controller}
+     */
+    @controller('operations.service-rates.index') index;
+
+    /**
+     * Inject the `currentUser` service
+     *
+     * @var {Service}
+     */
+    @service store;
+
+    /**
+     * Inject the `notifications` service
+     *
+     * @var {Service}
+     */
+    @service notifications;
+
+    /**
+     * Inject the `loader` service
+     *
+     * @var {Service}
+     */
+    @service loader;
+
+    /**
+     * The service rate being created.
+     *
+     * @var {ServiceRateModel}
+     */
+    @tracked serviceRate = this.store.createRecord('service-rate');
+
+    /**
+     * Different service types available, based on order type.
+     *
+     * @var {Array}
+     */
+    @tracked serviceTypes = [];
+
+    /**
+     * Service areas.
+     *
+     * @var {Array}
+     */
+    @tracked serviceAreas = [];
+
+    /**
+     * Zones.
+     *
+     * @var {Array}
+     */
+    @tracked zones = [];
+
+    /**
+     * True if creating service rate.
+     *
+     * @var {Boolean}
+     */
+    @tracked isCreatingServiceRate = false;
+
+    /**
+     * True if updating service rate.
+     *
+     * @var {Boolean}
+     */
+    @tracked isUpdatingServiceRate = false;
+
+    /**
+     * Dimension units.
+     *
+     * @var {Array}
+     */
+    dimensionUnits = ['cm', 'in', 'ft', 'mm', 'm', 'yd'];
+
+    /**
+     * Weight units.
+     *
+     * @var {Array}
+     */
+    weightUnits = ['g', 'oz', 'lb', 'kg'];
+
+    /**
+     * Rate calculation methods
+     *
+     * @var {Array}
+     */
+    calculationMethods = [
+        { name: 'Fixed Meter', key: 'fixed_meter' },
+        { name: 'Per Meter', key: 'per_meter' },
+        { name: 'Per Drop-off', key: 'per_drop' },
+        { name: 'Algorithm', key: 'algo' },
+    ];
+
+    /**
+     * COD Fee calculation methods
+     *
+     * @var {Array}
+     */
+    codCalculationMethods = [
+        { name: 'Flat Fee', key: 'flat' },
+        { name: 'Percentage', key: 'percentage' },
+    ];
+
+    /**
+     * Peak hour fee calculation methods
+     *
+     * @var {Array}
+     */
+    peakHourCalculationMethods = [
+        { name: 'Flat Fee', key: 'flat' },
+        { name: 'Percentage', key: 'percentage' },
+    ];
+
+    /**
+     * The applicable distance units for calculation.
+     *
+     * @var {Array}
+     */
+    distanceUnits = [
+        { name: 'Meter', key: 'm' },
+        { name: 'Kilometer', key: 'km' },
+    ];
+
+    /**
+     * By km max distance set
+     *
+     * @var {String}
+     */
+    @tracked fixedMeterUnit = 'km';
+
+    /**
+     * By km max distance set
+     *
+     * @var {Integer}
+     */
+    @tracked fixedMeterMaxDistance = 5;
+
+    /**
+     * Mutable rate fee's.
+     *
+     * @var {Array}
+     */
+    @tracked _rateFees = [];
+
+    /**
+     * The rate feess for per km
+     *
+     * @var {Array}
+     */
+    @computed('fixedMeterMaxDistance', 'fixedMeterUnit', 'serviceRate.currency', '_rateFees') get rateFees() {
+        if (!isBlank(this._rateFees)) {
+            return this._rateFees;
+        }
+
+        let maxDistance = parseInt(this.fixedMeterMaxDistance ?? 0);
+        let distanceUnit = this.fixedMeterUnit;
+        let currency = this.serviceRate.currency;
+        let rateFees = [];
+
+        for (let distance = 0; distance < maxDistance; distance++) {
+            rateFees.pushObject({
+                distance,
+                distance_unit: distanceUnit,
+                fee: 0,
+                currency,
+            });
+        }
+
+        return rateFees;
+    }
+
+    /** setter for rate fee's */
+    set rateFees(rateFees) {
+        this._rateFees = rateFees;
+    }
+
+    /**
+     * Mutable per drop-off rate fee's.
+     *
+     * @var {Array}
+     */
+    @tracked perDropRateFees = this.serviceRate.isNew
+        ? [
+              {
+                  min: 1,
+                  max: 5,
+                  fee: 0,
+                  unit: 'waypoint',
+                  currency: this.serviceRate.currency,
+              },
+          ]
+        : this.serviceRate.rate_fees.toArray();
+
+    /**
+     * Default parcel fee's
+     *
+     * @var {Array}
+     */
+    @tracked parcelFees = [
+        {
+            size: 'small',
+            length: 34,
+            width: 18,
+            height: 10,
+            dimensions_unit: 'cm',
+            weight: 2,
+            weight_unit: 'kg',
+            fee: 0,
+            currency: this.serviceRate.currency,
+        },
+        {
+            size: 'medium',
+            length: 34,
+            width: 32,
+            height: 10,
+            dimensions_unit: 'cm',
+            weight: 4,
+            weight_unit: 'kg',
+            fee: 0,
+            currency: this.serviceRate.currency,
+        },
+        {
+            size: 'large',
+            length: 34,
+            width: 32,
+            height: 18,
+            dimensions_unit: 'cm',
+            weight: 8,
+            weight_unit: 'kg',
+            fee: 0,
+            currency: this.serviceRate.currency,
+        },
+        {
+            size: 'x-large',
+            length: 34,
+            width: 32,
+            height: 34,
+            dimensions_unit: 'cm',
+            weight: 13,
+            weight_unit: 'kg',
+            fee: 0,
+            currency: this.serviceRate.currency,
+        },
+    ];
+
+    /**
+     * Adds a per drop-off rate fee
+     */
+    @action addPerDropoffRateFee() {
+        const rateFees = this.perDropRateFees;
+        const currency = this.serviceRate.currency;
+
+        const min = rateFees.lastObject?.max ? rateFees.lastObject?.max + 1 : 1;
+        const max = min + 5;
+
+        rateFees.pushObject({
+            min: min,
+            max: max,
+            unit: 'waypoint',
+            fee: 0,
+            currency,
+        });
+    }
+
+    /**
+     * Adds a per drop-off rate fee
+     */
+    @action removePerDropoffRateFee(index) {
+        this.perDropRateFees.removeAt(index);
+    }
+
+    /**
+     * Saves the service rate to server
+     *
+     * @void
+     */
+    @action createServiceRate() {
+        const { serviceRate, rateFees, parcelFees } = this;
+
+        serviceRate.setServiceRateFees(rateFees).setServiceRateParcelFees(parcelFees);
+
+        if (serviceRate.isPerDrop) {
+            serviceRate.clearServiceRateFees().setServiceRateFees(this.perDropRateFees);
+        }
+
+        this.isCreatingServiceRate = true;
+        this.loader.showLoader('.overlay-inner-content', 'Creating service rate...');
+
+        try {
+            return serviceRate
+                .save()
+                .then((serviceRate) => {
+                    this.index.table.addRow(serviceRate);
+
+                    return this.transitionToRoute('operations.service-rates.index').then(() => {
+                        this.notifications.success(`New Service Rate ${serviceRate.service_name} Created`);
+                        this.resetForm();
+                    });
+                })
+                .catch((error) => {
+                    this.notifications.serverError(error);
+                })
+                .finally(() => {
+                    this.isCreatingServiceRate = false;
+                    this.loader.removeLoader();
+                });
+        } catch (error) {
+            this.isCreatingServiceRate = false;
+            this.loader.removeLoader();
+        }
+    }
+
+    /**
+     * Select a service area and load it's zones
+     *
+     * @param {String} serviceAreaId
+     * @memberof OperationsServiceRatesIndexNewController
+     */
+    @action selectServiceArea(serviceAreaId) {
+        if (typeof serviceAreaId === 'string' && !isBlank(serviceAreaId)) {
+            this.serviceRate.service_area_uuid = serviceAreaId;
+
+            // load zones for this service area
+            this.store.query('zone', { service_area_uuid: serviceAreaId }).then((zones) => {
+                this.zones = zones;
+            });
+        } else {
+            this.zones = [];
+        }
+    }
+
+    /**
+     * Resets the service rate form
+     *
+     * @void
+     */
+    @action resetForm() {
+        this.serviceRate = this.store.createRecord('service-rate');
+        this.byKmMaxDistance = 5;
+        this.rateFees = this.rateFees.map((rateFee) => ({ ...rateFee, fee: 0 }));
+        this.parcelFees = this.parcelFees.map((parcelFee) => ({
+            ...parcelFee,
+            fee: 0,
+            dimensions_unit: 'cm',
+            weight_unit: 'kg',
+        }));
+    }
+
+    /**
+     * Handle back button action
+     *
+     * @return {Transition}
+     */
+    @action transitionBack() {
+        return this.transitionToRoute('operations.service-rates.index').then(() => {
+            this.resetForm();
+        });
+    }
+}