@fleetbase/ember-core 0.0.1

package/addon/utils/download.js

@@ -0,0 +1,157 @@
+export default function download(data, strFileName, strMimeType) {
+    var self = window, // this script is only for browsers anyway...
+        defaultMime = 'application/octet-stream', // this default mime also triggers iframe downloads
+        mimeType = strMimeType || defaultMime,
+        payload = data,
+        url = !strFileName && !strMimeType && payload,
+        anchor = document.createElement('a'),
+        toString = function (a) {
+            return String(a);
+        },
+        myBlob = self.Blob || self.MozBlob || self.WebKitBlob || toString,
+        fileName = strFileName || 'download',
+        blob,
+        reader;
+    myBlob = myBlob.call ? myBlob.bind(self) : Blob;
+
+    if (String(this) === 'true') {
+        //reverse arguments, allowing download.bind(true, "text/xml", "export.xml") to act as a callback
+        payload = [payload, mimeType];
+        mimeType = payload[0];
+        payload = payload[1];
+    }
+
+    if (url && url.length < 2048) {
+        // if no filename and no mime, assume a url was passed as the only argument
+        fileName = url.split('/').pop().split('?')[0];
+        anchor.href = url; // assign href prop to temp anchor
+        if (anchor.href.indexOf(url) !== -1) {
+            // if the browser determines that it's a potentially valid url path:
+            var ajax = new XMLHttpRequest();
+            ajax.open('GET', url, true);
+            ajax.responseType = 'blob';
+            ajax.onload = function (e) {
+                download(e.target.response, fileName, defaultMime);
+            };
+            setTimeout(function () {
+                ajax.send();
+            }, 0); // allows setting custom ajax headers using the return:
+            return ajax;
+        } // end if valid url?
+    } // end if url?
+
+    //go ahead and download dataURLs right away
+    if (/^data:([\w+-]+\/[\w+.-]+)?[,;]/.test(payload)) {
+        if (payload.length > 1024 * 1024 * 1.999 && myBlob !== toString) {
+            payload = dataUrlToBlob(payload);
+            mimeType = payload.type || defaultMime;
+        } else {
+            return navigator.msSaveBlob // IE10 can't do a[download], only Blobs:
+                ? navigator.msSaveBlob(dataUrlToBlob(payload), fileName)
+                : saver(payload); // everyone else can save dataURLs un-processed
+        }
+    } else {
+        //not data url, is it a string with special needs?
+        if (/([\x80-\xff])/.test(payload)) {
+            var i = 0,
+                tempUiArr = new Uint8Array(payload.length),
+                mx = tempUiArr.length;
+            for (i; i < mx; ++i) tempUiArr[i] = payload.charCodeAt(i);
+            payload = new myBlob([tempUiArr], { type: mimeType });
+        }
+    }
+    blob = payload instanceof myBlob ? payload : new myBlob([payload], { type: mimeType });
+
+    function dataUrlToBlob(strUrl) {
+        var parts = strUrl.split(/[:;,]/),
+            type = parts[1],
+            indexDecoder = strUrl.indexOf('charset') > 0 ? 3 : 2,
+            decoder = parts[indexDecoder] == 'base64' ? atob : decodeURIComponent,
+            binData = decoder(parts.pop()),
+            mx = binData.length,
+            i = 0,
+            uiArr = new Uint8Array(mx);
+
+        for (i; i < mx; ++i) uiArr[i] = binData.charCodeAt(i);
+
+        return new myBlob([uiArr], { type: type });
+    }
+
+    function saver(url, winMode) {
+        if ('download' in anchor) {
+            //html5 A[download]
+            anchor.href = url;
+            anchor.setAttribute('download', fileName);
+            anchor.className = 'download-js-link';
+            anchor.innerHTML = 'downloading...';
+            anchor.style.display = 'none';
+            anchor.addEventListener('click', function (e) {
+                e.stopPropagation();
+                this.removeEventListener('click', arguments.callee);
+            });
+            document.body.appendChild(anchor);
+            setTimeout(function () {
+                anchor.click();
+                document.body.removeChild(anchor);
+                if (winMode === true) {
+                    setTimeout(function () {
+                        self.URL.revokeObjectURL(anchor.href);
+                    }, 250);
+                }
+            }, 66);
+            return true;
+        }
+
+        // handle non-a[download] safari as best we can:
+        if (/(Version)\/(\d+)\.(\d+)(?:\.(\d+))?.*Safari\//.test(navigator.userAgent)) {
+            if (/^data:/.test(url)) url = 'data:' + url.replace(/^data:([\w\/\-\+]+)/, defaultMime);
+            if (!window.open(url)) {
+                // popup blocked, offer direct download:
+                if (confirm('Displaying New Document\n\nUse Save As... to download, then click back to return to this page.')) {
+                    location.href = url;
+                }
+            }
+            return true;
+        }
+
+        //do iframe dataURL download (old ch+FF):
+        var f = document.createElement('iframe');
+        document.body.appendChild(f);
+
+        if (!winMode && /^data:/.test(url)) {
+            // force a mime that will download:
+            url = 'data:' + url.replace(/^data:([\w\/\-\+]+)/, defaultMime);
+        }
+        f.src = url;
+        setTimeout(function () {
+            document.body.removeChild(f);
+        }, 333);
+    } //end saver
+
+    if (navigator.msSaveBlob) {
+        // IE10+ : (has Blob, but not a[download] or URL)
+        return navigator.msSaveBlob(blob, fileName);
+    }
+
+    if (self.URL) {
+        // simple fast and modern way using Blob and URL:
+        saver(self.URL.createObjectURL(blob), true);
+    } else {
+        // handle non-Blob()+non-URL browsers:
+        if (typeof blob === 'string' || blob.constructor === toString) {
+            try {
+                return saver('data:' + mimeType + ';base64,' + self.btoa(blob));
+            } catch (y) {
+                return saver('data:' + mimeType + ',' + encodeURIComponent(blob));
+            }
+        }
+
+        // Blob but not URL support:
+        reader = new FileReader();
+        reader.onload = function (e) {
+            saver(this.result);
+        };
+        reader.readAsDataURL(blob);
+    }
+    return true;
+}

