nextcloud/core/js/shareitemmodel.js

795 lines
20 KiB
JavaScript
Raw Normal View History

/*
* Copyright (c) 2015
*
* This file is licensed under the Affero General Public License version 3
* or later.
*
* See the COPYING-README file.
*
*/
(function() {
if(!OC.Share) {
OC.Share = {};
OC.Share.Types = {};
}
2015-09-03 16:53:17 +03:00
/**
* @typedef {object} OC.Share.Types.LinkShareInfo
* @property {bool} isLinkShare
* @property {string} token
* @property {string|null} password
* @property {string} link
* @property {number} permissions
2015-09-04 16:31:45 +03:00
* @property {Date} expiration
* @property {number} stime share time
2015-09-03 16:53:17 +03:00
*/
/**
* @typedef {object} OC.Share.Types.Collection
* @property {string} item_type
* @property {string} path
* @property {string} item_source TODO: verify
*/
/**
* @typedef {object} OC.Share.Types.Reshare
* @property {string} uid_owner
* @property {number} share_type
* @property {string} share_with
* @property {string} displayname_owner
* @property {number} permissions
*/
/**
* @typedef {object} OC.Share.Types.ShareInfo
* @property {number} share_type
* @property {number} permissions
* @property {number} file_source optional
* @property {number} item_source
* @property {string} token
* @property {string} share_with
* @property {string} share_with_displayname
* @property {string} mail_send
* @property {OC.Share.Types.Collection|undefined} collection
* @property {Date} expiration optional?
* @property {number} stime optional?
*/
/**
* @typedef {object} OC.Share.Types.ShareItemInfo
* @property {OC.Share.Types.Reshare} reshare
* @property {OC.Share.Types.ShareInfo[]} shares
2015-09-03 16:53:17 +03:00
* @property {OC.Share.Types.LinkShareInfo|undefined} linkShare
*/
/**
* These properties are sometimes returned by the server as strings instead
* of integers, so we need to convert them accordingly...
*/
var SHARE_RESPONSE_INT_PROPS = [
'id', 'file_parent', 'mail_send', 'file_source', 'item_source', 'permissions',
2015-09-24 13:21:19 +03:00
'storage', 'share_type', 'parent', 'stime'
];
/**
* @class OCA.Share.ShareItemModel
* @classdesc
*
* Represents the GUI of the share dialogue
*
* // FIXME: use OC Share API once #17143 is done
*
* // TODO: this really should be a collection of share item models instead,
* where the link share is one of them
*/
var ShareItemModel = OC.Backbone.Model.extend({
initialize: function(attributes, options) {
if(!_.isUndefined(options.configModel)) {
this.configModel = options.configModel;
}
2015-09-03 16:53:17 +03:00
if(!_.isUndefined(options.fileInfoModel)) {
/** @type {OC.Files.FileInfo} **/
this.fileInfoModel = options.fileInfoModel;
}
2015-09-05 03:02:55 +03:00
_.bindAll(this, 'addShare');
},
defaults: {
allowPublicUploadStatus: false,
2015-09-03 16:53:17 +03:00
permissions: 0,
linkShare: {}
},
/**
* Saves the current link share information.
*
* This will trigger an ajax call and refetch the model afterwards.
*
* TODO: this should be a separate model
*/
saveLinkShare: function(attributes, options) {
var model = this;
var itemType = this.get('itemType');
var itemSource = this.get('itemSource');
// TODO: use backbone's default value mechanism once this is a separate model
var requiredAttributes = [
{ name: 'password', defaultValue: '' },
{ name: 'permissions', defaultValue: OC.PERMISSION_READ },
{ name: 'expiration', defaultValue: this.configModel.getDefaultExpirationDateString() }
];
attributes = attributes || {};
// get attributes from the model and fill in with default values
_.each(requiredAttributes, function(attribute) {
// a provided options overrides a present value of the link
// share. If neither is given, the default value is used.
if(_.isUndefined(attribute[attribute.name])) {
attributes[attribute.name] = attribute.defaultValue;
var currentValue = model.get('linkShare')[attribute.name];
if(!_.isUndefined(currentValue)) {
attributes[attribute.name] = currentValue;
}
}
});
OC.Share.share(
itemType,
itemSource,
OC.Share.SHARE_TYPE_LINK,
attributes.password,
attributes.permissions,
this.fileInfoModel.get('name'),
attributes.expiration,
function(result) {
if (!result || result.status !== 'success') {
model.fetch({
success: function() {
if (options && _.isFunction(options.success)) {
options.success(model);
}
}
});
} else {
if (options && _.isFunction(options.error)) {
options.error(model);
}
}
},
function(result) {
var msg = t('core', 'Error');
if (result.data && result.data.message) {
msg = result.data.message;
}
if (options && _.isFunction(options.error)) {
options.error(model, msg);
} else {
OC.dialogs.alert(msg, t('core', 'Error while sharing'));
}
}
);
},
removeLinkShare: function() {
2015-09-14 02:24:21 +03:00
this.removeShare(OC.Share.SHARE_TYPE_LINK, '');
},
/**
* Sets the public upload flag
*
* @param {bool} allow whether public upload is allowed
*/
setPublicUpload: function(allow) {
var permissions = OC.PERMISSION_READ;
if(allow) {
permissions = OC.PERMISSION_UPDATE | OC.PERMISSION_CREATE | OC.PERMISSION_READ;
}
this.get('linkShare').permissions = permissions;
},
/**
* Sets the expiration date of the public link
*
* @param {string} expiration expiration date
*/
setExpirationDate: function(expiration) {
this.get('linkShare').expiration = expiration;
},
/**
* Set password of the public link share
*
* @param {string} password
*/
setPassword: function(password) {
this.get('linkShare').password = password;
},
addShare: function(attributes, options) {
var shareType = attributes.shareType;
var shareWith = attributes.shareWith;
2015-09-05 03:02:55 +03:00
var fileName = this.fileInfoModel.get('name');
options = options || {};
// Default permissions are Edit (CRUD) and Share
// Check if these permissions are possible
var permissions = OC.PERMISSION_READ;
if (shareType === OC.Share.SHARE_TYPE_REMOTE) {
permissions = OC.PERMISSION_CREATE | OC.PERMISSION_UPDATE | OC.PERMISSION_READ;
} else {
if (this.updatePermissionPossible()) {
permissions = permissions | OC.PERMISSION_UPDATE;
}
if (this.createPermissionPossible()) {
permissions = permissions | OC.PERMISSION_CREATE;
}
if (this.deletePermissionPossible()) {
permissions = permissions | OC.PERMISSION_DELETE;
}
if (this.configModel.get('isResharingAllowed') && (this.sharePermissionPossible())) {
permissions = permissions | OC.PERMISSION_SHARE;
}
}
var model = this;
var itemType = this.get('itemType');
var itemSource = this.get('itemSource');
OC.Share.share(itemType, itemSource, shareType, shareWith, permissions, fileName, options.expiration, function() {
model.fetch();
2015-09-05 03:02:55 +03:00
});
},
2015-09-14 03:29:22 +03:00
setPermissions: function(shareType, shareWith, permissions) {
var itemType = this.get('itemType');
var itemSource = this.get('itemSource');
// TODO: in the future, only set the permissions on the model but don't save directly
2015-09-14 03:29:22 +03:00
OC.Share.setPermissions(itemType, itemSource, shareType, shareWith, permissions);
},
2015-09-14 02:24:21 +03:00
removeShare: function(shareType, shareWith) {
var model = this;
var itemType = this.get('itemType');
var itemSource = this.get('itemSource');
OC.Share.unshare(itemType, itemSource, shareType, shareWith, function() {
model.fetch();
});
},
/**
* @returns {boolean}
*/
isPublicUploadAllowed: function() {
return this.get('allowPublicUploadStatus');
},
/**
* @returns {boolean}
*/
isFolder: function() {
return this.get('itemType') === 'folder';
},
/**
* @returns {boolean}
*/
isFile: function() {
return this.get('itemType') === 'file';
},
/**
* whether this item has reshare information
* @returns {boolean}
*/
hasReshare: function() {
var reshare = this.get('reshare');
return _.isObject(reshare) && !_.isUndefined(reshare.uid_owner);
},
/**
* whether this item has user share information
* @returns {boolean}
*/
hasUserShares: function() {
return this.getSharesWithCurrentItem().length > 0;
},
/**
* Returns whether this item has a link share
*
* @return {bool} true if a link share exists, false otherwise
*/
hasLinkShare: function() {
var linkShare = this.get('linkShare');
if (linkShare && linkShare.isLinkShare) {
return true;
}
return false;
},
/**
* @param {number} shareIndex
* @returns {string}
*/
getCollectionType: function(shareIndex) {
/** @type OC.Share.Types.ShareInfo **/
var share = this.get('shares')[shareIndex];
if(!_.isObject(share)) {
throw "Unknown Share";
} else if(_.isUndefined(share.collection)) {
throw "Share is not a collection";
}
return share.collection.item_type;
},
/**
* @param {number} shareIndex
* @returns {string}
*/
getCollectionPath: function(shareIndex) {
/** @type OC.Share.Types.ShareInfo **/
var share = this.get('shares')[shareIndex];
if(!_.isObject(share)) {
throw "Unknown Share";
} else if(_.isUndefined(share.collection)) {
throw "Share is not a collection";
}
return share.collection.path;
},
/**
* @param {number} shareIndex
* @returns {string}
*/
getCollectionSource: function(shareIndex) {
/** @type OC.Share.Types.ShareInfo **/
var share = this.get('shares')[shareIndex];
if(!_.isObject(share)) {
throw "Unknown Share";
} else if(_.isUndefined(share.collection)) {
throw "Share is not a collection";
}
return share.collection.item_source;
},
/**
* @param {number} shareIndex
* @returns {boolean}
*/
isCollection: function(shareIndex) {
/** @type OC.Share.Types.ShareInfo **/
var share = this.get('shares')[shareIndex];
if(!_.isObject(share)) {
throw "Unknown Share";
}
if(_.isUndefined(share.collection)) {
return false;
}
return true;
},
/**
* @returns {string}
*/
getReshareOwner: function() {
return this.get('reshare').uid_owner;
},
/**
* @returns {string}
*/
getReshareOwnerDisplayname: function() {
return this.get('reshare').displayname_owner;
},
/**
* @returns {string}
*/
getReshareWith: function() {
return this.get('reshare').share_with;
},
/**
* @returns {number}
*/
getReshareType: function() {
return this.get('reshare').share_type;
},
/**
* Returns all share entries that only apply to the current item
* (file/folder)
*
* @return {Array.<OC.Share.Types.ShareInfo>}
*/
getSharesWithCurrentItem: function() {
var shares = this.get('shares') || [];
var fileId = this.fileInfoModel.get('id');
return _.filter(shares, function(share) {
return share.item_source === fileId;
});
},
/**
* @param shareIndex
* @returns {string}
*/
getShareWith: function(shareIndex) {
/** @type OC.Share.Types.ShareInfo **/
var share = this.get('shares')[shareIndex];
if(!_.isObject(share)) {
throw "Unknown Share";
}
return share.share_with;
},
/**
* @param shareIndex
* @returns {string}
*/
getShareWithDisplayName: function(shareIndex) {
/** @type OC.Share.Types.ShareInfo **/
var share = this.get('shares')[shareIndex];
if(!_.isObject(share)) {
throw "Unknown Share";
}
return share.share_with_displayname;
},
getShareType: function(shareIndex) {
/** @type OC.Share.Types.ShareInfo **/
var share = this.get('shares')[shareIndex];
if(!_.isObject(share)) {
throw "Unknown Share";
}
return share.share_type;
},
/**
* whether a share from shares has the requested permission
*
* @param {number} shareIndex
* @param {number} permission
* @returns {boolean}
* @private
*/
_shareHasPermission: function(shareIndex, permission) {
/** @type OC.Share.Types.ShareInfo **/
var share = this.get('shares')[shareIndex];
if(!_.isObject(share)) {
throw "Unknown Share";
}
if( share.share_type === OC.Share.SHARE_TYPE_REMOTE
&& ( permission === OC.PERMISSION_SHARE
|| permission === OC.PERMISSION_DELETE))
{
return false;
}
return (share.permissions & permission) === permission;
},
notificationMailWasSent: function(shareIndex) {
/** @type OC.Share.Types.ShareInfo **/
var share = this.get('shares')[shareIndex];
if(!_.isObject(share)) {
throw "Unknown Share";
}
return share.mail_send === 1;
},
/**
* Sends an email notification for the given share
*
* @param {int} shareType share type
* @param {string} shareWith recipient
* @param {bool} state whether to set the notification flag or remove it
*/
sendNotificationForShare: function(shareType, shareWith, state) {
var itemType = this.get('itemType');
var itemSource = this.get('itemSource');
2015-09-14 19:24:58 +03:00
return $.post(
OC.generateUrl('core/ajax/share.php'),
{
action: state ? 'informRecipients' : 'informRecipientsDisabled',
recipient: shareWith,
shareType: shareType,
itemSource: itemSource,
itemType: itemType
},
function(result) {
if (result.status !== 'success') {
2015-09-14 19:24:58 +03:00
// FIXME: a model should not show dialogs
OC.dialogs.alert(t('core', result.data.message), t('core', 'Warning'));
}
}
);
},
2015-09-14 19:24:58 +03:00
/**
* Send the link share information by email
*
* @param {string} recipientEmail recipient email address
*/
sendEmailPrivateLink: function(recipientEmail) {
var deferred = $.Deferred();
2015-09-14 19:24:58 +03:00
var itemType = this.get('itemType');
var itemSource = this.get('itemSource');
var linkShare = this.get('linkShare');
$.post(
2015-09-14 19:24:58 +03:00
OC.generateUrl('core/ajax/share.php'), {
action: 'email',
toaddress: recipientEmail,
link: linkShare.link,
itemType: itemType,
itemSource: itemSource,
file: this.fileInfoModel.get('name'),
expiration: linkShare.expiration || ''
},
function(result) {
if (!result || result.status !== 'success') {
// FIXME: a model should not show dialogs
OC.dialogs.alert(result.data.message, t('core', 'Error while sending notification'));
deferred.reject();
} else {
deferred.resolve();
2015-09-14 19:24:58 +03:00
}
});
return deferred.promise();
2015-09-14 19:24:58 +03:00
},
/**
* @returns {boolean}
*/
sharePermissionPossible: function() {
return (this.get('permissions') & OC.PERMISSION_SHARE) === OC.PERMISSION_SHARE;
},
/**
* @param {number} shareIndex
* @returns {boolean}
*/
hasSharePermission: function(shareIndex) {
return this._shareHasPermission(shareIndex, OC.PERMISSION_SHARE);
},
/**
* @returns {boolean}
*/
createPermissionPossible: function() {
return (this.get('permissions') & OC.PERMISSION_CREATE) === OC.PERMISSION_CREATE;
},
/**
* @param {number} shareIndex
* @returns {boolean}
*/
hasCreatePermission: function(shareIndex) {
return this._shareHasPermission(shareIndex, OC.PERMISSION_CREATE);
},
/**
* @returns {boolean}
*/
updatePermissionPossible: function() {
return (this.get('permissions') & OC.PERMISSION_UPDATE) === OC.PERMISSION_UPDATE;
},
/**
* @param {number} shareIndex
* @returns {boolean}
*/
hasUpdatePermission: function(shareIndex) {
return this._shareHasPermission(shareIndex, OC.PERMISSION_UPDATE);
},
/**
* @returns {boolean}
*/
deletePermissionPossible: function() {
return (this.get('permissions') & OC.PERMISSION_DELETE) === OC.PERMISSION_DELETE;
},
/**
* @param {number} shareIndex
* @returns {boolean}
*/
hasDeletePermission: function(shareIndex) {
return this._shareHasPermission(shareIndex, OC.PERMISSION_DELETE);
},
/**
* @returns {boolean}
*/
editPermissionPossible: function() {
return this.createPermissionPossible()
|| this.updatePermissionPossible()
|| this.deletePermissionPossible();
},
/**
* @returns {boolean}
*/
hasEditPermission: function(shareIndex) {
return this.hasCreatePermission(shareIndex)
|| this.hasUpdatePermission(shareIndex)
|| this.hasDeletePermission(shareIndex);
},
fetch: function() {
var model = this;
this.trigger('request', this);
OC.Share.loadItem(this.get('itemType'), this.get('itemSource'), function(data) {
model.trigger('sync', 'GET', this);
model.set(model.parse(data));
});
},
/**
* Updates OC.Share.itemShares and OC.Share.statuses.
*
* This is required in case the user navigates away and comes back,
* the share statuses from the old arrays are still used to fill in the icons
* in the file list.
*/
_legacyFillCurrentShares: function(shares) {
var fileId = this.fileInfoModel.get('id');
if (!shares || !shares.length) {
delete OC.Share.statuses[fileId];
OC.Share.currentShares = {};
OC.Share.itemShares = [];
return;
}
var currentShareStatus = OC.Share.statuses[fileId];
if (!currentShareStatus) {
currentShareStatus = {link: false};
OC.Share.statuses[fileId] = currentShareStatus;
}
currentShareStatus.link = false;
OC.Share.currentShares = {};
OC.Share.itemShares = [];
_.each(shares,
/**
* @param {OC.Share.Types.ShareInfo} share
*/
function(share) {
if (share.share_type === OC.Share.SHARE_TYPE_LINK) {
OC.Share.itemShares[share.share_type] = true;
currentShareStatus.link = true;
} else {
if (!OC.Share.itemShares[share.share_type]) {
OC.Share.itemShares[share.share_type] = [];
}
OC.Share.itemShares[share.share_type].push(share.share_with);
}
}
);
},
parse: function(data) {
if(data === false) {
console.warn('no data was returned');
trigger('fetchError');
return {};
}
var permissions = this.get('possiblePermissions');
if(!_.isUndefined(data.reshare) && !_.isUndefined(data.reshare.permissions) && data.reshare.uid_owner !== OC.currentUser) {
permissions = permissions & data.reshare.permissions;
}
var allowPublicUploadStatus = false;
if(!_.isUndefined(data.shares)) {
$.each(data.shares, function (key, value) {
if (value.share_type === OC.Share.SHARE_TYPE_LINK) {
allowPublicUploadStatus = (value.permissions & OC.PERMISSION_CREATE) ? true : false;
return true;
}
});
}
2015-09-03 16:53:17 +03:00
/** @type {OC.Share.Types.ShareInfo[]} **/
var shares = _.map(data.shares, function(share) {
// properly parse some values because sometimes the server
// returns integers as string...
var i;
for (i = 0; i < SHARE_RESPONSE_INT_PROPS.length; i++) {
var prop = SHARE_RESPONSE_INT_PROPS[i];
if (!_.isUndefined(share[prop])) {
share[prop] = parseInt(share[prop], 10);
}
}
return share;
});
this._legacyFillCurrentShares(shares);
2015-09-03 16:53:17 +03:00
var linkShare = { isLinkShare: false };
// filter out the share by link
shares = _.reject(shares,
/**
* @param {OC.Share.Types.ShareInfo} share
*/
function(share) {
var isShareLink =
share.share_type === OC.Share.SHARE_TYPE_LINK
&& ( share.file_source === this.get('itemSource')
|| share.item_source === this.get('itemSource'));
if (isShareLink) {
var link = window.location.protocol + '//' + window.location.host;
if (!share.token) {
// pre-token link
var fullPath = this.fileInfoModel.get('path') + '/' +
this.fileInfoModel.get('name');
var location = '/' + OC.currentUser + '/files' + fullPath;
var type = this.fileInfoModel.isDirectory() ? 'folder' : 'file';
link += OC.linkTo('', 'public.php') + '?service=files&' +
type + '=' + encodeURIComponent(location);
} else {
link += OC.generateUrl('/s/') + share.token;
}
linkShare = {
isLinkShare: true,
token: share.token,
password: share.share_with,
2015-09-04 16:31:45 +03:00
link: link,
permissions: share.permissions,
2015-09-04 16:31:45 +03:00
// currently expiration is only effective for link shares.
expiration: share.expiration,
stime: share.stime
2015-09-03 16:53:17 +03:00
};
return share;
}
},
this
);
return {
reshare: data.reshare,
shares: shares,
2015-09-03 16:53:17 +03:00
linkShare: linkShare,
permissions: permissions,
allowPublicUploadStatus: allowPublicUploadStatus
};
},
/**
* Parses a string to an valid integer (unix timestamp)
* @param time
* @returns {*}
* @internal Only used to work around a bug in the backend
*/
_parseTime: function(time) {
if (_.isString(time)) {
// skip empty strings and hex values
if (time === '' || (time.length > 1 && time[0] === '0' && time[1] === 'x')) {
return null;
}
time = parseInt(time, 10);
if(isNaN(time)) {
time = null;
}
}
return time;
}
});
OC.Share.ShareItemModel = ShareItemModel;
})();