@fleetbase/storefront-engine 0.0.1

package/addon/controllers/settings/index.js

@@ -0,0 +1,102 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { alias } from '@ember/object/computed';
+import { action } from '@ember/object';
+import { isArray } from '@ember/array';
+import getPodMethods from '@fleetbase/console/utils/get-pod-methods';
+
+export default class SettingsIndexController extends Controller {
+    @service notifications;
+    @service fetch;
+    @service storefront;
+
+    @alias('storefront.activeStore') activeStore;
+    @tracked podMethods = getPodMethods();
+    @tracked isLoading = false;
+    @tracked uploadQueue = [];
+    @tracked uploadedFiles = [];
+
+    @action addTag(tag) {
+        if (!isArray(this.model.tags)) {
+            this.model.tags = [];
+        }
+
+        this.model.tags?.pushObject(tag);
+    }
+
+    @action removeTag(index) {
+        this.model.tags?.removeAt(index);
+    }
+
+    @action saveSettings() {
+        this.isLoading = true;
+
+        this.model.save().then(() => {
+            this.notifications.success('Changes saved');
+            this.isLoading = false;
+        });
+    }
+
+    @action uploadFile(type, file) {
+        const prefix = type.replace('storefront_', '');
+
+        this.fetch.uploadFile.perform(
+            file,
+            {
+                path: `uploads/storefront/${this.activeStore.id}/${type}`,
+                key_uuid: this.activeStore.id,
+                key_type: `store:storefront`,
+                type,
+            },
+            (uploadedFile) => {
+                this.model.setProperties({
+                    [`${prefix}_uuid`]: uploadedFile.id,
+                    [`${prefix}_url`]: uploadedFile.s3url,
+                    [prefix]: uploadedFile,
+                });
+            }
+        );
+    }
+
+    @action queueFile(file) {
+        this.uploadQueue.pushObject(file);
+        this.fetch.uploadFile.perform(
+            file,
+            {
+                path: `uploads/storefront/${this.activeStore.id}/media`,
+                key_uuid: this.activeStore.id,
+                key_type: `store:storefront`,
+                type: `storefront_store_media`,
+            },
+            (uploadedFile) => {
+                this.model.files.pushObject(uploadedFile);
+                this.uploadQueue.removeObject(file);
+            },
+            () => {
+                this.uploadQueue.removeObject(file);
+            }
+        );
+    }
+
+    @action removeFile(file) {
+        if (file.queue) {
+            file.queue.remove(file);
+        }
+
+        if (file.model) {
+            this.uploadedFiles.removeObject(file.model);
+            file.model.destroyRecord();
+        }
+
+        this.uploadQueue.removeObject(file);
+    }
+
+    @action makeAlertable(reason, models) {
+        if (!this.model.alertable || !this.model.alertable?.length) {
+            this.model.set('alertable', {});
+        }
+
+        this.model.set(`alertable.${reason}`, models);
+    }
+}

package/addon/controllers/settings/locations.js

