@fleetbase/ember-core 0.0.1

package/addon/services/crud.js

@@ -0,0 +1,226 @@
+import Service from '@ember/service';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+import { isArray } from '@ember/array';
+import { dasherize } from '@ember/string';
+import { pluralize } from 'ember-inflector';
+import { format as formatDate } from 'date-fns';
+import getModelName from '../utils/get-model-name';
+import humanize from '../utils/humanize';
+import first from '../utils/first';
+
+export default class CrudService extends Service {
+    /**
+     * Inject the `fetch` service
+     *
+     * @var {Service}
+     */
+    @service fetch;
+
+    /**
+     * Inject the `modalsManager` service
+     *
+     * @var {Service}
+     */
+    @service modalsManager;
+
+    /**
+     * Inject the `notifications` service
+     *
+     * @var {Service}
+     */
+    @service notifications;
+
+    /**
+     * Inject the `store` service
+     *
+     * @var {Service}
+     */
+    @service store;
+
+    /**
+     * Generic deletion modal with options
+     *
+     * @param {Model} model
+     * @param {Object} options
+     * @void
+     */
+    @action delete(model, options = {}) {
+        const modelName = getModelName(model, options?.modelName, { humanize: true, capitalizeWords: true });
+
+        this.modalsManager.confirm({
+            title: `Are you sure to delete this ${modelName}?`,
+            args: ['model'],
+            model,
+            confirm: (modal) => {
+                if (typeof options.onConfirm === 'function') {
+                    options.onConfirm(model);
+                }
+
+                modal.startLoading();
+
+                return model
+                    .destroyRecord()
+                    .then((model) => {
+                        this.notifications.success(options.successNotification || `${model.name ? modelName + " '" + model.name + "'" : "'" + modelName + "'"} has been deleted.`);
+                        if (typeof options.onSuccess === 'function') {
+                            options.onSuccess(model);
+                        }
+                    })
+                    .catch((error) => {
+                        this.notifications.serverError(error);
+
+                        if (typeof options.onError === 'function') {
+                            options.onError(error, model);
+                        }
+                    })
+                    .finally(() => {
+                        if (typeof options.callback === 'function') {
+                            options.callback(model);
+                        }
+                    });
+            },
+            ...options,
+        });
+    }
+
+    /**
+     * Generic deletion modal with options
+     *
+     * @param {Array} selected an array of selected models for deletion
+     * @param {Object} options
+     * @void
+     */
+    @action bulkDelete(selected, options = {}) {
+        if (!isArray(selected) || selected.length === 0) {
+            return;
+        }
+
+        const firstModel = first(selected);
+        const modelName = getModelName(firstModel, options?.modelName, { humanize: true, capitalizeWords: true });
+
+        // make sure all are the same type
+        selected = selected.filter((m) => getModelName(m) === getModelName(firstModel));
+
+        return this.bulkAction('delete', selected, {
+            acceptButtonScheme: 'danger',
+            acceptButtonIcon: 'trash',
+            actionPath: `${dasherize(pluralize(modelName))}/bulk-delete`,
+            actionMethod: `DELETE`,
+            modelName,
+            ...options,
+        });
+    }
+
+    /**
+     * Generic bulk action on multiple models modal with options
+     *
+     * @param {Array} selected an array of selected models for deletion
+     * @param {Object} options
+     * @void
+     */
+    @action bulkAction(verb, selected, options = {}) {
+        if (!isArray(selected) || selected.length === 0) {
+            return;
+        }
+
+        const firstModel = first(selected);
+        const modelName = getModelName(firstModel, options?.modelName, { humanize: true, capitalizeWords: true });
+        const count = selected.length;
+        const actionMethod = (typeof options.actionMethod === 'string' ? options.actionMethod : `POST`).toLowerCase();
+
+        this.modalsManager.show('modals/bulk-action-model', {
+            title: `Bulk ${verb} ${pluralize(modelName)}`,
+            acceptButtonText: humanize(verb),
+            args: ['selected'],
+            modelNamePath: 'name',
+            verb,
+            selected,
+            count,
+            modelName,
+            remove: (model) => {
+                selected.removeObject(model);
+                this.modalsManager.setOption('selected', selected);
+            },
+            confirm: (modal) => {
+                const selected = modal.getOption('selected');
+
+                if (typeof options.onConfirm === 'function') {
+                    options.onConfirm(selected);
+                }
+
+                modal.startLoading();
+
+                return this.fetch[actionMethod](options.actionPath, {
+                    ids: selected.map((model) => model.id),
+                })
+                    .then((response) => {
+                        this.notifications.success(response.message ?? options.successNotification ?? `${count} ${pluralize(modelName, count)} were updated successfully.`);
+
+                        if (typeof options.onSuccess === 'function') {
+                            options.onSuccess(selected);
+                        }
+                    })
+                    .catch((error) => {
+                        this.notifications.serverError(error);
+
+                        if (typeof options.onError === 'function') {
+                            options.onError(error, selected);
+                        }
+                    })
+                    .finally(() => {
+                        if (typeof options.callback === 'function') {
+                            options.callback(selected);
+                        }
+                    });
+            },
+            ...options,
+        });
+    }
+
+    /**
+     * Toggles dialog to export resource data
+     *
+     * @void
+     */
+    @action export(modelName, options = {}) {
+        // always lowercase modelname
+        modelName = modelName.toLowerCase();
+
+        // set the model uri endpoint
+        const modelEndpoint = dasherize(pluralize(modelName));
+
+        this.modalsManager.show('modals/export-form', {
+            title: `Export ${pluralize(modelName)}`,
+            acceptButtonText: 'Download',
+            formatOptions: ['csv', 'xlsx', 'xls', 'html', 'pdf'],
+            setFormat: ({ target }) => {
+                this.modalsManager.setOption('format', target.value || null);
+            },
+            confirm: (modal, done) => {
+                const format = modal.getOption('format') || 'xlsx';
+                modal.startLoading();
+                return this.fetch
+                    .download(
+                        `${modelEndpoint}/export`,
+                        {
+                            format,
+                        },
+                        {
+                            fileName: `${modelEndpoint}-${formatDate(new Date(), 'yyyy-MM-dd-HH:mm')}.${format}`,
+                        }
+                    )
+                    .then(() => {
+                        setTimeout(() => {
+                            return done();
+                        }, 600);
+                    })
+                    .catch((error) => {
+                        modal.stopLoading();
+                        this.notifications.serverError(error, 'Unable to download API credentials export.');
+                    });
+            },
+            ...options,
+        });
+    }
+}