package/addon/utils/env.js

@@ -0,0 +1,3 @@
+export default function env(variable, defaultValue = null) {
+    return process.env[variable] !== undefined ? process.env[variable] : defaultValue;
+}

package/addon/utils/extract-coordinates.js

@@ -0,0 +1,35 @@
+import isLatitude from './is-latitude';
+import isLongitude from './is-longitude';
+
+export default function extractCoordinates(coordinates = [], format = 'latlng') {
+    let latitude = null,
+        longitude = null;
+
+    for (let i = 0; i < coordinates.length; i++) {
+        let coord = coordinates[i];
+
+        if (isLatitude(coord) && latitude === null) {
+            latitude = coord;
+            continue;
+        }
+
+        if (isLongitude(coord) && longitude === null) {
+            longitude = coord;
+            continue;
+        }
+    }
+
+    if (latitude === null) {
+        latitude = 0;
+    }
+
+    if (longitude === null) {
+        latitude = 0;
+    }
+
+    if (format === 'lnglat') {
+        return [longitude, latitude];
+    }
+
+    return [latitude, longitude];
+}

package/addon/utils/extract-latitude.js

@@ -0,0 +1,28 @@
+/* eslint-disable no-unused-vars */
+import extractCoordinates from './extract-coordinates';
+import Terraformer from 'terraformer';
+import { isArray } from '@ember/array';
+
+export default function extractLatitude(position) {
+    let latitude, longitude;
+
+    if (!position) {
+        return 0;
+    }
+
+    if (position instanceof Terraformer.Point || isArray(position.coordinates)) {
+        [latitude, longitude] = extractCoordinates(position.coordinates);
+
+        return latitude;
+    }
+
+    if (typeof position === 'object') {
+        let latitude = position['lat'] || position['latitude'] || position['x'];
+
+        return latitude;
+    }
+
+    [latitude, longitude] = extractCoordinates(position);
+
+    return latitude;
+}

package/addon/utils/extract-longitude.js