@@ -0,0 +1,186 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { alias } from '@ember/object/computed';
+import { action } from '@ember/object';
+import Point from '@fleetbase/fleetops-data/utils/geojson/point';
+
+export default class SettingsLocationsController extends Controller {
+    /**
+     * Inject the `notifications` service
+     *
+     * @var {Service}
+     */
+    @service notifications;
+
+    /**
+     * Inject the `modals-manager` service
+     *
+     * @var {Service}
+     */
+    @service modalsManager;
+
+    /**
+     * Inject the `crud` service
+     *
+     * @var {Service}
+     */
+    @service crud;
+
+    /**
+     * Inject the `store` service
+     *
+     * @var {Service}
+     */
+    @service store;
+
+    /**
+     * Inject the `hostRouter` service
+     *
+     * @var {Service}
+     */
+    @service hostRouter;
+
+    /**
+     * Inject the `storefront` service
+     *
+     * @var {Service}
+     */
+    @service storefront;
+
+    @alias('storefront.activeStore') activeStore;
+
+    daysOfTheWeek = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
+
+    /**
+     * Create a new store location
+     *
+     * @void
+     */
+    @action createNewLocation() {
+        const place = this.store.createRecord('place');
+        const storeLocation = this.store.createRecord('store-location', {
+            store_uuid: this.activeStore.id,
+            place,
+        });
+
+        return this.editStoreLocation(storeLocation, {
+            title: 'New store location',
+            acceptButtonText: 'Add new Location',
+            acceptButtonIcon: 'save',
+        });
+    }
+
+    @action async editStoreLocation(storeLocation, options = {}) {
+        await storeLocation.loadPlace();
+
+        let { place } = storeLocation;
+
+        if (!place) {
+            place = this.store.createRecord('place', {
+                name: storeLocation.name,
+            });
+        }
+
+        this.modalsManager.show('modals/store-location-form', {
+            title: 'Edit store location',
+            acceptButtonText: 'Save Changes',
+            acceptButtonIcon: 'save',
+            place,
+            autocomplete: (selected) => {
+                const coordinatesInputComponent = this.modalsManager.getOption('coordinatesInputComponent');
+
+                place.setProperties({ ...selected });
+
+                if (coordinatesInputComponent) {
+                    const [longitude, latitude] = selected.location.coordinates;
+                    coordinatesInputComponent.updateCoordinates(latitude, longitude);
+                }
+            },
+            setCoordinatesInput: (coordinatesInputComponent) => {
+                this.modalsManager.setOption('coordinatesInputComponent', coordinatesInputComponent);
+            },
+            updatePlaceCoordinates: ({ latitude, longitude }) => {
+                const location = new Point(longitude, latitude);
+
+                place.setProperties({ location });
+            },
+            confirm: (modal) => {
+                modal.startLoading();
+
+                return place.save().then((place) => {
+                    storeLocation.setProperties({
+                        place_uuid: place.id,
+                        name: place.name,
+                    });
+
+                    return storeLocation
+                        .save()
+                        .then((storeLocation) => {
+                            storeLocation.setProperties({
+                                place,
+                            });
+                            this.notifications.success(`${place.get('name') || place.get('street1')} store location saved.`);
+                            return this.hostRouter.refresh();
+                        })
+                        .catch((error) => {
+                            modal.stopLoading();
+                            this.notifications.serverError(error);
+                        });
+                });
+            },
+            ...options,
+        });
+    }
+
+    @action removeStoreLocation(storeLocation) {
+        this.modalsManager.confirm({
+            title: 'Are you sure you wish to remove this store location?',
+            body: 'All products that are solely assosciated with this location will no longer be accessible.',
+            confirm: (modal) => {
+                modal.startLoading();
+
+                return storeLocation.destroyRecord();
+            },
+        });
+    }
+
+    /**
+     * Create a new store location
+     *
+     * @void
+     */
+    @action addHours(storeLocation, day) {
+        const storeHours = this.store.createRecord('store-hour', {
+            store_location_uuid: storeLocation.id,
+            day_of_week: day,
+        });
+
+        this.modalsManager.show('modals/add-store-hours', {
+            title: `Add new store hours for ${day}`,
+            acceptButtonText: 'Add hours',
+            acceptButtonIcon: 'save',
+            storeHours,
+            confirm: (modal) => {
+                modal.startLoading();
+
+                return storeHours.save().then((storeHours) => {
+                    storeLocation.hours.pushObject(storeHours);
+                    this.notifications.success(`New store hours added for ${day}`);
+                });
+            },
+        });
+    }
+
+    @action removeHours(storeHours) {
+        this.modalsManager.confirm({
+            title: 'Are you sure you wish to remove these hours?',
+            body: 'By removing these operation hours, your store may become inactive according to the updated schedule for this location..',
+            confirm: (modal) => {
+                modal.startLoading();
+
+                return storeHours.destroyRecord();
+            },
+        });
+    }
+}

