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

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

@@ -0,0 +1,20 @@
+import AccessControlledModel from '@girder/core/models/AccessControlledModel';
+import { restRequest } from '@girder/core/rest';
+
+var CollectionCreationPolicyModel = AccessControlledModel.extend({
+    resourceName: 'system/setting/collection_creation_policy',
+    fetchAccess: function () {
+        return restRequest({
+            url: `${this.resourceName}/access`,
+            method: 'GET'
+        }).done((resp) => {
+            this.set('access', resp);
+            this.trigger('g:accessFetched');
+            return resp;
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    }
+});
+
+export default CollectionCreationPolicyModel;

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

@@ -0,0 +1,12 @@
+import _ from 'underscore';
+
+import AccessControlledModel from '@girder/core/models/AccessControlledModel';
+import MetadataMixin from '@girder/core/models/MetadataMixin';
+
+var CollectionModel = AccessControlledModel.extend({
+    resourceName: 'collection'
+});
+
+_.extend(CollectionModel.prototype, MetadataMixin);
+
+export default CollectionModel;

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

@@ -0,0 +1,310 @@
+import _ from 'underscore';
+
+import FolderModel from '@girder/core/models/FolderModel';
+import ItemModel from '@girder/core/models/ItemModel';
+import Model from '@girder/core/models/Model';
+import { restRequest, uploadHandlers, getUploadChunkSize } from '@girder/core/rest';
+import '@girder/core/utilities/S3UploadHandler'; // imported for side effect
+
+var FileModel = Model.extend({
+    resourceName: 'file',
+    resumeInfo: null,
+
+    _wrapData: function (data, type) {
+        var wrapped = data;
+
+        if (!(data instanceof Blob)) {
+            if (!_.isArray(data)) {
+                wrapped = [data];
+            }
+            wrapped = new Blob(wrapped, {
+                type: type
+            });
+        }
+
+        return wrapped;
+    },
+
+    /**
+     * Upload into an existing file object (i.e. this model) to change its
+     * contents. This does not change the name or MIME type of the existing
+     * file.
+     * @param data A browser File object, browser Blob object, or raw data to be uploaded.
+     */
+    updateContents: function (data) {
+        data = this._wrapData(data);
+
+        this.upload(null, data, {
+            url: `file/${this.id}/contents`,
+            method: 'PUT',
+            data: {
+                size: data.size
+            }
+        });
+    },
+
+    /**
+     * Upload data to a new file in a given container
+     * @param Model A constructor for the parent model (either FolderModel or ItemModel).
+     * @param model The parent model to upload to, or a string containing the id thereof.
+     * @param data The data to upload - either a string, File object, or Blob object.
+     * @param name The name of the file to create (optional if data is a File).
+     * @param type The mime type of the file (optional).
+     */
+    _uploadToContainer: function (Model, model, data, name, type) {
+        if (_.isString(model)) {
+            model = new Model({
+                _id: model
+            });
+        }
+
+        data = this._wrapData(data, type);
+        data.name = name;
+
+        this.upload(model, data);
+    },
+
+    /**
+     * Upload data to a new file in a given folder
+     * @param parentFolder The parent folder to upload to, or a string containing the id thereof.
+     * @param data The data to upload - either a string, File object, or Blob object.
+     * @param name The name of the file to create (optional if data is a File).
+     * @param type The mime type of the file (optional).
+     */
+    uploadToFolder: function (parentFolder, data, name, type) {
+        this._uploadToContainer(FolderModel, parentFolder, data, name, type);
+    },
+
+    /**
+     * Upload data to a new file in a given folder
+     * @param parentItem The parent item to upload to, or a string containing the id thereof.
+     * @param data The data to upload - either a string, File object, or Blob object.
+     * @param name The name of the file to create (optional if data is a File).
+     * @param type The mime type of the file (optional).
+     */
+    uploadToItem: function (parentItem, data, name, type) {
+        this._uploadToContainer(ItemModel, parentItem, data, name, type);
+    },
+
+    /**
+     * Upload a file. Handles uploading into all of the core assetstore types.
+     * @param parentModel The parent folder or item to upload into.
+     * @param file The browser File object to be uploaded.
+     * @param [_restParams] Override the rest request parameters. This is meant
+     * for internal use; do not pass this parameter.
+     * @param [otherParams] Optional Object containing other parameters for the
+     * initUpload request.
+     */
+    upload: function (parentModel, file, _restParams, otherParams) {
+        this.startByte = 0;
+        this.resumeInfo = null;
+        this.uploadHandler = null;
+        _restParams = _restParams || {
+            url: 'file',
+            method: 'POST',
+            data: _.extend({
+                parentType: parentModel.resourceName,
+                parentId: parentModel.get('_id'),
+                name: file.name,
+                size: file.size,
+                mimeType: file.type
+            }, otherParams)
+        };
+
+        // Authenticate and generate the upload token for this file
+        restRequest(_restParams).done((upload) => {
+            var behavior = upload.behavior;
+            if (behavior && uploadHandlers[behavior]) {
+                this.uploadHandler = new uploadHandlers[behavior]({
+                    upload: upload,
+                    parentModel: parentModel,
+                    file: file
+                });
+                this.uploadHandler.on({
+                    'g:upload.complete': function (params) {
+                        this.set(params);
+                        this.trigger('g:upload.complete', params);
+                        this.uploadHandler = null;
+                    },
+                    'g:upload.chunkSent': function (params) {
+                        this.trigger('g:upload.chunkSent', params);
+                    },
+                    'g:upload.error': function (params) {
+                        this.trigger('g:upload.error', params);
+                    },
+                    'g:upload.errorStarting': function (params) {
+                        this.trigger('g:upload.errorStarting', params);
+                    },
+                    'g:upload.progress': function (params) {
+                        this.trigger('g:upload.progress', {
+                            startByte: params.startByte,
+                            loaded: params.loaded,
+                            total: params.file.size,
+                            file: params.file
+                        });
+                    }
+                }, this);
+                return this.uploadHandler.execute();
+            }
+
+            if (file.size > 0) {
+                // Begin uploading chunks of this file
+                this._uploadChunk(file, upload._id);
+            } else {
+                // Empty file, so we are done
+                this.set(upload);
+                this.trigger('g:upload.complete');
+            }
+        }).fail((resp) => {
+            var text = 'Error: ', identifier;
+
+            if (resp.status === 0) {
+                text += 'Connection to the server interrupted.';
+            } else {
+                text += resp.responseJSON.message;
+                identifier = resp.responseJSON.identifier;
+            }
+            this.trigger('g:upload.errorStarting', {
+                message: text,
+                identifier: identifier,
+                response: resp
+            });
+        });
+    },
+
+    /**
+     * If an error was triggered during the upload of this file, call this
+     * in order to attempt to resume it.
+     */
+    resumeUpload: function () {
+        if (this.uploadHandler !== null && this.uploadHandler.resume) {
+            return this.uploadHandler.resume();
+        }
+
+        // Request the actual offset we need to resume at
+        restRequest({
+            url: 'file/offset',
+            method: 'GET',
+            data: {
+                uploadId: this.resumeInfo.uploadId
+            },
+            error: null
+        }).done((resp) => {
+            this.startByte = resp.offset;
+            this._uploadChunk(this.resumeInfo.file, this.resumeInfo.uploadId);
+        }).fail((resp) => {
+            var msg;
+
+            if (resp.status === 0) {
+                msg = 'Could not connect to the server.';
+            } else {
+                msg = 'An error occurred when resuming upload, check console.';
+            }
+            this.trigger('g:upload.error', {
+                message: msg,
+                response: resp
+            });
+        });
+    },
+
+    abortUpload: function () {
+        if (!this.resumeInfo || !this.resumeInfo.uploadId) {
+            return;
+        }
+        restRequest({
+            url: 'system/uploads',
+            method: 'DELETE',
+            data: {
+                uploadId: this.resumeInfo.uploadId
+            },
+            error: null,
+            done: null
+        });
+    },
+
+    _uploadChunk: function (file, uploadId) {
+        var endByte = Math.min(this.startByte + getUploadChunkSize(), file.size);
+
+        this.chunkLength = endByte - this.startByte;
+        var sliceFn = file.webkitSlice ? 'webkitSlice' : 'slice';
+        var blob = file[sliceFn](this.startByte, endByte);
+
+        restRequest({
+            url: `file/chunk?offset=${this.startByte}&uploadId=${uploadId}`,
+            method: 'POST',
+            data: blob,
+            contentType: false,
+            processData: false,
+            success: (resp) => {
+                this.trigger('g:upload.chunkSent', {
+                    bytes: endByte - this.startByte
+                });
+
+                if (endByte === file.size) {
+                    this.startByte = 0;
+                    this.resumeInfo = null;
+                    this.set(resp);
+                    this.trigger('g:upload.complete');
+                } else {
+                    this.startByte = endByte;
+                    this._uploadChunk(file, uploadId);
+                }
+            },
+            error: (resp) => {
+                var text = 'Error: ', identifier;
+
+                if (resp.status === 0) {
+                    text += 'Connection to the server interrupted.';
+                } else {
+                    text += resp.responseJSON.message;
+                    identifier = resp.responseJSON.identifier;
+                }
+
+                this.resumeInfo = {
+                    uploadId: uploadId,
+                    file: file
+                };
+
+                this.trigger('g:upload.error', {
+                    message: text,
+                    identifier: identifier,
+                    response: resp
+                });
+            },
+            xhr: () => {
+                // Custom XHR so we can register a progress handler
+                var xhr = new window.XMLHttpRequest();
+                xhr.upload.addEventListener('progress', (e) => {
+                    this._uploadProgress(file, e);
+                });
+                return xhr;
+            }
+        });
+    },
+
+    /**
+     * Progress callback from XHR during upload. This will trigger useful
+     * progress events under the 'upload.progress' tag.
+     */
+    _uploadProgress: function (file, event) {
+        if (!event.lengthComputable) {
+            return;
+        }
+
+        // We only want to count bytes of the actual file, not the bytes of
+        // the request body corresponding to the other form parameters model
+        // we are also sending.
+        var loaded = this.chunkLength + event.loaded - event.total;
+
+        if (loaded >= 0) {
+            this.trigger('g:upload.progress', {
+                startByte: this.startByte,
+                loaded: loaded,
+                total: file.size,
+                file: file
+            });
+        }
+    }
+});
+
+export default FileModel;

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

@@ -0,0 +1,33 @@
+import _ from 'underscore';
+
+import AccessControlledModel from '@girder/core/models/AccessControlledModel';
+import MetadataMixin from '@girder/core/models/MetadataMixin';
+import { restRequest } from '@girder/core/rest';
+
+var FolderModel = AccessControlledModel.extend({
+    resourceName: 'folder',
+
+    getRootPath: function () {
+        return restRequest({
+            url: `${this.resourceName}/${this.id}/rootpath`
+        });
+    },
+
+    /**
+     * Remove the contents of the folder.
+     */
+    removeContents: function () {
+        return restRequest({
+            url: `${this.resourceName}/${this.id}/contents`,
+            method: 'DELETE'
+        }).done(() => {
+            this.trigger('g:success');
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    }
+});
+
+_.extend(FolderModel.prototype, MetadataMixin);
+
+export default FolderModel;

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

@@ -0,0 +1,197 @@
+import _ from 'underscore';
+
+import AccessControlledModel from '@girder/core/models/AccessControlledModel';
+import { AccessType } from '@girder/core/constants';
+import { getCurrentUser } from '@girder/core/auth';
+import { restRequest } from '@girder/core/rest';
+
+var GroupModel = AccessControlledModel.extend({
+    resourceName: 'group',
+
+    /**
+     * Send an invitation to this group to the user identified by userId.
+     * Requires moderator (write) access on the group.
+     * @param userId The ID of the user to invite.
+     * @param accessType The access level to invite them as.
+     * @param request Set to true if this is accepting a user's request to join.
+     * @param [params] Additional parameters to pass with the request.
+     */
+    sendInvitation: function (userId, accessType, request, params) {
+        params = params || {};
+        return restRequest({
+            url: `${this.resourceName}/${this.id}/invitation`,
+            data: _.extend({
+                userId: userId,
+                level: accessType
+            }, params),
+            method: 'POST',
+            error: null
+        }).done((resp) => {
+            this.set(resp);
+
+            if (!request && userId === getCurrentUser().get('_id')) {
+                if (params.force) {
+                    getCurrentUser().addToGroup(this.get('_id'));
+                } else {
+                    getCurrentUser().addInvitation(this.get('_id'), accessType);
+                }
+            }
+            this.trigger('g:invited');
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    /**
+     * Accept an invitation to join a group. Only call this if the user has
+     * already been invited to the group.
+     */
+    joinGroup: function () {
+        return restRequest({
+            url: `${this.resourceName}/${this.id}/member`,
+            method: 'POST'
+        }).done((resp) => {
+            getCurrentUser().addToGroup(this.get('_id'));
+            getCurrentUser().removeInvitation(this.get('_id'));
+
+            this.set(resp);
+
+            this.trigger('g:joined');
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    /**
+     * This will create an invitation request on this group for the current
+     * user. Requires read access on the group. If the user already has an
+     * outstanding invitation to this group, call joinGroup instead.
+     */
+    requestInvitation: function () {
+        return restRequest({
+            url: `${this.resourceName}/${this.id}/member`,
+            method: 'POST'
+        }).done((resp) => {
+            this.set(resp);
+
+            this.trigger('g:inviteRequested');
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    /**
+     * Promote a user to moderator or administrator. Requires admin access
+     * on the group.
+     * @param user The user model of the user being promoted
+     * @param level The AccessLevel (WRITE or ADMIN) to promote to
+     */
+    promoteUser: function (user, level) {
+        var role;
+        if (level === AccessType.WRITE) {
+            role = 'moderator';
+        } else if (level === AccessType.ADMIN) {
+            role = 'admin';
+        }
+        return restRequest({
+            url: `${this.resourceName}/${this.id}/${role}`,
+            data: {
+                userId: user.get('_id')
+            },
+            method: 'POST'
+        }).done((resp) => {
+            this.set(resp);
+
+            this.trigger('g:promoted');
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    /**
+     * Demote a user to ordinary member status. Requires admin access on the
+     * group.
+     * @param userId The id of the user to demote.
+     * @param level The current access level of the user.
+     */
+    demoteUser: function (userId, level) {
+        var role;
+        if (level === AccessType.WRITE) {
+            role = 'moderator';
+        } else if (level === AccessType.ADMIN) {
+            role = 'admin';
+        }
+        return restRequest({
+            url: `${this.resourceName}/${this.id}/${role}?userId=${userId}`,
+            method: 'DELETE'
+        }).done((resp) => {
+            this.set(resp);
+
+            this.trigger('g:demoted');
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    /**
+     * Remove a member of a group, or if the user is not already a member,
+     * this will simply delete any outstanding membership request or
+     * invitation for this user.
+     * @param userId The ID of the user to remove.
+     */
+    removeMember: function (userId) {
+        return restRequest({
+            url: `${this.resourceName}/${this.id}/member?userId=${userId}`,
+            method: 'DELETE'
+        }).done((resp) => {
+            if (userId === getCurrentUser().get('_id')) {
+                getCurrentUser().removeFromGroup(this.get('_id'));
+            }
+
+            this.set(resp);
+
+            this.trigger('g:removed');
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    /* Check if the current user has the authority in this group to directly
+     * add members.
+     *
+     * @returns: true if adding members is allowed.
+     */
+    mayAddMembers: function () {
+        if (getCurrentUser().get('admin')) {
+            return true;
+        }
+        var groupAddAllowed;
+        var addToGroupPolicy = this.get('_addToGroupPolicy');
+        if (addToGroupPolicy === 'nomod' || addToGroupPolicy === 'yesmod') {
+            groupAddAllowed = 'mod';
+        } else if (addToGroupPolicy === 'noadmin' || addToGroupPolicy === 'yesadmin') {
+            groupAddAllowed = 'admin';
+        } else {
+            return false;
+        }
+        var addAllowed = this.get('addAllowed') || '';
+        if (addAllowed === 'no' || (addToGroupPolicy.substr(0, 3) !== 'yes' &&
+                addAllowed.substr(0, 3) !== 'yes')) {
+            return false;
+        }
+        if (addAllowed === 'yesadmin') {
+            groupAddAllowed = 'admin';
+        }
+        if (groupAddAllowed === 'admin' &&
+                this.get('_accessLevel') >= AccessType.ADMIN) {
+            return true;
+        }
+        if (groupAddAllowed === 'mod' &&
+                this.get('_accessLevel') >= AccessType.WRITE) {
+            return true;
+        }
+        return false;
+    }
+});
+
+export default GroupModel;

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

@@ -0,0 +1,72 @@
+import $ from 'jquery';
+import _ from 'underscore';
+
+import FileCollection from '@girder/core/collections/FileCollection';
+import FolderModel from '@girder/core/models/FolderModel';
+import MetadataMixin from '@girder/core/models/MetadataMixin';
+import Model from '@girder/core/models/Model';
+import { restRequest } from '@girder/core/rest';
+
+var ItemModel = Model.extend({
+    resourceName: 'item',
+
+    /**
+     * Get the access level of the item if it is set. Takes an optional callback
+     * to be called once the access level is fetched (or immediately if it has
+     * already been fetched).
+     */
+    getAccessLevel: function (callback) {
+        callback = callback || $.noop;
+
+        if (this.has('_accessLevel')) {
+            callback(this.get('_accessLevel'));
+            return this.get('_accessLevel');
+        }
+        if (this.parent && this.parent.getAccessLevel()) {
+            this.set('_accessLevel', this.parent.getAccessLevel());
+            callback(this.get('_accessLevel'));
+            return this.get('_accessLevel');
+        } else {
+            var parent = new FolderModel();
+            parent.set({
+                _id: this.get('folderId')
+            }).once('g:fetched', function () {
+                this.parent = parent;
+                this.set('_accessLevel', this.parent.getAccessLevel());
+                callback(this.get('_accessLevel'));
+            }, this).fetch();
+        }
+    },
+
+    /**
+     * Get the path to the root of the hierarchy
+     */
+    getRootPath: function (callback) {
+        return restRequest({
+            url: `${this.resourceName}/${this.id}/rootpath`
+        }).done((resp) => {
+            callback(resp);
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    },
+
+    /**
+     * Get the files within the item.
+     */
+    getFiles: function () {
+        return restRequest({
+            url: `${this.resourceName}/${this.id}/files`
+        }).then((resp) => {
+            const fileCollection = new FileCollection(resp);
+            this.trigger('g:files', fileCollection);
+            return fileCollection;
+        }).fail((err) => {
+            this.trigger('g:error', err);
+        });
+    }
+});
+
+_.extend(ItemModel.prototype, MetadataMixin);
+
+export default ItemModel;