@@ -0,0 +1,28 @@
+/* eslint-disable no-unused-vars */
+import extractCoordinates from './extract-coordinates';
+import Terraformer from 'terraformer';
+import { isArray } from '@ember/array';
+
+export default function extractLongitude(position) {
+    let latitude, longitude;
+
+    if (!position) {
+        return 0;
+    }
+
+    if (position instanceof Terraformer.Point || isArray(position.coordinates)) {
+        [latitude, longitude] = extractCoordinates(position.coordinates);
+
+        return longitude;
+    }
+
+    if (typeof position === 'object') {
+        let longitude = position['lng'] || position['longitude'] || position['lon'] || position['y'];
+
+        return longitude;
+    }
+
+    [latitude, longitude] = extractCoordinates(position);
+
+    return longitude;
+}

package/addon/utils/find-closest-waypoint.js

@@ -0,0 +1,20 @@
+import haversine from './haversine';
+import { get } from '@ember/object';
+
+export default function findClosestWaypoint(latitude, longitude, waypoints = []) {
+    let distances = [];
+
+    for (let i = 0; i < waypoints.length; i++) {
+        let waypoint = waypoints.objectAt(i);
+        let distance = haversine({ latitude, longitude }, waypoint.place.get('latitudelongitude'));
+
+        distances.pushObject({
+            distance,
+            waypoint,
+        });
+    }
+
+    distances = distances.sortBy('distance');
+
+    return get(distances, 'firstObject.waypoint');
+}

package/addon/utils/first.js

@@ -0,0 +1,10 @@
+import { isArray } from '@ember/array';
+
+export default function first(arr, n = 1) {
+    if (!isArray(arr) || arr.length === 0 || n <= 0) {
+        return null;
+    }
+
+    n = Math.min(n, arr.length);
+    return n > 1 ? arr.slice(0, n) : arr[0];
+}

package/addon/utils/frontend-url.js

@@ -0,0 +1,30 @@
+import config from '@fleetbase/console/config/environment';
+import { isBlank } from '@ember/utils';
+
+const queryString = (params) =>
+    Object.keys(params)
+        .map((key) => `${key}=${params[key]}`)
+        .join('&');
+
+export default function frontendUrl(path = '', queryParams = {}) {
+    let url = 'https://';
+    let urlParams = !isBlank(queryParams) ? queryString(queryParams) : '';
+
+    if (['qa', 'staging'].includes(config.environment)) {
+        url += `${config.environment}.`;
+    }
+
+    if (['local', 'development'].includes(config.environment)) {
+        url += 'fleetbase.dev';
+    } else {
+        url += 'fleetbase.io';
+    }
+
+    url += `/${path}`;
+
+    if (urlParams) {
+        url += `?${urlParams}`;
+    }
+
+    return url;
+}

package/addon/utils/generate-slug.js

@@ -0,0 +1,11 @@
+export default function generateSlug(length = 12) {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    let slug = '';
+
+    for (let i = 0; i < length; i++) {
+        const index = Math.floor(Math.random() * chars.length);
+        slug += chars[index];
+    }
+
+    return slug;
+}

package/addon/utils/generate-uuid.js

@@ -0,0 +1,3 @@
+export default function generateUuid() {
+    return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c) => (c ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16));
+}

package/addon/utils/get-length-units.js

@@ -0,0 +1,44 @@
+export default function getLengthUnits() {
+    return [
+        {
+            name: 'Meter',
+            value: 'm',
+        },
+        {
+            name: 'Millimeter',
+            value: 'mm',
+        },
+        {
+            name: 'Centimeter',
+            value: 'cm',
+        },
+        {
+            name: 'Decimeter',
+            value: 'dm',
+        },
+        {
+            name: 'Kilometer',
+            value: 'km',
+        },
+        {
+            name: 'Inch',
+            value: 'in',
+        },
+        {
+            name: 'Foot',
+            value: 'ft',
+        },
+        {
+            name: 'Yard',
+            value: 'yd',
+        },
+        {
+            name: 'Astonomical Unit',
+            value: 'AE',
+        },
+        {
+            name: 'Light Year',
+            value: 'lj',
+        },
+    ];
+}

package/addon/utils/get-meta-field-types.js

@@ -0,0 +1,3 @@
+export default function getMetaFieldTypes() {
+    return true;
+}

package/addon/utils/get-mime-type.js

