@girder/core 5.0.0-beta.1 → 5.0.0-beta.2

package/dist-lib/src/dialog.js

@@ -0,0 +1,128 @@
+import $ from 'jquery';
+import _ from 'underscore';
+import Backbone from 'backbone';
+
+import router from '@girder/core/router';
+import { parseQueryString, splitRoute } from '@girder/core/misc';
+
+import ConfirmDialogTemplate from '@girder/core/templates/widgets/confirmDialog.pug';
+
+import '@girder/core/utilities/jquery/girderModal';
+
+function handleClose(name, options, nameId) {
+    if (!router.enabled()) {
+        return;
+    }
+    var curRoute = Backbone.history.fragment,
+        routeParts = splitRoute(curRoute),
+        queryString = parseQueryString(routeParts.name),
+        dialogName = queryString.dialog,
+        dialogId = queryString.dialogid;
+    delete queryString.dialog;
+    delete queryString.dialogid;
+    var unparsedQueryString = $.param(queryString);
+    if (unparsedQueryString.length > 0) {
+        unparsedQueryString = '?' + unparsedQueryString;
+    }
+    if (dialogName === name && dialogId === nameId) {
+        router.navigate(routeParts.base + unparsedQueryString, options);
+    }
+}
+
+function handleOpen(name, options, nameId) {
+    if (!router.enabled()) {
+        return;
+    }
+    var curRoute = Backbone.history.fragment,
+        routeParts = splitRoute(curRoute),
+        queryString = parseQueryString(routeParts.name),
+        dialogName = queryString.dialog,
+        dialogId = queryString.dialogid;
+
+    if (dialogName !== name || nameId !== dialogId) {
+        queryString.dialog = name;
+        if (nameId) {
+            queryString.dialogid = nameId;
+        }
+        var unparsedQueryString = $.param(queryString);
+        if (unparsedQueryString.length > 0) {
+            unparsedQueryString = '?' + unparsedQueryString;
+        }
+        router.navigate(routeParts.base + unparsedQueryString, options);
+    }
+}
+
+/**
+ * Prompt the user to confirm an action.
+ * @param {Object} [params] Parameters controlling this function's behavior.
+ * @param {String} [params.text] The text to prompt the user with.
+ * @param {String} [params.yesText] The text for the confirm button.
+ * @param {String} [params.yesClass] Class string to apply to the confirm button.
+ * @param {String} [params.noText] The text for the no/cancel button.
+ * @param {Boolean} [params.escapedHtml] If you want to render the text as HTML rather than
+ *        plain text, set this to true to acknowledge that you have escaped any
+ *        user-created data within the text to prevent XSS exploits.
+ * @param {Boolean} [params.msgConfirmation] If you want to add a new security before
+ *        perform an action. This will ask to enter a specific string "params.yesText params.name"
+ * @param {String} [params.additionalText] Additional text to display before the confirmation
+ *        input.
+ * @param {String} [params.name] The name to enter in order to confirm an action.
+ * @param {Function} [params.confirmCallback]Callback function when the user confirms the action.
+ */
+function confirm(params) {
+    params = _.extend({
+        text: 'Are you sure?',
+        yesText: 'Yes',
+        yesClass: 'btn-danger',
+        noText: 'Cancel',
+        escapedHtml: false,
+        msgConfirmation: false,
+        additionalText: '',
+        name: ''
+    }, params);
+    $('#g-dialog-container').html(ConfirmDialogTemplate({
+        params: params
+    })).girderModal(false).one('hidden.bs.modal', function () {
+        $('#g-confirm-button').off('click');
+    });
+
+    const el = $('#g-dialog-container').find('.modal-body>p:first-child');
+    if (params.escapedHtml) {
+        el.html(params.text);
+    } else {
+        el.text(params.text);
+    }
+    if (params.msgConfirmation) {
+        if (params.escapedHtml) {
+            $('.g-additional-text').html(params.additionalText);
+        } else {
+            $('.g-additional-text').text(params.additionalText);
+        }
+    }
+
+    $('#g-confirm-button').off('click').on('click', function () {
+        if (params.msgConfirmation) {
+            const key = `${params.yesText.toUpperCase()} ${params.name}`;
+            const msg = $('#g-confirm-text').val();
+            if (msg.toUpperCase() === key.toUpperCase()) {
+                $('#g-dialog-container').modal('hide');
+                params.confirmCallback();
+            } else if (msg.toUpperCase() === '') {
+                $('.g-msg-error').html(`Error: You need to enter <b>'${key}'</b>.`);
+                $('.g-msg-error').css('color', 'red');
+            } else {
+                $('.g-msg-error').html(`Error: <b>'${msg}'</b> isn't <b>'${key}'</b>`);
+                $('.g-msg-error').css('color', 'red');
+            }
+        } else {
+            $('#g-dialog-container').modal('hide');
+            params.confirmCallback();
+        }
+    });
+}
+
+export {
+    confirm,
+    handleClose,
+    handleOpen
+};