package/addon/services/current-user.js

@@ -0,0 +1,259 @@
+import Service from '@ember/service';
+import Evented from '@ember/object/evented';
+import { inject as service } from '@ember/service';
+import { dasherize } from '@ember/string';
+import { computed, get, action } from '@ember/object';
+import { isBlank } from '@ember/utils';
+import { alias } from '@ember/object/computed';
+import { storageFor } from 'ember-local-storage';
+
+export default class CurrentUserService extends Service.extend(Evented) {
+    /**
+     * Inject the `session` service
+     *
+     * @var {Service}
+     */
+    @service session;
+
+    /**
+     * Inject the `store` service
+     *
+     * @var {Service}
+     */
+    @service store;
+
+    /**
+     * Inject the `fetch` service
+     *
+     * @var {Service}
+     */
+    @service fetch;
+
+    /**
+     * Inject the `theme` service
+     *
+     * @var {Service}
+     */
+    @service theme;
+
+    /**
+     * Inject the `notifications` service
+     *
+     * @var {Service}
+     */
+    @service notifications;
+
+    /**
+     * User options in localStorage
+     *
+     * @var StorageObject
+     */
+    @storageFor('user-options') options;
+
+    /**
+     * Alias for current user id
+     *
+     * @var {String}
+     */
+    @alias('user.id') id;
+
+    /**
+     * Alias for current user name
+     *
+     * @var {String}
+     */
+    @alias('user.name') name;
+
+    /**
+     * Alias for current user phone
+     *
+     * @var {String}
+     */
+    @alias('user.phone') phone;
+
+    /**
+     * Alias for current user phone
+     *
+     * @var {String}
+     */
+    @alias('user.email') email;
+
+    /**
+     * Alias for current user's company id
+     *
+     * @var {String}
+     */
+    @alias('user.company_uuid') companyId;
+
+    /**
+     * Loads the current authenticated user
+     *
+     * @void
+     */
+    async load() {
+        if (this.session.isAuthenticated) {
+            let user = await this.store.findRecord('user', 'me');
+            this.set('user', user);
+            this.trigger('user.loaded', user);
+        }
+    }
+
+    /**
+     * Resolves a user model.
+     *
+     * @return {Promise}
+     */
+    @action promiseUser(options = {}) {
+        const NoUserAuthenticatedError = new Error('Failed to authenticate user.');
+
+        return new Promise((resolve, reject) => {
+            if (this.session.isAuthenticated) {
+                return this.store
+                    .queryRecord('user', { me: true })
+                    .then((user) => {
+                        // set the `current user`
+                        this.set('user', user);
+                        this.trigger('user.loaded', user);
+
+                        // set environment from user option
+                        this.theme.setEnvironment();
+
+                        // @TODO Create an event dispatch for when an authenticated user is resolved from the server
+                        if (typeof options?.onUserResolved === 'function') {
+                            options.onUserResolved(user);
+                        }
+
+                        resolve(user);
+                    })
+                    .catch((error) => {
+                        reject(NoUserAuthenticatedError);
+                    });
+            } else {
+                reject(NoUserAuthenticatedError);
+            }
+        });
+    }
+
+    /**
+     * Loads and resolved all current users installed order configurations.
+     *
+     * @return {Promise}
+     */
+    @action getInstalledOrderConfigs(params = {}) {
+        return new Promise((resolve, reject) => {
+            this.fetch
+                .get('fleet-ops/order-configs/get-installed', params)
+                .then((configs) => {
+                    const serialized = [];
+
+                    for (let i = 0; i < configs.length; i++) {
+                        const config = configs.objectAt(i);
+                        const normalizedConfig = this.store.normalize('order-config', config);
+                        const serializedConfig = this.store.push(normalizedConfig);
+
+                        serialized.pushObject(serializedConfig);
+                    }
+
+                    resolve(serialized);
+                })
+                .catch(reject);
+        });
+    }
+
+    /**
+     * The prefix for this user options
+     *
+     * @var {String}
+     */
+    @computed('id') get optionsPrefix() {
+        return `${this.id}:`;
+    }
+
+    get latitude() {
+        return this.whois('latitude');
+    }
+
+    get longitude() {
+        return this.whois('longitude');
+    }
+
+    get currency() {
+        return this.whois('currency.code');
+    }
+
+    get city() {
+        return this.whois('city');
+    }
+
+    get country() {
+        return this.whois('country_code');
+    }
+
+    @action whois(key) {
+        return this.getWhoisProperty(key);
+    }
+
+    /**
+     * Sets a user's option in local storage
+     *
+     * @param {String} key
+     * @param {Mixed} value
+     * @return {CurrentUserService}
+     */
+    @action setOption(key, value) {
+        key = `${this.optionsPrefix}${dasherize(key)}`;
+
+        this.options.set(key, value);
+
+        return this;
+    }
+
+    /**
+     * Retrieves a user option from local storage
+     *
+     * @param {String} key
+     * @return {Mixed}
+     */
+    @action getOption(key, defaultValue = null) {
+        key = `${this.optionsPrefix}${dasherize(key)}`;
+
+        const value = this.options.get(key);
+        return value !== undefined ? value : defaultValue;
+    }
+
+    /**
+     * Retrieves a user option from local storage
+     *
+     * @param {String} key
+     * @return {Mixed}
+     */
+    @action getWhoisProperty(prop) {
+        const whois = this.getOption('whois');
+
+        if (!whois || typeof whois !== 'object') {
+            return null;
+        }
+
+        return get(whois, prop);
+    }
+
+    /**
+     * Checks if an option exists in users local storage
+     *
+     * @param {String} key
+     * @return {Boolean}
+     */
+    @action hasOption(key) {
+        return this.getOption(key) !== undefined;
+    }
+
+    /**
+     * Checks if an option exists in users local storage
+     *
+     * @param {String} key
+     * @return {Boolean}
+     */
+    @action filledOption(key) {
+        return !isBlank(this.getOption(key));
+    }
+}