@@ -0,0 +1,25 @@
+export default function getMimeType(fileName) {
+    const map = {
+        pdf: 'application/pdf',
+        zip: 'application/zip',
+        doc: 'application/msword',
+        xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        png: 'image/png',
+        jpeg: 'image/jpg',
+        jpg: 'image/jpg',
+        csv: 'text/csv',
+    };
+
+    const extensions = Object.keys(map);
+
+    for (let index = 0; index < extensions.length; index++) {
+        const ext = extensions.objectAt(index);
+
+        if (fileName.endsWith(ext)) {
+            return ext;
+        }
+    }
+
+    return null;
+}

package/addon/utils/get-model-name.js

@@ -0,0 +1,45 @@
+import { get } from '@ember/object';
+import { isArray } from '@ember/array';
+import { isBlank } from '@ember/utils';
+import { w, capitalize } from '@ember/string';
+import isModel from './is-model';
+import humanize from './humanize';
+
+export default function getModelName(model, fallback = null, options = {}) {
+    let modelName;
+
+    if (isArray(fallback)) {
+        for (let i = 0; i < fallback.length; i++) {
+            const defaultValue = fallback.objectAt(i);
+
+            if (!isBlank(defaultValue)) {
+                modelName = defaultValue;
+                break;
+            }
+        }
+    } else {
+        modelName = fallback;
+    }
+
+    if (isModel(model)) {
+        modelName = get(model, 'constructor.modelName') ?? get(model, '_internalModel.modelName') ?? fallback;
+    }
+
+    if (options.humanize === true) {
+        modelName = humanize(modelName);
+    }
+
+    if (options.lowercase === true) {
+        modelName = modelName.toLowerCase();
+    }
+
+    if (options.capitalize === true) {
+        modelName = capitalize(modelName);
+    }
+
+    if (options.capitalizeWords === true) {
+        modelName = w(modelName).map(capitalize).join(' ');
+    }
+
+    return modelName;
+}

package/addon/utils/get-permission-action.js

@@ -0,0 +1,47 @@
+import { classify } from '@ember/string';
+
+export default function getPermissionAction(permissionName) {
+    const permissionNameParts = permissionName.split(':');
+    const fullActionName = permissionNameParts.lastObject;
+    const actions = [
+        'create',
+        'update',
+        'delete',
+        'deactivate',
+        'get',
+        'list',
+        'cancel',
+        'optimize',
+        'roll',
+        'export',
+        'batch_delete',
+        'batch_cancel',
+        'notify',
+        'assign_vehicle',
+        'assign_order_to',
+        'dispatch_order_to',
+        'dispatch',
+        'assign',
+        'attach',
+        'sub_contract',
+        'create_order_for',
+    ];
+
+    if (permissionName.startsWith('auth')) {
+        return fullActionName;
+    }
+
+    if (fullActionName === '*') {
+        return 'All';
+    }
+
+    for (let i = 0; i < actions.length; i++) {
+        const action = actions.objectAt(i);
+
+        if (fullActionName.toLowerCase().startsWith(classify(action).toLowerCase())) {
+            return classify(action);
+        }
+    }
+
+    return 'N/A';
+}

package/addon/utils/get-permission-resource.js

@@ -0,0 +1,16 @@
+import getPermissionAction from './get-permission-action';
+import { classify } from '@ember/string';
+import { singularize } from 'ember-inflector';
+
+export default function getPermissionResource(permissionName = '') {
+    if (permissionName.startsWith('auth')) {
+        return 'N/A';
+    }
+
+    const permissionNameParts = permissionName.split(':');
+    const fullActionName = permissionNameParts.lastObject;
+    const actionName = getPermissionAction(permissionName);
+    const resourceName = fullActionName.replace(actionName, '');
+
+    return singularize(classify(resourceName));
+}

package/addon/utils/get-pod-methods.js

@@ -0,0 +1,7 @@
+export default function getPodMethods() {
+    return [
+        { name: 'None', value: null },
+        { name: 'QR Code Scan', value: 'scan' },
+        { name: 'Signature', value: 'signature' },
+    ];
+}

package/addon/utils/get-routing-host.js