package/addon/controllers/settings/notifications.js

@@ -0,0 +1,102 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { alias } from '@ember/object/computed';
+import { action, set } from '@ember/object';
+import { capitalize } from '@ember/string';
+import getNotificationSchemas from '../../utils/get-notification-schemas';
+
+export default class SettingsNotificationsController extends Controller {
+    @service notifications;
+    @service modalsManager;
+    @service store;
+    @service crud;
+    @service storefront;
+    @alias('storefront.activeStore') activeStore;
+    @tracked channels = [];
+
+    @action createChannel() {
+        const channel = this.store.createRecord('notification-channel', {
+            owner_uuid: this.activeStore.id,
+            owner_type: 'store:storefront',
+        });
+
+        this.editChannel(channel, {
+            title: `Create a new notification channel`,
+            acceptButtonText: 'Create Notification Channel',
+            decline: (modal) => {
+                channel.destroyRecord();
+                modal.done();
+            },
+        });
+    }
+
+    @action editChannel(channel, options = {}) {
+        const schemas = getNotificationSchemas();
+        const schemaOptions = [
+            { name: 'Apple Push Notification Service (APN)', value: 'apn' },
+            { name: 'Firebase Cloud Messaging (FCM)', value: 'fcm' },
+        ];
+
+        this.modalsManager.show('modals/create-notification-channel', {
+            title: `Edit notification channel`,
+            acceptButtonText: 'Save Changes',
+            schema: channel.id ? channel.config : null,
+            schemas,
+            schemaOptions,
+            selectSchema: (schema) => {
+                this.modalsManager.setOption('schema', schemas[schema]);
+
+                channel.setProperties({
+                    name: `${capitalize(schema)} Notification Channel`,
+                    scheme: schema,
+                    config: schemas[schema],
+                });
+            },
+            setConfigKey: (key, value) => {
+                // eslint-disable-next-line no-undef
+                if (value instanceof Event) {
+                    const eventValue = value.target.value;
+
+                    set(channel.config, key, eventValue);
+                    return;
+                }
+
+                set(channel.config, key, value);
+            },
+            channel,
+            confirm: (modal) => {
+                modal.startLoading();
+
+                return channel
+                    .save()
+                    .then((channel) => {
+                        this.notifications.success(`New notification channel added`);
+                        this.channels.pushObject(channel);
+                    })
+                    .catch((error) => {
+                        // gateway.rollbackAttributes();
+                        modal.stopLoading();
+                        this.notifications.serverError(error);
+                    });
+            },
+            ...options,
+        });
+    }
+
+    @action deleteChannel(channel) {
+        this.modalsManager.confirm({
+            title: 'Are you sure you wish to remove this notification channel?',
+            body: 'All applications and websites utilizing this channel in configuration could be disrupted if channel is not replaced beforehand',
+            confirm: (modal) => {
+                modal.startLoading();
+
+                return channel.destroyRecord().then(() => {
+                    // justincase
+                    this.channels.removeObject(channel);
+                    modal.stopLoading();
+                });
+            },
+        });
+    }
+}

package/addon/engine.js

@@ -0,0 +1,19 @@
+import Engine from '@ember/engine';
+import loadInitializers from 'ember-load-initializers';
+import Resolver from 'ember-resolver';
+import config from './config/environment';
+import services from '@fleetbase/ember-core/exports/services';
+
+const { modulePrefix } = config;
+const externalRoutes = ['console', 'extensions'];
+
+export default class StorefrontEngine extends Engine {
+    modulePrefix = modulePrefix;
+    Resolver = Resolver;
+    dependencies = {
+        services,
+        externalRoutes,
+    };
+}
+
+loadInitializers(StorefrontEngine, modulePrefix);

package/addon/helpers/get-tip-amount.js

@@ -0,0 +1,5 @@
+import { helper } from '@ember/component/helper';
+
+export default helper(function getTipAmount(positional /*, named*/) {
+    return positional;
+});

