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

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

@@ -0,0 +1,88 @@
+import _ from 'underscore';
+
+import { restRequest } from '@girder/core/rest';
+
+var MetadataMixin = {
+    _sendMetadata: function (metadata, successCallback, errorCallback, opts) {
+        opts = opts || {};
+        restRequest({
+            url: opts.path ||
+                ((this.altUrl || this.resourceName) + `/${this.id}/metadata?allowNull=true`),
+            contentType: 'application/json',
+            data: JSON.stringify(metadata),
+            method: 'PUT',
+            error: null
+        }).done((resp) => {
+            this.set(opts.field || 'meta', resp.meta);
+            if (_.isFunction(successCallback)) {
+                successCallback();
+            }
+        }).fail((err) => {
+            err.message = err.responseJSON.message;
+            if (_.isFunction(errorCallback)) {
+                errorCallback(err);
+            }
+        });
+    },
+
+    addMetadata: function (key, value, successCallback, errorCallback, opts) {
+        opts = opts || {};
+        var datum = {};
+        datum[key] = value;
+        var meta = this.get(opts.field || 'meta');
+        if (meta && _.has(meta, key)) {
+            if (_.isFunction(errorCallback)) {
+                errorCallback({ message: key + ' is already a metadata key' });
+            }
+        } else {
+            this._sendMetadata(datum, successCallback, errorCallback, opts);
+        }
+    },
+
+    removeMetadata: function (key, successCallback, errorCallback, opts) {
+        if (!_.isArray(key)) {
+            key = [key];
+        }
+        restRequest({
+            url: opts.path ||
+                ((this.altUrl || this.resourceName) + `/${this.id}/metadata`),
+            contentType: 'application/json',
+            data: JSON.stringify(key),
+            method: 'DELETE',
+            error: null
+        }).done((resp) => {
+            this.set(opts.field || 'meta', resp.meta);
+            if (_.isFunction(successCallback)) {
+                successCallback();
+            }
+        }).fail((err) => {
+            err.message = err.responseJSON.message;
+            if (_.isFunction(errorCallback)) {
+                errorCallback(err);
+            }
+        });
+    },
+
+    editMetadata: function (newKey, oldKey, value, successCallback, errorCallback, opts) {
+        opts = opts || {};
+
+        if (newKey === oldKey) {
+            var datum = {};
+            datum[newKey] = value;
+            this._sendMetadata(datum, successCallback, errorCallback, opts);
+        } else {
+            if (_.has(this.get(opts.field || 'meta'), newKey)) {
+                if (_.isFunction(errorCallback)) {
+                    errorCallback({ message: newKey + ' is already a metadata key' });
+                }
+            } else {
+                var metas = {};
+                metas[oldKey] = null;
+                metas[newKey] = value;
+                this._sendMetadata(metas, successCallback, errorCallback, opts);
+            }
+        }
+    }
+};
+
+export default MetadataMixin;

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