@@ -0,0 +1,44 @@
+import { get } from '@ember/object';
+import { isArray } from '@ember/array';
+import { isBlank } from '@ember/utils';
+// import { getOwner } from '@ember/application';
+import config from '@fleetbase/console/config/environment';
+
+const isRoutingInCountry = (country, payload, waypoints = []) => {
+    // const owner = getOwner(this);
+    // const currentUser = owner.lookup(`service:current-user`);
+    // const whois = currentUser.getOption('whois');
+
+    if (isBlank(payload)) {
+        payload = {};
+    }
+
+    let countryCode = null;
+
+    if (get(payload, 'pickup.country') === country || get(payload, 'dropoff.country') === country) {
+        countryCode = country;
+    }
+
+    if (isArray(waypoints) && !isBlank(waypoints?.firstObject) && get(waypoints?.firstObject, 'place.country') === country) {
+        countryCode = country;
+    }
+
+    return countryCode === country;
+};
+
+export { isRoutingInCountry };
+
+export default function getRoutingHost(payload, waypoints = []) {
+    const isRoutingInCanada = isRoutingInCountry('CA', payload, waypoints);
+    const isRoutingInUSA = isRoutingInCountry('US', payload, waypoints);
+
+    if (isRoutingInCanada && typeof config.osrm?.servers?.ca === 'string') {
+        return config.osrm.servers.ca;
+    }
+
+    if (isRoutingInUSA && typeof config.osrm?.servers?.us === 'string') {
+        return config.osrm.servers.us;
+    }
+
+    return config.osrm.host;
+}

package/addon/utils/get-service-name.js

@@ -0,0 +1,21 @@
+// import { classify } from '@ember/string';
+
+export default function getServiceName(serviceName) {
+    if (serviceName.toLowerCase().startsWith('fleet')) {
+        return 'Fleet Ops';
+    }
+
+    if (serviceName.toLowerCase().startsWith('iam') || serviceName.toLowerCase().startsWith('identity')) {
+        return 'IAM';
+    }
+
+    if (serviceName.toLowerCase().startsWith('auth')) {
+        return 'Auth';
+    }
+
+    if (serviceName === 'developers' || serviceName.toLowerCase().startsWith('developers')) {
+        return 'Developers Console';
+    }
+
+    return 'N/A';
+}

package/addon/utils/get-user-options.js

@@ -0,0 +1,21 @@
+/**
+ * Retrieves user options from local storage.
+ *
+ * Attempts to read the user options stored in local storage as a JSON string under the key
+ * USER_OPTIONS_STORAGE_KEY. If the JSON parsing fails, an empty object is returned.
+ *
+ * @returns {Object} The user options as an object, or an empty object if no valid user options were found.
+ * @throws Will not throw an error, even if JSON parsing fails. Errors are silently caught and ignored.
+ */
+export default function getUserOptions() {
+    const USER_OPTIONS_STORAGE_KEY = '@fleetbase/storage:user-options';
+
+    try {
+        const storedValue = window.localStorage.getItem(USER_OPTIONS_STORAGE_KEY);
+        return storedValue ? JSON.parse(storedValue) : {};
+    } catch (error) {
+        // For debugging purposes, you can log the error (optional)
+        // console.error('Failed to parse user options from local storage:', error);
+        return {};
+    }
+}

package/addon/utils/get-weight-units.js

@@ -0,0 +1,32 @@
+export default function getWeightUnits() {
+    return [
+        {
+            name: 'Grams',
+            value: 'g',
+        },
+        {
+            name: 'Kilograms',
+            value: 'kg',
+        },
+        {
+            name: 'Grain',
+            value: 'gr',
+        },
+        {
+            name: 'Dram',
+            value: 'dr',
+        },
+        {
+            name: 'Ounce',
+            value: 'oz',
+        },
+        {
+            name: 'Pound',
+            value: 'lb',
+        },
+        {
+            name: 'Tonne',
+            value: 't',
+        },
+    ];
+}

package/addon/utils/get-with-default.js

@@ -0,0 +1,6 @@
+import { get } from '@ember/object';
+
+export default function getWithDefault(obj, key, defaultValue) {
+    let value = get(obj, key);
+    return value === undefined ? defaultValue : value;
+}