package/addon/models/addon-category.js

@@ -0,0 +1,6 @@
+import CategoryModel from '@fleetbase/console/models/category';
+import { hasMany } from '@ember-data/model';
+
+export default class AddonCategoryModel extends CategoryModel {
+    @hasMany('product-addon') addons;
+}

package/addon/models/gateway.js

@@ -0,0 +1,46 @@
+import Model, { attr } from '@ember-data/model';
+import { format, formatDistanceToNow } from 'date-fns';
+
+export default class GatewayModel extends Model {
+    /** @ids */
+    @attr('string') created_by_uuid;
+    @attr('string') company_uuid;
+    @attr('string') owner_uuid;
+
+    /** @attributes */
+    @attr('string', { defaultValue: 'storefront:store' }) owner_type;
+    @attr('string', { defaultValue: '' }) name;
+    @attr('string', { defaultValue: '' }) code;
+    @attr('string') type;
+    @attr('boolean') sandbox;
+    @attr('raw') meta;
+    @attr('raw') config;
+    @attr('string') return_url;
+    @attr('string') callback_url;
+
+    /** @dates */
+    @attr('date') created_at;
+    @attr('date') updated_at;
+
+    /** @methods */
+    toJSON() {
+        return this.serialize();
+    }
+
+    /** @computed */
+    get updatedAgo() {
+        return formatDistanceToNow(this.updated_at);
+    }
+
+    get updatedAt() {
+        return format(this.updated_at, 'PPP');
+    }
+
+    get createdAgo() {
+        return formatDistanceToNow(this.created_at);
+    }
+
+    get createdAt() {
+        return format(this.created_at, 'PPP p');
+    }
+}

package/addon/models/network.js