package/dist-lib/src/events.js

@@ -0,0 +1,6 @@
+import _ from 'underscore';
+import Backbone from 'backbone';
+
+var girderEvents = _.clone(Backbone.Events);
+
+export default girderEvents;

package/dist-lib/src/index.d.ts

@@ -0,0 +1,23 @@
+declare const girder: {
+    $: any;
+    _: any;
+    Backbone: any;
+    moment: any;
+    initializeDefaultApp: (apiRoot: string, el?: string | HTMLElement) => Promise<unknown>;
+    auth: any;
+    collections: any;
+    constants: any;
+    dialog: any;
+    events: any;
+    misc: any;
+    models: any;
+    plugins: {};
+    pluginUtils: any;
+    rest: any;
+    router: any;
+    utilities: any;
+    version: any;
+    views: any;
+};
+export type Girder = typeof girder;
+export { girder, };

package/dist-lib/src/index.ts

@@ -0,0 +1,80 @@
+import $ from 'jquery';
+
+import _ from 'underscore';
+
+import Backbone from 'backbone';
+
+import moment from 'moment';
+
+import * as auth from './auth';
+import * as collections from './collections';
+import * as constants from './constants';
+import * as dialog from './dialog';
+import * as misc from './misc';
+import * as models from './models';
+import * as pluginUtils from './pluginUtils';
+import * as rest from './rest';
+import * as utilities from './utilities';
+import * as views from './views';
+import events from './events';
+import router from './router';
+import version from './version';
+
+const initializeDefaultApp = async (apiRoot: string, el: string | HTMLElement = 'body') => {
+    return new Promise((resolve, reject) => {
+        $(() => {
+            rest.setApiRoot(apiRoot);
+            events.trigger('g:appload.before');
+            rest.restRequest({
+                url: `system/public_settings`,
+                method: 'GET',
+            }).done((resp: any) => {
+                const app = new views.App({
+                    el,
+                    parentView: null,
+                    contactEmail: resp['core.contact_email_address'],
+                    privacyNoticeHref: resp['core.privacy_notice'],
+                    brandName: resp['core.brand_name'],
+                    bannerColor: resp['core.banner_color'],
+                    registrationPolicy: resp['core.registration_policy'],
+                    enablePasswordLogin: resp['core.enable_password_login'],
+                });
+                app.render();
+                document.title = resp['core.brand_name'];
+                events.trigger('g:appload.after', app);
+                resolve(app);
+            }).fail((resp: any) => {
+                events.trigger('g:error', resp);
+                reject(new Error("Could not retrieve public settings from server."));
+            });
+        });
+    });
+};
+
+const girder = {
+    $,
+    _,
+    Backbone,
+    moment,
+    initializeDefaultApp,
+    auth,
+    collections,
+    constants,
+    dialog,
+    events,
+    misc,
+    models,
+    plugins: {},
+    pluginUtils,
+    rest,
+    router,
+    utilities,
+    version,
+    views
+};
+
+export type Girder = typeof girder;
+
+export {
+    girder,
+};

package/dist-lib/src/main.ts

@@ -0,0 +1,45 @@
+import { girder } from '.';
+
+declare global {
+  interface Window {
+    girder: typeof girder;
+  }
+}
+window.girder = girder;
+
+interface StaticFilesSpec {
+  css: string[],
+  js: string[],
+}
+
+const apiRoot = import.meta.env.VITE_API_ROOT ?? '/api/v1';
+
+(async () => {
+  const origin = apiRoot.startsWith('/') ? window.origin : new URL(apiRoot).origin;
+  const staticFilesResp = await fetch(`${apiRoot}/system/plugin_static_files`);
+  const staticFiles: StaticFilesSpec = await staticFilesResp.json();
+
+  staticFiles.css.forEach((href) => {
+    const link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.type = 'text/css';
+    link.href = new URL(href, origin).href;
+    document.head.appendChild(link);
+  });
+
+  const scriptPromises: Promise<void>[] = [];
+  staticFiles.js.forEach((href) => {
+    scriptPromises.push(new Promise((resolve) => {
+      const script = document.createElement('script');
+      script.type = 'text/javascript';
+      script.src = new URL(href, origin).href;
+      document.head.appendChild(script);
+      script.addEventListener('load', function() {
+        resolve();
+      });
+    }));
+  });
+
+  await Promise.all(scriptPromises);
+  await girder.initializeDefaultApp(apiRoot);
+})();