@@ -0,0 +1,187 @@
+import $ from 'jquery';
+import _ from 'underscore';
+import Backbone from 'backbone';
+
+import { restRequest, getApiRoot } from '@girder/core/rest';
+
+/**
+ * All models should descend from this base model, which provides a number
+ * of utilities for synchronization.
+ */
+var Model = Backbone.Model.extend({
+    resourceName: null,
+    altUrl: null,
+    idAttribute: '_id',
+
+    /**
+     * Convenience method for incrementing numeric properties.
+     * @param {string} attr The attribute to increment.
+     * @param {number} [amount] The amount to increment by. Defaults to 1.
+     */
+    increment: function (attr, amount) {
+        if (amount === undefined) {
+            amount = 1;
+        }
+        if (!amount) {
+            return;
+        }
+        return this.set(attr, this.get(attr) + amount);
+    },
+
+    /**
+     * Get the name for this resource. By default, just the name attribute.
+     */
+    name: function () {
+        return this.get('name');
+    },
+
+    /**
+     * Save this model to the server. If this is a new model, meaning it has no
+     * _id attribute, this will create it. If the _id is set, we update the
+     * existing model. Triggers g:saved on success, and g:error on error.
+     */
+    save: function () {
+        if (this.altUrl === null && this.resourceName === null) {
+            throw new Error('An altUrl or resourceName must be set on the Model.');
+        }
+
+        var path, type;
+        if (this.has('_id')) {
+            path = (this.altUrl || this.resourceName) + '/' + this.get('_id');
+            type = 'PUT';
+        } else {
+            path = (this.altUrl || this.resourceName);
+            type = 'POST';
+        }
+        /* Don't save attributes which are objects using this call.  For
+         * instance, if the metadata of an item has keys that contain non-ascii
+         * values, they won't get handled by the rest call. */
+        var data = {};
+        _.each(this.keys(), function (key) {
+            var value = this.get(key);
+            if (!_.isObject(value)) {
+                data[key] = value;
+            }
+        }, this);
+
+        return restRequest({
+            url: path,
+            method: type,
+            data: data,
+            error: null // don't do default error behavior (validation may fail)
+        }).done((resp) => {
+            this.set(resp);
+            this.trigger('g:saved');
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    /**
+     * Fetch a single resource from the server. Triggers g:fetched on success,
+     * or g:error on error.
+     *
+     * @param {object|undefined} opts: additional options, which can include:
+     *     ignoreError: true - ignore the default error handler
+     *     extraPath - a string to append to the end of the resource URL
+     *     data - a dictionary of parameters to pass to the endpoint.
+     */
+    fetch: function (opts) {
+        if (this.altUrl === null && this.resourceName === null) {
+            throw new Error('An altUrl or resourceName must be set on the Model.');
+        }
+
+        opts = opts || {};
+        var restOpts = {
+            url: `${this.altUrl || this.resourceName}/${this.id}`
+        };
+        if (opts.extraPath) {
+            restOpts.url += '/' + opts.extraPath;
+        }
+        if (opts.ignoreError) {
+            restOpts.error = null;
+        }
+        if (opts.data) {
+            restOpts.data = opts.data;
+        }
+        return restRequest(restOpts).done((resp) => {
+            this.set(resp);
+            if (opts.extraPath) {
+                this.trigger('g:fetched.' + opts.extraPath);
+            } else {
+                this.trigger('g:fetched');
+            }
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    /**
+     * Get the path for downloading this resource via the API. Can be used
+     * as the href property of a direct download link.
+     * @param params {Object} list of key-value parameters to include in the
+     *    query string.
+     */
+    downloadUrl: function (params) {
+        let url = `${getApiRoot()}/${this.altUrl || this.resourceName}/${this.id}/download`;
+
+        if (params) {
+            url += '?' + $.param(params);
+        }
+
+        return url;
+    },
+
+    /**
+     * For models that can be downloaded, this method can be used to
+     * initiate the download in the browser.
+     */
+    download: function () {
+        window.location.assign(this.downloadUrl());
+    },
+
+    /**
+     * Delete the model on the server.
+     * @param opts Options, may contain:
+     *   throwError Whether to throw an error (bool, default=true)
+     *   progress Whether to record progress (bool, default=false)
+     */
+    destroy: function (opts) {
+        if (this.altUrl === null && this.resourceName === null) {
+            throw new Error('An altUrl or resourceName must be set on the Model.');
+        }
+
+        var args = {
+            url: `${this.altUrl || this.resourceName}/${this.id}`,
+            method: 'DELETE'
+        };
+
+        opts = opts || {};
+        if (opts.progress === true) {
+            args.url += '?progress=true';
+        }
+
+        if (opts.throwError !== false) {
+            args.error = null;
+        }
+
+        return restRequest(args).done(() => {
+            if (this.collection) {
+                this.collection.remove(this);
+            }
+            this.trigger('g:deleted');
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    /**
+     * Return the access level with respect to the current user
+     */
+    getAccessLevel: function () {
+        return this.get('_accessLevel');
+    }
+
+});
+
+export default Model;

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

@@ -0,0 +1,189 @@
+import _ from 'underscore';
+
+import { fetchCurrentUser, setCurrentToken, setCurrentUser } from '@girder/core/auth';
+import events from '@girder/core/events';
+import Model from '@girder/core/models/Model';
+import { restRequest } from '@girder/core/rest';
+import eventStream from '@girder/core/utilities/EventStream';
+
+var UserModel = Model.extend({
+    resourceName: 'user',
+
+    /**
+     * Calling this function mutates the model in one of two ways: (1) if a user
+     * is currently logged into Girder, the model will reflect that user; (2) if
+     * no user is logged in, the model will become clear.  To know which path
+     * occurred, you can call this method, then install a one-time event handler
+     * for the model's change event.  In that handler, calling isNew() on the
+     * model will tell if you if a user is logged in (false) or not (true).
+     *
+     * This is equivalent to invoking fetchCurrentUser(), then calling
+     * clear() or set() on the model depending on whether the result of the call
+     * is null or not.
+     */
+    current: function () {
+        fetchCurrentUser()
+            .done((user) => {
+                if (user) {
+                    this.set(user);
+                } else {
+                    this.clear();
+                }
+            });
+    },
+
+    name: function () {
+        return this.get('firstName') + ' ' + this.get('lastName');
+    },
+
+    /**
+     * When this user is added to a group, call this on the user model.
+     */
+    addToGroup: function (groupId) {
+        var groups = this.get('groups') || [];
+        groups.push(groupId);
+        this.set('groups', groups);
+    },
+
+    /**
+     * When this user is removed from a group, call this on the user model.
+     */
+    removeFromGroup: function (groupId) {
+        var groups = this.get('groups') || [];
+        var index = groups.indexOf(groupId);
+
+        while (index >= 0) {
+            groups.splice(index, 1);
+            index = groups.indexOf(groupId);
+        }
+
+        this.set('groups', groups);
+    },
+
+    /**
+     * When this user is invited to a group, call this on the user model.
+     */
+    addInvitation: function (groupId, level) {
+        var invites = this.get('groupInvites') || [];
+        invites.push({
+            groupId: groupId,
+            level: level
+        });
+
+        this.set('groupInvites', invites);
+    },
+
+    /**
+     * When this user's invitation is deleted, either by joining the group or
+     * having the invitation deleted manually, this should be called on the user
+     * model.
+     */
+    removeInvitation: function (groupId) {
+        var invites = this.get('groupInvites') || [];
+        var filtered = _.reject(invites, _.matcher({ groupId: groupId }));
+
+        this.set('groupInvites', filtered);
+    },
+
+    /**
+     * Change the password for this user.
+     */
+    changePassword: function (oldPassword, newPassword) {
+        return restRequest({
+            url: `${this.resourceName}/password`,
+            data: {
+                old: oldPassword,
+                new: newPassword
+            },
+            method: 'PUT',
+            error: null
+        }).done(() => {
+            this.trigger('g:passwordChanged');
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    /**
+     * Change the password for another user (as an admin).
+     */
+    adminChangePassword: function (newPassword) {
+        return restRequest({
+            url: `${this.resourceName}/${this.id}/password`,
+            data: {
+                password: newPassword
+            },
+            method: 'PUT',
+            error: null
+        }).done(() => {
+            this.trigger('g:passwordChanged');
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    initializeEnableOtp: function () {
+        return restRequest({
+            url: `user/${this.id}/otp`,
+            method: 'POST',
+            error: null
+        })
+            .then((resp) => {
+                return resp.totpUri;
+            });
+    },
+
+    finializeEnableOtp: function (otpToken) {
+        return restRequest({
+            url: `user/${this.id}/otp`,
+            method: 'PUT',
+            headers: {
+                'Girder-OTP': otpToken
+            },
+            error: null
+        })
+            .done(() => {
+                this.set('otp', true);
+            });
+    },
+
+    disableOtp: function () {
+        return restRequest({
+            url: `user/${this.id}/otp`,
+            method: 'DELETE',
+            error: null
+        })
+            .done(() => {
+                this.set('otp', false);
+            });
+    }
+}, {
+    fromTemporaryToken: function (userId, token) {
+        return restRequest({
+            url: `user/password/temporary/${userId}`,
+            method: 'GET',
+            data: { token: token },
+            error: null
+        }).done((resp) => {
+            resp.user.token = resp.authToken.token;
+            eventStream.close();
+            setCurrentUser(new UserModel(resp.user));
+            setCurrentToken(resp.authToken.token);
+            eventStream.open();
+            events.trigger('g:login-changed');
+        });
+    },
+
+    sendVerificationEmail: function (login) {
+        return restRequest({
+            url: 'user/verification',
+            method: 'POST',
+            data: {
+                login: login
+            },
+            error: null
+        });
+    }
+});
+
+export default UserModel;

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

@@ -0,0 +1,25 @@
+import AccessControlledModel from './AccessControlledModel';
+import ApiKeyModel from './ApiKeyModel';
+import AssetstoreModel from './AssetstoreModel';
+import CollectionModel from './CollectionModel';
+import FileModel from './FileModel';
+import FolderModel from './FolderModel';
+import GroupModel from './GroupModel';
+import ItemModel from './ItemModel';
+import MetadataMixin from './MetadataMixin';
+import Model from './Model';
+import UserModel from './UserModel';
+
+export {
+    AccessControlledModel,
+    ApiKeyModel,
+    AssetstoreModel,
+    CollectionModel,
+    FileModel,
+    FolderModel,
+    GroupModel,
+    ItemModel,
+    MetadataMixin,
+    Model,
+    UserModel
+};

package/dist-lib/src/pluginUtils.js

@@ -0,0 +1,11 @@
+/**
+ * Expose the symbols for a girder plugin under the window.girder.plugins
+ * namespace. Required since each plugin is loaded dynamically.
+ */
+var registerPluginNamespace = function (pluginName, symbols) {
+    window.girder.plugins[pluginName] = symbols;
+};
+
+export {
+    registerPluginNamespace
+};