@@ -0,0 +1,166 @@
+import Model, { attr, hasMany, belongsTo } from '@ember-data/model';
+import { format, formatDistanceToNow } from 'date-fns';
+import { getOwner } from '@ember/application';
+import isEmail from '@fleetbase/console/utils/is-email';
+import Store from './store';
+
+export default class NetworkModel extends Model {
+    /** @ids */
+    @attr('string') created_by_uuid;
+    @attr('string') company_uuid;
+    @attr('string') logo_uuid;
+    @attr('string') backdrop_uuid;
+
+    /** @relationships */
+    @hasMany('store') stores;
+    @hasMany('notification-channel') notification_channels;
+    @hasMany('gateway') gateways;
+    @hasMany('store') stores;
+    @belongsTo('file') logo;
+    @belongsTo('file') backdrop;
+
+    /** @attributes */
+    @attr('string', { defaultValue: '' }) name;
+    @attr('string', { defaultValue: '' }) description;
+    @attr('string', { defaultValue: '' }) website;
+    @attr('string', { defaultValue: '' }) email;
+    @attr('string', { defaultValue: '' }) phone;
+    @attr('string', { defaultValue: '' }) facebook;
+    @attr('string', { defaultValue: '' }) instagram;
+    @attr('string', { defaultValue: '' }) twitter;
+    @attr('raw') tags;
+    @attr('raw') translations;
+    @attr('raw') alertable;
+    @attr('string') public_id;
+    @attr('string') key;
+    @attr('string') currency;
+    @attr('string') timezone;
+    @attr('boolean') online;
+    @attr('number') stores_count;
+    @attr('object') options;
+    @attr('string') logo_url;
+    @attr('string') backdrop_url;
+    @attr('string') slug;
+
+    /** @dates */
+    @attr('date') created_at;
+    @attr('date') updated_at;
+
+    /** @computed */
+    get updatedAgo() {
+        return formatDistanceToNow(this.updated_at);
+    }
+
+    get updatedAt() {
+        return format(this.updated_at, 'PPP');
+    }
+
+    get createdAgo() {
+        return formatDistanceToNow(this.created_at);
+    }
+
+    get createdAt() {
+        return format(this.created_at, 'PPP p');
+    }
+
+    /** @methods */
+    toJSON() {
+        return this.serialize();
+    }
+
+    loadNotificationChannels() {
+        const owner = getOwner(this);
+        const store = owner.lookup(`service:store`);
+
+        return new Promise((resolve, reject) => {
+            return store
+                .query('notification-channel', { owner_uuid: this.id })
+                .then((notificationChannels) => {
+                    this.notification_channels = notificationChannels.toArray();
+
+                    resolve(notificationChannels);
+                })
+                .catch(reject);
+        });
+    }
+
+    loadPaymentGateways() {
+        const owner = getOwner(this);
+        const store = owner.lookup(`service:store`);
+
+        return new Promise((resolve, reject) => {
+            return store
+                .query('gateway', { owner_uuid: this.id })
+                .then((gateways) => {
+                    this.gateways = gateways.toArray();
+
+                    resolve(gateways);
+                })
+                .catch(reject);
+        });
+    }
+
+    loadStores() {
+        const owner = getOwner(this);
+        const store = owner.lookup(`service:store`);
+
+        return new Promise((resolve, reject) => {
+            return store
+                .query('store', { network: this.id })
+                .then((stores) => {
+                    this.stores = stores.toArray();
+
+                    resolve(stores);
+                })
+                .catch(reject);
+        });
+    }
+
+    addStores(stores = [], remove = []) {
+        const owner = getOwner(this);
+        const fetch = owner.lookup(`service:fetch`);
+
+        stores = stores.map((store) => {
+            if (store instanceof Store) {
+                return store.id;
+            }
+
+            return store;
+        });
+
+        remove = remove.map((store) => {
+            if (store instanceof Store) {
+                return store.id;
+            }
+
+            return store;
+        });
+
+        return fetch.post(`networks/${this.id}/add-stores`, { stores, remove }, { namespace: 'storefront/int/v1' });
+    }
+
+    removeStores(stores = []) {
+        const owner = getOwner(this);
+        const fetch = owner.lookup(`service:fetch`);
+
+        stores = stores.map((store) => {
+            if (store instanceof Store) {
+                return store.id;
+            }
+
+            return store;
+        });
+
+        return fetch.post(`networks/${this.id}/remove-stores`, { stores }, { namespace: 'storefront/int/v1' });
+    }
+
+    sendInvites(recipients = []) {
+        const owner = getOwner(this);
+        const fetch = owner.lookup(`service:fetch`);
+
+        // only send to valid recipients
+        recipients = recipients.filter((email) => isEmail(email));
+
+        return fetch.post(`networks/${this.id}/invite`, { recipients }, { namespace: 'storefront/int/v1' });
+    }
+}

package/addon/models/notification-channel.js

@@ -0,0 +1,47 @@
+import Model, { attr, belongsTo } from '@ember-data/model';
+import { format, formatDistanceToNow } from 'date-fns';
+
+export default class NotificationChannelModel extends Model {
+    /** @ids */
+    @attr('string') created_by_uuid;
+    @attr('string') company_uuid;
+    @attr('string') owner_uuid;
+    @attr('string') certificate_uuid;
+
+    /** @relationships */
+    @belongsTo('file') certificate;
+
+    /** @attributes */
+    @attr('string', { defaultValue: '' }) name;
+    @attr('string') scheme;
+    @attr('string') app_key;
+    @attr('string') owner_type;
+    @attr('object') config;
+    @attr('object') options;
+
+    /** @dates */
+    @attr('date') created_at;
+    @attr('date') updated_at;
+
+    /** @methods */
+    toJSON() {
+        return this.serialize();
+    }
+
+    /** @computed */
+    get updatedAgo() {
+        return formatDistanceToNow(this.updated_at);
+    }
+
+    get updatedAt() {
+        return format(this.updated_at, 'PPP');
+    }
+
+    get createdAgo() {
+        return formatDistanceToNow(this.created_at);
+    }
+
+    get createdAt() {
+        return format(this.created_at, 'PPP p');
+    }
+}