package/dist-lib/src/misc.js

@@ -0,0 +1,260 @@
+import $ from 'jquery';
+import _ from 'underscore';
+
+import { MONTHS } from '@girder/core/constants';
+
+import { Remarkable } from 'remarkable';
+
+import { linkify } from 'remarkable/linkify';
+
+/**
+ * This file contains utility functions for general use in the application
+ */
+var DATE_MONTH = 0;
+var DATE_DAY = 1;
+var DATE_MINUTE = 2;
+var DATE_SECOND = 3;
+
+/**
+ * Format a date string to the given resolution.
+ * @param datestr The date string to format.
+ * @param resolution The resolution, defaults to 'day'. Minimum is month.
+ */
+function formatDate(datestr, resolution) {
+    datestr = datestr.replace(' ', 'T'); // Cross-browser accepted date format
+    var date = new Date(datestr);
+    var output = MONTHS[date.getMonth()];
+
+    resolution = resolution || DATE_MONTH;
+
+    if (resolution >= DATE_DAY) {
+        output += ' ' + date.getDate() + ',';
+    }
+
+    output += ' ' + date.getFullYear();
+
+    if (resolution >= DATE_MINUTE) {
+        output += ' at ' + date.getHours() + ':' +
+            ('0' + date.getMinutes()).slice(-2);
+    }
+    if (resolution >= DATE_SECOND) {
+        output += ':' + ('0' + date.getSeconds()).slice(-2);
+    }
+
+    return output;
+}
+
+/**
+ * Format a size in bytes into a human-readable string with metric unit
+ * prefixes.
+ */
+function formatSize(sizeBytes) {
+    if (sizeBytes < 1024) {
+        return sizeBytes + ' B';
+    }
+    var i, sizeVal = sizeBytes, precision = 1;
+    for (i = 0; sizeVal >= 1024; i += 1) {
+        sizeVal /= 1024;
+    }
+    // If we are just reporting a low number, no need for decimal places.
+    if (sizeVal < 10) {
+        precision = 3;
+    } else if (sizeVal < 100) {
+        precision = 2;
+    }
+    return sizeVal.toFixed(precision) + ' ' +
+        ['B', 'kB', 'MB', 'GB', 'TB'][Math.min(i, 4)];
+}
+
+/**
+ * Like formatSize, but more generic. Returns a human-readable format
+ * of an integer using metric prefixes. The caller is expected to append any
+ * unit string if necessary.
+ *
+ * @param {integer} n The number to format.
+ * @param {Object} [opts={}] Formatting options. These include:
+ *   - {integer} [maxLen] Max number of digits in the output.
+ *   - {integer} [base=1000] Base for the prefixes (usually 1000 or 1024).
+ *   - {string} [sep=''] Separator between numeric value and metric prefix.
+ */
+function formatCount(n, opts) {
+    n = n || 0;
+    opts = opts || {};
+
+    var i = 0,
+        base = opts.base || 1000,
+        sep = opts.sep || '',
+        maxLen = opts.maxLen || 3,
+        precision = maxLen - 1;
+
+    for (; n > base; i += 1) {
+        n /= base;
+    }
+
+    if (!i) {
+        precision = 0;
+    } else if (n > 100) {
+        precision -= 2;
+    } else if (n > 10) {
+        precision -= 1;
+    }
+
+    return n.toFixed(Math.max(0, precision)) + sep +
+        ['', 'k', 'M', 'G', 'T'][Math.min(i, 4)];
+}
+
+/**
+ * This comparator can be used by collections that wish to support locale-based
+ * sorting.  The locale specifies how upper and lower case are compared.
+ */
+function localeComparator(model1, model2) {
+    var a1 = model1.get(this.sortField),
+        a2 = model2.get(this.sortField);
+
+    if (a1 !== undefined && a1.localeCompare) {
+        var result = a1.localeCompare(a2) * this.sortDir;
+        if (result || !this.secondarySortField) {
+            return result;
+        }
+        a1 = model1.get(this.secondarySortField);
+        a2 = model2.get(this.secondarySortField);
+        return a1.localeCompare(a2) * this.sortDir;
+    }
+
+    return a1 > a2 ? this.sortDir : (a1 < a2 ? -this.sortDir : 0);
+}
+
+/**
+ * This comparator can be passed to the sort function on javascript arrays.
+ */
+function localeSort(a1, a2) {
+    if (a1 !== undefined && a1.localeCompare) {
+        return a1.localeCompare(a2);
+    }
+    return a1 > a2 ? 1 : (a1 < a2 ? -1 : 0);
+}
+
+/**
+ * Return the model class name given its collection name.
+ * @param name Collection name, e.g. 'user'
+ */
+function getModelClassByName(name) {
+    var className = name.charAt(0).toUpperCase();
+    return className + name.substr(1) + 'Model';
+}
+
+function parseQueryString(queryString) {
+    var params = {};
+    if (queryString) {
+        _.each(queryString.replace(/\+/g, ' ').split(/&/g), function (el) {
+            var aux = el.split('='), val;
+            if (aux.length > 1) {
+                val = decodeURIComponent(el.substr(aux[0].length + 1));
+            }
+            params[decodeURIComponent(aux[0])] = val;
+        });
+    }
+    return params;
+}
+
+/**
+ * Create a set of flags that can be OR'd (|) together to define a set of
+ * options.
+ *
+ * @param {Array} options An array of strings defining the option names.
+ * @param {string} allOption If you want an option that enables all options,
+ *                 pass its name as this parameter.
+ * @return {Object} An object mapping the names of options to values.
+ */
+function defineFlags(options, allOption) {
+    var i = 0,
+        obj = {};
+
+    if (allOption) {
+        obj[allOption] = 1;
+    }
+    _.each(options, function (opt) {
+        obj[opt] = 1 << i;
+
+        if (allOption) {
+            obj[allOption] |= obj[opt];
+        }
+
+        i += 1;
+    });
+
+    return obj;
+}
+
+/**
+ * Transform markdown into HTML and render it into the given element. If no
+ * element is provided, simply returns the HTML.
+ *
+ * @param val The markdown text input.
+ * @param el The element to render the output HTML into, or falsy to simply
+ *        return the HTML value.
+ */
+var renderMarkdown = (function () {
+    var md = new Remarkable().use(linkify);
+    return function (val, el) {
+        if (el) {
+            $(el).html(md.render(val));
+        } else {
+            return md.render(val);
+        }
+    };
+}());
+
+/**
+ * Capitalize the first character of a string.
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.substring(1);
+}
+
+function splitRoute(route) {
+    if (!route) {
+        return { base: '', name: '' };
+    }
+    var firstIndex = route.indexOf('?'),
+        lastIndex = route.lastIndexOf('?'),
+        dialogName,
+        baseRoute;
+
+    if (firstIndex === -1) {
+        baseRoute = route;
+    } else {
+        baseRoute = route.slice(0, firstIndex);
+    }
+
+    if (lastIndex === -1) {
+        dialogName = '';
+    } else {
+        dialogName = route.slice(lastIndex + 1);
+    }
+
+    return { name: dialogName, base: baseRoute };
+}
+
+function _whenAll(promises) {
+    return $.when(...promises).then((...results) => results);
+}
+
+export {
+    DATE_MONTH,
+    DATE_DAY,
+    DATE_MINUTE,
+    DATE_SECOND,
+    formatDate,
+    formatSize,
+    formatCount,
+    localeComparator,
+    localeSort,
+    getModelClassByName,
+    parseQueryString,
+    defineFlags,
+    renderMarkdown,
+    capitalize,
+    splitRoute,
+    _whenAll
+};

package/dist-lib/src/models/AccessControlledModel.js

@@ -0,0 +1,76 @@
+import $ from 'jquery';
+import _ from 'underscore';
+
+import Model from '@girder/core/models/Model';
+import { restRequest } from '@girder/core/rest';
+
+/**
+ * Models corresponding to AccessControlledModels on the server should extend
+ * from this object. It provides utilities for managing and storing the
+ * access control list on
+ */
+var AccessControlledModel = Model.extend({
+    /**
+     * Saves the access control list on this model to the server. Saves the
+     * state of whatever this model's "access" parameter is set to, which
+     * should be an object of the form:
+     *    {groups: [{id: <groupId>, level: <accessLevel>}, ...],
+     *     users: [{id: <userId>, level: <accessLevel>}, ...]}
+     * The "public" attribute of this model should also be set as a boolean.
+     * When done, triggers the 'g:accessListSaved' event on the model.
+     */
+    updateAccess: function (params) {
+        if (this.altUrl === null && this.resourceName === null) {
+            throw new Error('An altUrl or resourceName must be set on the Model.');
+        }
+
+        return restRequest({
+            url: `${this.altUrl || this.resourceName}/${this.id}/access`,
+            method: 'PUT',
+            data: _.extend({
+                access: JSON.stringify(this.get('access')),
+                public: this.get('public'),
+                publicFlags: JSON.stringify(this.get('publicFlags') || [])
+            }, params || {})
+        }).done(() => {
+            this.trigger('g:accessListSaved');
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    /**
+     * Fetches the access control list from the server, and sets it as the
+     * access property.
+     * @param force By default, this only fetches access if it hasn't already
+     *              been set on the model. If you want to force a refresh
+     *              anyway, set this param to true.
+     */
+    fetchAccess: function (force) {
+        if (this.altUrl === null && this.resourceName === null) {
+            throw new Error('An altUrl or resourceName must be set on the Model.');
+        }
+
+        if (!this.get('access') || force) {
+            return restRequest({
+                url: `${this.altUrl || this.resourceName}/${this.id}/access`,
+                method: 'GET'
+            }).done((resp) => {
+                if (resp.access) {
+                    this.set(resp);
+                } else {
+                    this.set('access', resp);
+                }
+                this.trigger('g:accessFetched');
+                return resp;
+            }).fail((err) => {
+                this.trigger('g:error', err);
+            });
+        } else {
+            this.trigger('g:accessFetched');
+            return $.Deferred().resolve(this.get('access')).promise();
+        }
+    }
+});
+
+export default AccessControlledModel;

package/dist-lib/src/models/ApiKeyModel.js

@@ -0,0 +1,31 @@
+import AccessControlledModel from '@girder/core/models/AccessControlledModel';
+import { restRequest } from '@girder/core/rest';
+
+var ApiKeyModel = AccessControlledModel.extend({
+    resourceName: 'api_key',
+
+    setActive: function (active) {
+        return restRequest({
+            url: `api_key/${this.id}`,
+            method: 'PUT',
+            data: {
+                active: active
+            }
+        }).done(() => {
+            this.set({ active: active });
+            this.trigger('g:setActive');
+        });
+    },
+
+    save: function () {
+        // Scope needs to be sent to the server as JSON
+        var scope = this.get('scope');
+        this.set('scope', JSON.stringify(scope), { silent: true }); // eslint-disable-line backbone/no-silent
+        var promise = AccessControlledModel.prototype.save.call(this, arguments);
+        // Restore scope to its original state
+        this.set('scope', scope, { silent: true }); // eslint-disable-line backbone/no-silent
+        return promise;
+    }
+});
+
+export default ApiKeyModel;

package/dist-lib/src/models/AssetstoreModel.js

@@ -0,0 +1,43 @@
+import _ from 'underscore';
+
+import { formatSize } from '@girder/core/misc';
+import Model from '@girder/core/models/Model';
+import { restRequest } from '@girder/core/rest';
+
+var AssetstoreModel = Model.extend({
+    resourceName: 'assetstore',
+
+    capacityKnown: function () {
+        var cap = this.get('capacity');
+        return cap && cap.free !== null && cap.total !== null;
+    },
+
+    capacityString: function () {
+        var cap = this.get('capacity');
+        return formatSize(cap.free) + ' free of ' +
+            formatSize(cap.total) + ' total';
+    },
+
+    import: function (params) {
+        return restRequest({
+            url: `assetstore/${this.id}/import`,
+            method: 'POST',
+            data: params,
+            error: null
+        }).done((resp) => {
+            this.trigger('g:imported', resp);
+        }).fail((resp) => {
+            this.trigger('g:error', resp);
+        });
+    },
+
+    save: function () {
+        if (_.isNumber(this.get('perms'))) {
+            // Coerce to an octal string to disambiguate
+            this.set('perms', this.get('perms').toString(8));
+        }
+        return Model.prototype.save.call(this, arguments);
+    }
+});
+
+export default AssetstoreModel;