@fleetbase/registry-bridge-engine 0.0.1

package/addon/components/modals/select-extension-bundle.hbs

@@ -0,0 +1,43 @@
+<Modal::Default @modalIsOpened={{@modalIsOpened}} @options={{@options}} @confirm={{@onConfirm}} @decline={{@onDecline}}>
+    {{#if this.bundles}}
+        <div class="next-table-wrapper auto-height">
+            <table>
+                <thead>
+                    <tr>
+                        <th {{set-width "175px"}}>ID</th>
+                        <th {{set-width "70px"}}>Bundle</th>
+                        <th {{set-width "80px"}}>Version</th>
+                        <th {{set-width "110px"}}>Uploaded</th>
+                        <th {{set-width "100px"}}>Status</th>
+                        <th></th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {{#each this.bundles as |bundle|}}
+                        <tr>
+                            <td>{{bundle.bundle_id}}</td>
+                            <td>{{bundle.bundle_number}}</td>
+                            <td>{{bundle.version}}</td>
+                            <td>{{bundle.createdAgo}}</td>
+                            <td>
+                                <Badge @status={{bundle.status}} />
+                            </td>
+                            <td>
+                                {{#if (eq this.extension.next_bundle_uuid bundle.id)}}
+                                    <div class="flex flex-row items-center text-xs">
+                                        <FaIcon @icon="check" class="text-green-500" @size="md" />
+                                        <span class="ml-2 text-green-400">Selected</span>
+                                    </div>
+                                {{else}}
+                                    <Button @text="Select" @size="xs" @type="primary" @onClick={{fn this.selectBundle bundle}} />
+                                {{/if}}
+                            </td>
+                        </tr>
+                    {{/each}}
+                </tbody>
+            </table>
+        </div>
+    {{else}}
+        <div>No bundles uploaded.</div>
+    {{/if}}
+</Modal::Default>

package/addon/components/modals/select-extension-bundle.js

@@ -0,0 +1,31 @@
+import Component from '@glimmer/component';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+import { task } from 'ember-concurrency';
+
+export default class ModalsSelectExtensionBundleComponent extends Component {
+    @service store;
+    @tracked extension;
+    @tracked options = {};
+    @tracked bundles = [];
+
+    constructor(owner, { options }) {
+        super(...arguments);
+        const { extension } = options;
+
+        this.options = options;
+        this.extension = extension;
+        this.loadExtensionBundles.perform(extension);
+    }
+
+    @task *loadExtensionBundles(extension) {
+        this.bundles = yield this.store.query('registry-extension-bundle', { extension_uuid: extension.id, status: 'pending' });
+    }
+
+    @action selectBundle(bundle) {
+        if (typeof this.options.onBundleSelected === 'function') {
+            this.options.onBundleSelected(bundle);
+        }
+    }
+}

package/addon/components/progress-bar.hbs

@@ -0,0 +1,12 @@
+<div>
+    <div class="mb-2 flex justify-between items-center">
+        <h3 class="text-sm font-semibold text-gray-800 dark:text-white">{{@title}}</h3>
+        <span class="text-sm text-gray-800 dark:text-white">{{@percent}}%</span>
+    </div>
+    <div class="flex w-full h-2 bg-gray-200 rounded-full overflow-hidden dark:bg-neutral-700" role="progressbar" aria-valuenow={{@percent}} aria-valuemin="0" aria-valuemax="100">
+        <div
+            class="flex flex-col justify-center rounded-full overflow-hidden bg-blue-600 text-xs text-white text-center whitespace-nowrap transition duration-500 dark:bg-blue-500"
+            {{did-update this.setProgress @percent}}
+        ></div>
+    </div>
+</div>

package/addon/components/progress-bar.js

@@ -0,0 +1,8 @@
+import Component from '@glimmer/component';
+import { action } from '@ember/object';
+
+export default class ProgressBarComponent extends Component {
+    @action setProgress(el, [percent]) {
+        el.style.width = `${percent}%`;
+    }
+}

package/addon/controllers/application.js

@@ -0,0 +1,6 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+
+export default class ApplicationController extends Controller {
+    @tracked categories = [];
+}

package/addon/controllers/developers/analytics.js

@@ -0,0 +1,26 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { action } from '@ember/object';
+import { inject as service } from '@ember/service';
+import { task } from 'ember-concurrency';
+
+export default class DevelopersAnalyticsController extends Controller {
+    @service fetch;
+    @service notifications;
+    @tracked selectedExtension;
+    @tracked extensions = [];
+    @tracked metrics = {};
+
+    @action selectExtension(extension) {
+        this.selectedExtension = extension;
+        this.getExtensionAnalytics.perform(extension);
+    }
+
+    @task *getExtensionAnalytics(extension) {
+        try {
+            this.metrics = yield this.fetch.get('registry-extensions/analytics', { id: extension.id }, { namespace: '~registry/v1' });
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+}

package/addon/controllers/developers/extensions/edit/bundles.js

@@ -0,0 +1,70 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { task } from 'ember-concurrency';
+
+export default class DevelopersExtensionsEditBundlesController extends Controller {
+    @service store;
+    @service fetch;
+    @service hostRouter;
+    @service notifications;
+    @tracked extension;
+    @tracked lastError;
+    acceptedBundleTypes = [
+        'application/zip',
+        'application/x-zip',
+        'application/x-zip-compressed',
+        'application/x-compressed',
+        'multipart/x-zip',
+        'application/x-tar',
+        'application/gzip',
+        'application/x-gzip',
+        'application/x-tgz',
+        'application/x-bzip2',
+        'application/x-xz',
+    ];
+
+    @task *uploadBundle(file) {
+        this.lastError = undefined;
+
+        yield this.fetch.uploadFile.perform(
+            file,
+            {
+                path: `uploads/extensions/${this.extension.id}/bundles`,
+                subject_uuid: this.extension.id,
+                subject_type: 'registry-bridge:registry-extension',
+                type: 'extension_bundle',
+                meta: {
+                    version: this.extension.version,
+                },
+            },
+            (uploadedFile) => {
+                return this.createBundle.perform(uploadedFile);
+            },
+            () => {
+                // remove file from queue
+                if (file.queue && typeof file.queue.remove === 'function') {
+                    file.queue.remove(file);
+                }
+            }
+        );
+    }
+
+    @task *createBundle(uploadedFile) {
+        const bundle = this.store.createRecord('registry-extension-bundle', {
+            extension_uuid: this.extension.id,
+            bundle_uuid: uploadedFile.id,
+            bundle: uploadedFile,
+            status: 'pending',
+        });
+
+        try {
+            yield bundle.save();
+        } catch (error) {
+            this.lastError = error.message;
+            return this.notifications.serverError(error);
+        }
+
+        yield this.hostRouter.refresh();
+    }
+}

package/addon/controllers/developers/extensions/edit/index.js

@@ -0,0 +1,3 @@
+import Controller from '@ember/controller';
+
+export default class DevelopersExtensionsEditIndexController extends Controller {}

package/addon/controllers/developers/extensions/edit/monetize.js

@@ -0,0 +1,7 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+
+export default class DevelopersExtensionsEditMonetizeController extends Controller {
+    @tracked subscriptionModelOptions = ['flat_rate', 'tiered', 'usage'];
+    @tracked billingPeriodOptions = ['daily', 'weekly', 'monthly', 'quarterly', 'yearly'];
+}

package/addon/controllers/developers/extensions/edit.js

@@ -0,0 +1,107 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+import { isArray } from '@ember/array';
+import { isBlank } from '@ember/utils';
+import { task } from 'ember-concurrency';
+import humanize from '@fleetbase/ember-core/utils/humanize';
+
+export default class DevelopersExtensionsEditController extends Controller {
+    @service notifications;
+    @service intl;
+    @tracked isReady = false;
+    @tracked isReadyMessage = null;
+
+    @task *save() {
+        try {
+            yield this.model.save();
+            this.notifications.success('Extension details saved.');
+            const isReady = this.validateExtensionForReview();
+            if (isReady === true) {
+                this.isReady = isReady;
+            } else if (isArray(isReady) && isReady.length) {
+                this.isReadyMessage = isReady[0];
+            }
+        } catch (error) {
+            this.notifications.warning(error.message);
+        }
+    }
+
+    @task *startReview() {
+        try {
+            yield this.model.submitForReview();
+            this.notifications.success(this.intl.t('registry-bridge.developers.extensions.extension-form.submission-success-message'));
+        } catch (error) {
+            if (error && error.message) {
+                this.notifications.error(error.messsage);
+            }
+        }
+    }
+
+    @action onIconUploaded(uploadedFile) {
+        this.model.setProperties({
+            icon_uuid: uploadedFile.id,
+            icon_url: uploadedFile.url,
+        });
+
+        return this.model.save();
+    }
+
+    @action submitForReview() {
+        const result = this.validateExtensionForReview();
+        if (result === true) {
+            // send for review
+            return this.startReview.perform();
+        }
+
+        if (isArray(result)) {
+            this.notifications.warning(result.join('\n'));
+        }
+    }
+
+    getValidations() {
+        const defaultValidationFn = (value) => !isBlank(value);
+        return {
+            name: (value) => {
+                return typeof value === 'string' && value.length > 3;
+            },
+            description: (value) => {
+                return typeof value === 'string' && value.length > 12;
+            },
+            tags: defaultValidationFn,
+            promotional_text: defaultValidationFn,
+            subtitle: defaultValidationFn,
+            copyright: defaultValidationFn,
+            website_url: defaultValidationFn,
+            support_url: defaultValidationFn,
+            privacy_policy_url: defaultValidationFn,
+            icon_uuid: defaultValidationFn,
+            next_bundle_uuid: defaultValidationFn,
+            category_uuid: defaultValidationFn,
+        };
+    }
+
+    validateExtensionForReview() {
+        const extension = this.model;
+        const validations = this.getValidations();
+        const errors = [];
+        // next bundle and current bundle id cannot be equal
+        if (extension.next_bundle_uuid === extension.current_bundle_uuid) {
+            return ['New bundle must be selected fo review.'];
+        }
+
+        Object.keys(validations).forEach((property) => {
+            const isValid = validations[property](extension.get(property));
+            if (!isValid) {
+                errors.push(`${humanize(property)} is required for submission.`);
+            }
+        });
+
+        if (errors.length > 0) {
+            return errors;
+        }
+
+        return true;
+    }
+}

package/addon/controllers/developers/extensions/index.js

@@ -0,0 +1,3 @@
+import Controller from '@ember/controller';
+
+export default class DevelopersExtensionsIndexController extends Controller {}

package/addon/controllers/developers/extensions/new.js

@@ -0,0 +1,32 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+import { task } from 'ember-concurrency';
+
+export default class DevelopersExtensionsNewController extends Controller {
+    @service store;
+    @service universe;
+    @service hostRouter;
+    @service notifications;
+    @tracked extension = this.store.createRecord('registry-extension');
+
+    @task *save() {
+        try {
+            yield this.extension.save();
+        } catch (error) {
+            return this.notifications.warning(error.message);
+        }
+        return this.hostRouter.transitionTo('console.extensions.developers.extensions.edit', this.extension);
+    }
+
+    @action cancel() {
+        this.reset();
+        return this.hostRouter.transitionTo('console.extensions.developers.extensions');
+    }
+
+    reset() {
+        this.extension.destroyRecord();
+        this.extension = this.store.createRecord('registry-extension');
+    }
+}

package/addon/controllers/developers/payments/index.js

@@ -0,0 +1,39 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+
+export default class DevelopersPaymentsIndexController extends Controller {
+    @tracked hasStripeConnectAccount = true;
+    @tracked table;
+    @tracked page = 1;
+    @tracked limit = 30;
+    @tracked sort = '-created_at';
+    @tracked query = null;
+    queryParams = ['page', 'limit', 'sort', 'query'];
+    columns = [
+        {
+            label: 'Extension',
+            valuePath: 'extension.name',
+            width: '20%',
+        },
+        {
+            label: 'Category',
+            valuePath: 'extension.category_name',
+            width: '20%',
+        },
+        {
+            label: 'Customer',
+            valuePath: 'company.name',
+            width: '20%',
+        },
+        {
+            label: 'Amount',
+            valuePath: 'locked_price',
+            width: '20%',
+        },
+        {
+            label: 'Date',
+            valuePath: 'created_at',
+            width: '20%',
+        },
+    ];
+}

package/addon/controllers/developers/payments/onboard.js

@@ -0,0 +1,67 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+import { task } from 'ember-concurrency';
+import { loadConnectAndInitialize } from '@stripe/connect-js';
+import config from '../config/environment';
+
+export default class DevelopersPaymentsOnboardController extends Controller {
+    @service fetch;
+    @service notifications;
+    @tracked connectedAccountId;
+    @tracked onboardInProgress = false;
+    @tracked onboardCompleted = false;
+
+    @task *startOnboard() {
+        try {
+            const { account } = yield this.fetch.post('payments/account', {}, { namespace: '~registry/v1' });
+
+            this.connectedAccountId = account;
+            this.onboardInProgress = true;
+
+            const instance = loadConnectAndInitialize({
+                publishableKey: config.stripe.publishableKey,
+                fetchClientSecret: this.fetchClientSecret.bind(this),
+                appearance: {
+                    overlays: 'dialog',
+                    variables: {
+                        colorPrimary: '#635BFF',
+                    },
+                },
+            });
+
+            const container = this.getTrackedElement('embeddedOnboardingContainer');
+            const embeddedOnboardingComponent = instance.create('account-onboarding');
+            embeddedOnboardingComponent.setOnExit(() => {
+                this.onboardInProgress = false;
+                this.onboardCompleted = true;
+            });
+            container.appendChild(embeddedOnboardingComponent);
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    async fetchClientSecret() {
+        try {
+            const { clientSecret } = await this.fetch.post('payments/account-session', { account: this.connectedAccountId }, { namespace: '~registry/v1' });
+
+            return clientSecret;
+        } catch (error) {
+            this.notifications.serverError(error);
+        }
+    }
+
+    @action createTrackedElement(name, el) {
+        this[name] = el;
+    }
+
+    getTrackedElement(name) {
+        if (this[name] instanceof HTMLElement) {
+            return this[name];
+        }
+
+        return null;
+    }
+}

package/addon/controllers/explore/category.js

@@ -0,0 +1,22 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { inject as service } from '@ember/service';
+import { task, timeout } from 'ember-concurrency';
+
+export default class ExploreCategoryController extends Controller {
+    @service store;
+    @tracked extensions = [];
+    @tracked query;
+    queryParams = ['query'];
+
+    @task({ restartable: true }) *search(event) {
+        this.query = event.target.value;
+        yield timeout(300);
+
+        if (this.query) {
+            this.extensions = yield this.store.query('registry-extension', { explore: 1, category: this.model.id, query: this.query });
+        } else {
+            this.extensions = yield this.store.query('registry-extension', { explore: 1, category: this.model.id });
+        }
+    }
+}

package/addon/controllers/explore/index.js

@@ -0,0 +1,15 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import { task, timeout } from 'ember-concurrency';
+
+export default class ExploreIndexController extends Controller {
+    @tracked query;
+
+    @task({ restartable: true }) *search(event) {
+        const query = event.target.value;
+        if (query) {
+            this.query = query;
+            yield timeout(300);
+        }
+    }
+}

package/addon/controllers/installed.js

@@ -0,0 +1,86 @@
+import Controller from '@ember/controller';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+import { later } from '@ember/runloop';
+
+export default class InstalledController extends Controller {
+    @service modalsManager;
+    @service currentUser;
+    @service notifications;
+    @service socket;
+    @service hostRouter;
+
+    @action about(extension) {
+        this.modalsManager.show('modals/extension-details', {
+            titleComponent: 'extension-modal-title',
+            modalClass: 'flb--extension-modal modal-lg',
+            modalHeaderClass: 'flb--extension-modal-header',
+            acceptButtonText: 'Done',
+            hideDeclineButton: true,
+            extension,
+        });
+    }
+
+    @action uninstall(extension) {
+        const uninstallChannel = `uninstall.${this.currentUser.companyId}.${extension.id}`;
+
+        this.modalsManager.show('modals/extension-uninstall', {
+            title: `Uninstall ${extension.name}`,
+            modalClass: 'flb--extension-modal modal-lg',
+            modalHeaderClass: 'flb--extension-modal-header',
+            acceptButtonText: 'Uninstall',
+            acceptButtonIcon: 'trash',
+            acceptButtonScheme: 'danger',
+            process: null,
+            step: null,
+            stepDescription: 'Awaiting uninstall to begin...',
+            progress: 0,
+            extension,
+            confirm: async (modal) => {
+                modal.startLoading();
+
+                // Listen for uninstall progress
+                this.socket.listen(uninstallChannel, ({ process, step, progress }) => {
+                    let stepDescription;
+                    switch (step) {
+                        case 'server.uninstall':
+                            stepDescription = '(1/3) Uninstalling extension...';
+                            break;
+
+                        case 'engine.uninstall':
+                            stepDescription = '(2/3) Uninstalling extension...';
+                            break;
+
+                        case 'console.build':
+                            stepDescription = '(3/3) Completing uninstall...';
+                            break;
+
+                        default:
+                            break;
+                    }
+                    modal.setOptions({ process, step, progress, stepDescription });
+                });
+
+                // Start uninstall progress
+                modal.setOption('progress', 5);
+
+                // Run uninstall
+                try {
+                    await extension.uninstall();
+                    await this.hostRouter.refresh();
+                    this.notifications.info(`${extension.name} is now Uninstalled.`);
+                    later(
+                        this,
+                        () => {
+                            window.location.reload(true);
+                        },
+                        600
+                    );
+                    modal.done();
+                } catch (error) {
+                    this.notifications.serverError(error);
+                }
+            },
+        });
+    }
+}

package/addon/controllers/purchased.js

@@ -0,0 +1,18 @@
+import Controller from '@ember/controller';
+import { inject as service } from '@ember/service';
+import { action } from '@ember/object';
+
+export default class PurchasedController extends Controller {
+    @service modalsManager;
+
+    @action about(extension) {
+        this.modalsManager.show('modals/extension-details', {
+            titleComponent: 'extension-modal-title',
+            modalClass: 'flb--extension-modal modal-lg',
+            modalHeaderClass: 'flb--extension-modal-header',
+            acceptButtonText: 'Done',
+            hideDeclineButton: true,
+            extension,
+        });
+    }
+}

package/addon/engine.js

@@ -0,0 +1,44 @@
+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';
+import ExtensionReviewerControlComponent from './components/extension-reviewer-control';
+import ExtensionPendingPublishViewerComponent from './components/extension-pending-publish-viewer';
+
+const { modulePrefix } = config;
+const externalRoutes = ['console', 'extensions'];
+
+export default class RegistryBridgeEngine extends Engine {
+    modulePrefix = modulePrefix;
+    Resolver = Resolver;
+    dependencies = {
+        services,
+        externalRoutes,
+    };
+    setupExtension = function (app, engine, universe) {
+        // Register menu item in header
+        universe.registerHeaderMenuItem('Extensions', 'console.extensions', { icon: 'shapes', priority: 99 });
+        // Register admin controls
+        universe.registerAdminMenuPanel(
+            'Extensions Registry',
+            [
+                {
+                    title: 'Extensions Awaiting Review',
+                    icon: 'gavel',
+                    component: ExtensionReviewerControlComponent,
+                },
+                {
+                    title: 'Extensions Pending Publish',
+                    icon: 'rocket',
+                    component: ExtensionPendingPublishViewerComponent,
+                },
+            ],
+            {
+                slug: 'extension-registry',
+            }
+        );
+    };
+}
+
+loadInitializers(RegistryBridgeEngine, modulePrefix);