mirror of
https://github.com/YunoHost-Apps/rocketchat_ynh.git
synced 2024-09-03 20:16:25 +02:00
787 lines
80 KiB
JavaScript
787 lines
80 KiB
JavaScript
(function () {
|
|
|
|
/* Imports */
|
|
var Meteor = Package.meteor.Meteor;
|
|
var ECMAScript = Package.ecmascript.ECMAScript;
|
|
var RocketChatFile = Package['rocketchat:file'].RocketChatFile;
|
|
var UploadFS = Package['jalik:ufs'].UploadFS;
|
|
var Slingshot = Package['edgee:slingshot'].Slingshot;
|
|
var AWS = Package['peerlibrary:aws-sdk'].AWS;
|
|
var RocketChat = Package['rocketchat:lib'].RocketChat;
|
|
var Random = Package.random.Random;
|
|
var _ = Package.underscore._;
|
|
var Tracker = Package.tracker.Tracker;
|
|
var Deps = Package.tracker.Deps;
|
|
var WebApp = Package.webapp.WebApp;
|
|
var main = Package.webapp.main;
|
|
var WebAppInternals = Package.webapp.WebAppInternals;
|
|
var babelHelpers = Package['babel-runtime'].babelHelpers;
|
|
var Symbol = Package['ecmascript-runtime'].Symbol;
|
|
var Map = Package['ecmascript-runtime'].Map;
|
|
var Set = Package['ecmascript-runtime'].Set;
|
|
var Promise = Package.promise.Promise;
|
|
var TAPi18next = Package['tap:i18n'].TAPi18next;
|
|
var TAPi18n = Package['tap:i18n'].TAPi18n;
|
|
|
|
/* Package-scope variables */
|
|
var FileUpload, FileUploadBase, FileSystemStore, fileUploadHandler;
|
|
|
|
(function(){
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/rocketchat_file-upload/globalFileRestrictions.js //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
/* globals Slingshot */ //
|
|
//
|
|
Slingshot.fileRestrictions('rocketchat-uploads', { // 3
|
|
authorize: function (file /*, metaContext*/) { // 4
|
|
if (!RocketChat.fileUploadIsValidContentType(file.type)) { // 5
|
|
throw new Meteor.Error(TAPi18n.__('Invalid_file_type')); // 6
|
|
} //
|
|
//
|
|
var maxFileSize = RocketChat.settings.get('FileUpload_MaxFileSize'); // 9
|
|
//
|
|
if (maxFileSize && maxFileSize < file.size) { // 11
|
|
throw new Meteor.Error(TAPi18n.__('File_exceeds_allowed_size_of_bytes', { size: maxFileSize })); // 12
|
|
} //
|
|
//
|
|
//Deny uploads if user is not logged in. //
|
|
if (!this.userId) { // 16
|
|
throw new Meteor.Error('login-require', 'Please login before posting files'); // 17
|
|
} //
|
|
//
|
|
return true; // 20
|
|
}, //
|
|
maxSize: 0, // 22
|
|
allowedFileTypes: null // 23
|
|
}); //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function(){
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/rocketchat_file-upload/lib/FileUpload.js //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
/* globals FileUpload:true */ //
|
|
/* exported FileUpload */ //
|
|
//
|
|
var maxFileSize = 0; // 4
|
|
//
|
|
FileUpload = { // 6
|
|
validateFileUpload: function (file) { // 7
|
|
if (file.size > maxFileSize) { // 8
|
|
throw new Meteor.Error('file-too-large', 'File is too large'); // 9
|
|
} //
|
|
//
|
|
if (!RocketChat.fileUploadIsValidContentType(file.type)) { // 12
|
|
throw new Meteor.Error('invalid-file-type', 'File type is not accepted'); // 13
|
|
} //
|
|
//
|
|
return true; // 16
|
|
} //
|
|
}; //
|
|
//
|
|
RocketChat.settings.get('FileUpload_MaxFileSize', function (key, value) { // 20
|
|
maxFileSize = value; // 21
|
|
}); //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function(){
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/rocketchat_file-upload/lib/FileUploadBase.js //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
/* globals FileUploadBase:true */ //
|
|
/* exported FileUploadBase */ //
|
|
//
|
|
FileUploadBase = (function () { // 4
|
|
function FileUploadBase(meta, file /*, data*/) { // 5
|
|
babelHelpers.classCallCheck(this, FileUploadBase); //
|
|
//
|
|
this.id = Random.id(); // 6
|
|
this.meta = meta; // 7
|
|
this.file = file; // 8
|
|
} //
|
|
//
|
|
FileUploadBase.prototype.getProgress = (function () { // 4
|
|
function getProgress() {} // 11
|
|
//
|
|
return getProgress; //
|
|
})(); //
|
|
//
|
|
FileUploadBase.prototype.getFileName = (function () { // 4
|
|
function getFileName() { // 15
|
|
return this.meta.name; // 16
|
|
} //
|
|
//
|
|
return getFileName; //
|
|
})(); //
|
|
//
|
|
FileUploadBase.prototype.start = (function () { // 4
|
|
function start() {} // 19
|
|
//
|
|
return start; //
|
|
})(); //
|
|
//
|
|
FileUploadBase.prototype.stop = (function () { // 4
|
|
function stop() {} // 23
|
|
//
|
|
return stop; //
|
|
})(); //
|
|
//
|
|
return FileUploadBase; //
|
|
})(); //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function(){
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/rocketchat_file-upload/server/lib/FileUpload.js //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
/* globals FileUpload:true */ //
|
|
FileUpload.handlers = {}; // 2
|
|
//
|
|
FileUpload.addHandler = function (store, handler) { // 4
|
|
this.handlers[store] = handler; // 5
|
|
}; //
|
|
//
|
|
FileUpload["delete"] = function (fileId) { // 8
|
|
var file = RocketChat.models.Uploads.findOneById(fileId); // 9
|
|
//
|
|
if (!file) { // 11
|
|
return; // 12
|
|
} //
|
|
//
|
|
this.handlers[file.store]["delete"](file); // 15
|
|
//
|
|
return RocketChat.models.Uploads.remove(file._id); // 17
|
|
}; //
|
|
//
|
|
FileUpload.get = function (file, req, res, next) { // 20
|
|
if (file.store && this.handlers && this.handlers[file.store] && this.handlers[file.store].get) { // 21
|
|
this.handlers[file.store].get.call(this, file, req, res, next); // 22
|
|
} else { //
|
|
res.writeHead(404); // 24
|
|
res.end(); // 25
|
|
return; // 26
|
|
} //
|
|
}; //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function(){
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/rocketchat_file-upload/server/lib/requests.js //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
/* globals FileUpload, WebApp, Cookies */ //
|
|
var protectedFiles; // 2
|
|
//
|
|
RocketChat.settings.get('FileUpload_ProtectFiles', function (key, value) { // 4
|
|
protectedFiles = value; // 5
|
|
}); //
|
|
//
|
|
WebApp.connectHandlers.use('/file-upload/', function (req, res, next) { // 8
|
|
var file; // 9
|
|
//
|
|
var match = /^\/([^\/]+)\/(.*)/.exec(req.url); // 11
|
|
//
|
|
if (match[1]) { // 13
|
|
file = RocketChat.models.Uploads.findOneById(match[1]); // 14
|
|
//
|
|
if (file) { // 16
|
|
if (protectedFiles) { // 17
|
|
var cookie, rawCookies, ref, token, uid; // 18
|
|
cookie = new Cookies(); // 19
|
|
//
|
|
if ((typeof req !== 'undefined' && req !== null ? (ref = req.headers) != null ? ref.cookie : void 0 : void 0) != null) {
|
|
rawCookies = req.headers.cookie; // 22
|
|
} //
|
|
//
|
|
if (rawCookies != null) { // 25
|
|
uid = cookie.get('rc_uid', rawCookies); // 26
|
|
} //
|
|
//
|
|
if (rawCookies != null) { // 29
|
|
token = cookie.get('rc_token', rawCookies); // 30
|
|
} //
|
|
//
|
|
if (uid == null) { // 33
|
|
uid = req.query.rc_uid; // 34
|
|
token = req.query.rc_token; // 35
|
|
} //
|
|
//
|
|
if (!(uid && token && RocketChat.models.Users.findOneByIdAndLoginToken(uid, token))) { // 38
|
|
res.writeHead(403); // 39
|
|
res.end(); // 40
|
|
return false; // 41
|
|
} //
|
|
} //
|
|
//
|
|
return FileUpload.get(file, req, res, next); // 45
|
|
} //
|
|
} //
|
|
//
|
|
res.writeHead(404); // 49
|
|
res.end(); // 50
|
|
return; // 51
|
|
}); //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function(){
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/rocketchat_file-upload/server/config/configFileUploadAmazonS3.js //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
/* globals Slingshot, FileUpload, AWS, SystemLogger */ //
|
|
var crypto = Npm.require('crypto'); // 2
|
|
//
|
|
var S3accessKey, S3secretKey; // 4
|
|
//
|
|
var generateURL = function (file) { // 6
|
|
if (!file || !file.s3) { // 7
|
|
return; // 8
|
|
} //
|
|
var resourceURL = '/' + file.s3.bucket + '/' + file.s3.path + file._id; // 10
|
|
var expires = parseInt(new Date().getTime() / 1000) + 60; // 11
|
|
var StringToSign = 'GET\n\n\n' + expires + '\n' + resourceURL; // 12
|
|
var signature = crypto.createHmac('sha1', S3secretKey).update(new Buffer(StringToSign, 'utf-8')).digest('base64'); // 13
|
|
return file.url + '?AWSAccessKeyId=' + encodeURIComponent(S3accessKey) + '&Expires=' + expires + '&Signature=' + encodeURIComponent(signature);
|
|
}; //
|
|
//
|
|
FileUpload.addHandler('s3', { // 17
|
|
get: function (file, req, res) { // 18
|
|
var fileUrl = generateURL(file); // 19
|
|
//
|
|
if (fileUrl) { // 21
|
|
res.setHeader('Location', fileUrl); // 22
|
|
res.writeHead(302); // 23
|
|
} //
|
|
res.end(); // 25
|
|
}, //
|
|
'delete': function (file) { // 27
|
|
var s3 = new AWS.S3(); // 28
|
|
var request = s3.deleteObject({ // 29
|
|
Bucket: file.s3.bucket, // 30
|
|
Key: file.s3.path + file._id // 31
|
|
}); //
|
|
request.send(); // 33
|
|
} //
|
|
}); //
|
|
//
|
|
var createS3Directive = _.debounce(function () { // 37
|
|
var directiveName = 'rocketchat-uploads'; // 38
|
|
//
|
|
var type = RocketChat.settings.get('FileUpload_Storage_Type'); // 40
|
|
var bucket = RocketChat.settings.get('FileUpload_S3_Bucket'); // 41
|
|
var acl = RocketChat.settings.get('FileUpload_S3_Acl'); // 42
|
|
var accessKey = RocketChat.settings.get('FileUpload_S3_AWSAccessKeyId'); // 43
|
|
var secretKey = RocketChat.settings.get('FileUpload_S3_AWSSecretAccessKey'); // 44
|
|
var cdn = RocketChat.settings.get('FileUpload_S3_CDN'); // 45
|
|
var region = RocketChat.settings.get('FileUpload_S3_Region'); // 46
|
|
var bucketUrl = RocketChat.settings.get('FileUpload_S3_BucketURL'); // 47
|
|
//
|
|
AWS.config.update({ // 49
|
|
accessKeyId: RocketChat.settings.get('FileUpload_S3_AWSAccessKeyId'), // 50
|
|
secretAccessKey: RocketChat.settings.get('FileUpload_S3_AWSSecretAccessKey') // 51
|
|
}); //
|
|
//
|
|
if (type === 'AmazonS3' && !_.isEmpty(bucket) && !_.isEmpty(accessKey) && !_.isEmpty(secretKey)) { // 54
|
|
if (Slingshot._directives[directiveName]) { // 55
|
|
delete Slingshot._directives[directiveName]; // 56
|
|
} //
|
|
var config = { // 58
|
|
bucket: bucket, // 59
|
|
AWSAccessKeyId: accessKey, // 60
|
|
AWSSecretAccessKey: secretKey, // 61
|
|
key: function (file, metaContext) { // 62
|
|
var path = RocketChat.hostname + '/' + metaContext.rid + '/' + this.userId + '/'; // 63
|
|
//
|
|
var upload = { // 65
|
|
s3: { // 66
|
|
bucket: bucket, // 67
|
|
region: region, // 68
|
|
path: path // 69
|
|
} //
|
|
}; //
|
|
var fileId = RocketChat.models.Uploads.insertFileInit(metaContext.rid, this.userId, 's3', file, upload); // 72
|
|
//
|
|
return path + fileId; // 74
|
|
} //
|
|
}; //
|
|
//
|
|
if (!_.isEmpty(acl)) { // 78
|
|
config.acl = acl; // 79
|
|
} //
|
|
//
|
|
if (!_.isEmpty(cdn)) { // 82
|
|
config.cdn = cdn; // 83
|
|
} //
|
|
//
|
|
if (!_.isEmpty(region)) { // 86
|
|
config.region = region; // 87
|
|
} //
|
|
//
|
|
if (!_.isEmpty(bucketUrl)) { // 90
|
|
config.bucketUrl = bucketUrl; // 91
|
|
} //
|
|
//
|
|
try { // 94
|
|
Slingshot.createDirective(directiveName, Slingshot.S3Storage, config); // 95
|
|
} catch (e) { //
|
|
SystemLogger.error('Error configuring S3 ->', e.message); // 97
|
|
} //
|
|
} else { //
|
|
if (Slingshot._directives[directiveName]) { // 100
|
|
delete Slingshot._directives[directiveName]; // 101
|
|
} //
|
|
} //
|
|
}, 500); //
|
|
//
|
|
RocketChat.settings.get('FileUpload_Storage_Type', createS3Directive); // 106
|
|
//
|
|
RocketChat.settings.get('FileUpload_S3_Bucket', createS3Directive); // 108
|
|
//
|
|
RocketChat.settings.get('FileUpload_S3_Acl', createS3Directive); // 110
|
|
//
|
|
RocketChat.settings.get('FileUpload_S3_AWSAccessKeyId', function (key, value) { // 112
|
|
S3accessKey = value; // 113
|
|
createS3Directive(); // 114
|
|
}); //
|
|
//
|
|
RocketChat.settings.get('FileUpload_S3_AWSSecretAccessKey', function (key, value) { // 117
|
|
S3secretKey = value; // 118
|
|
createS3Directive(); // 119
|
|
}); //
|
|
//
|
|
RocketChat.settings.get('FileUpload_S3_CDN', createS3Directive); // 122
|
|
//
|
|
RocketChat.settings.get('FileUpload_S3_Region', createS3Directive); // 124
|
|
//
|
|
RocketChat.settings.get('FileUpload_S3_BucketURL', createS3Directive); // 126
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function(){
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/rocketchat_file-upload/server/config/configFileUploadFileSystem.js //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
/* globals FileSystemStore:true, FileUpload, UploadFS, RocketChatFile */ //
|
|
//
|
|
var storeName = 'fileSystem'; // 3
|
|
//
|
|
FileSystemStore = null; // 5
|
|
//
|
|
var createFileSystemStore = _.debounce(function () { // 7
|
|
var stores = UploadFS.getStores(); // 8
|
|
if (stores[storeName]) { // 9
|
|
delete stores[storeName]; // 10
|
|
} //
|
|
FileSystemStore = new UploadFS.store.Local({ // 12
|
|
collection: RocketChat.models.Uploads.model, // 13
|
|
name: storeName, // 14
|
|
path: RocketChat.settings.get('FileUpload_FileSystemPath'), //'/tmp/uploads/photos', // 15
|
|
filter: new UploadFS.Filter({ // 16
|
|
onCheck: FileUpload.validateFileUpload // 17
|
|
}), //
|
|
transformWrite: function (readStream, writeStream, fileId, file) { // 19
|
|
var identify, stream; // 20
|
|
if (RocketChatFile.enabled === false || !/^image\/.+/.test(file.type)) { // 21
|
|
return readStream.pipe(writeStream); // 22
|
|
} //
|
|
stream = void 0; // 24
|
|
identify = function (err, data) { // 25
|
|
var ref; // 26
|
|
if (err != null) { // 27
|
|
return stream.pipe(writeStream); // 28
|
|
} //
|
|
file.identify = { // 30
|
|
format: data.format, // 31
|
|
size: data.size // 32
|
|
}; //
|
|
if (data.Orientation != null && ((ref = data.Orientation) !== '' && ref !== 'Unknown' && ref !== 'Undefined')) { // 34
|
|
return RocketChatFile.gm(stream).autoOrient().stream().pipe(writeStream); // 35
|
|
} else { //
|
|
return stream.pipe(writeStream); // 37
|
|
} //
|
|
}; //
|
|
stream = RocketChatFile.gm(readStream).identify(identify).stream(); // 40
|
|
return; // 41
|
|
} //
|
|
}); //
|
|
}, 500); //
|
|
//
|
|
RocketChat.settings.get('FileUpload_FileSystemPath', createFileSystemStore); // 46
|
|
//
|
|
var fs = Npm.require('fs'); // 48
|
|
//
|
|
FileUpload.addHandler(storeName, { // 50
|
|
get: function (file, req, res) { // 51
|
|
var filePath = FileSystemStore.getFilePath(file._id, file); // 52
|
|
//
|
|
try { // 54
|
|
var stat = Meteor.wrapAsync(fs.stat)(filePath); // 55
|
|
//
|
|
if (stat && stat.isFile()) { // 57
|
|
res.setHeader('Content-Disposition', 'attachment; filename="' + encodeURIComponent(file.name) + '"'); // 58
|
|
res.setHeader('Last-Modified', file.uploadedAt.toUTCString()); // 59
|
|
res.setHeader('Content-Type', file.type); // 60
|
|
res.setHeader('Content-Length', file.size); // 61
|
|
//
|
|
FileSystemStore.getReadStream(file._id, file).pipe(res); // 63
|
|
} //
|
|
} catch (e) { //
|
|
res.writeHead(404); // 66
|
|
res.end(); // 67
|
|
return; // 68
|
|
} //
|
|
}, //
|
|
'delete': function (file) { // 71
|
|
return FileSystemStore['delete'](file._id); // 72
|
|
} //
|
|
}); //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function(){
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/rocketchat_file-upload/server/config/configFileUploadGridFS.js //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
/* globals FileUpload, UploadFS */ //
|
|
var stream = Npm.require('stream'); // 2
|
|
var zlib = Npm.require('zlib'); // 3
|
|
//
|
|
// code from: https://github.com/jalik/jalik-ufs/blob/master/ufs-server.js#L91 //
|
|
var readFromGridFS = function (storeName, fileId, file, headers, req, res) { // 6
|
|
var store = UploadFS.getStore(storeName); // 7
|
|
var rs = store.getReadStream(fileId, file); // 8
|
|
var ws = new stream.PassThrough(); // 9
|
|
//
|
|
rs.on('error', function (err) { // 11
|
|
store.onReadError.call(store, err, fileId, file); // 12
|
|
res.end(); // 13
|
|
}); //
|
|
ws.on('error', function (err) { // 15
|
|
store.onReadError.call(store, err, fileId, file); // 16
|
|
res.end(); // 17
|
|
}); //
|
|
ws.on('close', function () { // 19
|
|
// Close output stream at the end //
|
|
ws.emit('end'); // 21
|
|
}); //
|
|
//
|
|
var accept = req.headers['accept-encoding'] || ''; // 24
|
|
//
|
|
// Transform stream //
|
|
store.transformRead(rs, ws, fileId, file, req, headers); // 27
|
|
//
|
|
// Compress data using gzip //
|
|
if (accept.match(/\bgzip\b/)) { // 30
|
|
headers['Content-Encoding'] = 'gzip'; // 31
|
|
delete headers['Content-Length']; // 32
|
|
res.writeHead(200, headers); // 33
|
|
ws.pipe(zlib.createGzip()).pipe(res); // 34
|
|
} //
|
|
// Compress data using deflate //
|
|
else if (accept.match(/\bdeflate\b/)) { //
|
|
headers['Content-Encoding'] = 'deflate'; // 38
|
|
delete headers['Content-Length']; // 39
|
|
res.writeHead(200, headers); // 40
|
|
ws.pipe(zlib.createDeflate()).pipe(res); // 41
|
|
} //
|
|
// Send raw data //
|
|
else { //
|
|
res.writeHead(200, headers); // 45
|
|
ws.pipe(res); // 46
|
|
} //
|
|
}; //
|
|
//
|
|
FileUpload.addHandler('rocketchat_uploads', { // 50
|
|
get: function (file, req, res) { // 51
|
|
var headers = { // 52
|
|
'Content-Disposition': 'attachment; filename="' + encodeURIComponent(file.name) + '"', // 53
|
|
'Last-Modified': file.uploadedAt.toUTCString(), // 54
|
|
'Content-Type': file.type, // 55
|
|
'Content-Length': file.size // 56
|
|
}; //
|
|
return readFromGridFS(file.store, file._id, file, headers, req, res); // 58
|
|
}, //
|
|
'delete': function (file) { // 60
|
|
return Meteor.fileStore['delete'](file._id); // 61
|
|
} //
|
|
}); //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function(){
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/rocketchat_file-upload/server/methods/sendFileMessage.js //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
Meteor.methods({ // 1
|
|
'sendFileMessage': function (roomId, store, file) { // 2
|
|
if (!Meteor.userId()) { // 3
|
|
throw new Meteor.Error(203, 'User_logged_out'); // 4
|
|
} //
|
|
//
|
|
var room = Meteor.call('canAccessRoom', roomId, Meteor.userId()); // 7
|
|
//
|
|
if (!room) { // 9
|
|
return false; // 10
|
|
} //
|
|
//
|
|
RocketChat.models.Uploads.updateFileComplete(file._id, Meteor.userId(), _.omit(file, '_id')); // 13
|
|
//
|
|
var fileUrl = '/file-upload/' + file._id + '/' + file.name; // 15
|
|
//
|
|
var attachment = { // 17
|
|
title: 'File Uploaded: ' + file.name, // 18
|
|
title_link: fileUrl, // 19
|
|
title_link_download: true // 20
|
|
}; //
|
|
//
|
|
if (/^image\/.+/.test(file.type)) { // 23
|
|
attachment.image_url = fileUrl; // 24
|
|
attachment.image_type = file.type; // 25
|
|
attachment.image_size = file.size; // 26
|
|
if (file.identify && file.identify.size) { // 27
|
|
attachment.image_dimensions = file.identify.size; // 28
|
|
} //
|
|
} else if (/^audio\/.+/.test(file.type)) { //
|
|
attachment.audio_url = fileUrl; // 31
|
|
attachment.audio_type = file.type; // 32
|
|
attachment.audio_size = file.size; // 33
|
|
} else if (/^video\/.+/.test(file.type)) { //
|
|
attachment.video_url = fileUrl; // 35
|
|
attachment.video_type = file.type; // 36
|
|
attachment.video_size = file.size; // 37
|
|
} //
|
|
//
|
|
var msg = { // 40
|
|
_id: Random.id(), // 41
|
|
rid: roomId, // 42
|
|
msg: '', // 43
|
|
file: { // 44
|
|
_id: file._id // 45
|
|
}, //
|
|
groupable: false, // 47
|
|
attachments: [attachment] // 48
|
|
}; //
|
|
//
|
|
msg = Meteor.call('sendMessage', msg); // 51
|
|
} //
|
|
}); //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function(){
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/rocketchat_file-upload/server/startup/settings.js //
|
|
// //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
RocketChat.settings.addGroup('FileUpload', function () { // 1
|
|
this.add('FileUpload_Enabled', true, { // 2
|
|
type: 'boolean', // 3
|
|
'public': true // 4
|
|
}); //
|
|
//
|
|
this.add('FileUpload_MaxFileSize', 2097152, { // 7
|
|
type: 'int', // 8
|
|
'public': true // 9
|
|
}); //
|
|
//
|
|
this.add('FileUpload_MediaTypeWhiteList', 'image/*,audio/*,application/pdf,text/plain,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document', {
|
|
type: 'string', // 13
|
|
'public': true, // 14
|
|
i18nDescription: 'FileUpload_MediaTypeWhiteListDescription' // 15
|
|
}); //
|
|
//
|
|
this.add('FileUpload_ProtectFiles', true, { // 18
|
|
type: 'boolean', // 19
|
|
'public': true, // 20
|
|
i18nDescription: 'FileUpload_ProtectFilesDescription' // 21
|
|
}); //
|
|
//
|
|
this.add('FileUpload_Storage_Type', 'GridFS', { // 24
|
|
type: 'select', // 25
|
|
values: [{ // 26
|
|
key: 'GridFS', // 27
|
|
i18nLabel: 'GridFS' // 28
|
|
}, { //
|
|
key: 'AmazonS3', // 30
|
|
i18nLabel: 'AmazonS3' // 31
|
|
}, { //
|
|
key: 'FileSystem', // 33
|
|
i18nLabel: 'FileSystem' // 34
|
|
}], //
|
|
'public': true // 36
|
|
}); //
|
|
//
|
|
this.section('Amazon S3', function () { // 39
|
|
this.add('FileUpload_S3_Bucket', '', { // 40
|
|
type: 'string', // 41
|
|
enableQuery: { // 42
|
|
_id: 'FileUpload_Storage_Type', // 43
|
|
value: 'AmazonS3' // 44
|
|
} //
|
|
}); //
|
|
this.add('FileUpload_S3_Acl', '', { // 47
|
|
type: 'string', // 48
|
|
enableQuery: { // 49
|
|
_id: 'FileUpload_Storage_Type', // 50
|
|
value: 'AmazonS3' // 51
|
|
} //
|
|
}); //
|
|
this.add('FileUpload_S3_AWSAccessKeyId', '', { // 54
|
|
type: 'string', // 55
|
|
enableQuery: { // 56
|
|
_id: 'FileUpload_Storage_Type', // 57
|
|
value: 'AmazonS3' // 58
|
|
} //
|
|
}); //
|
|
this.add('FileUpload_S3_AWSSecretAccessKey', '', { // 61
|
|
type: 'string', // 62
|
|
enableQuery: { // 63
|
|
_id: 'FileUpload_Storage_Type', // 64
|
|
value: 'AmazonS3' // 65
|
|
} //
|
|
}); //
|
|
this.add('FileUpload_S3_CDN', '', { // 68
|
|
type: 'string', // 69
|
|
enableQuery: { // 70
|
|
_id: 'FileUpload_Storage_Type', // 71
|
|
value: 'AmazonS3' // 72
|
|
} //
|
|
}); //
|
|
this.add('FileUpload_S3_Region', '', { // 75
|
|
type: 'string', // 76
|
|
enableQuery: { // 77
|
|
_id: 'FileUpload_Storage_Type', // 78
|
|
value: 'AmazonS3' // 79
|
|
} //
|
|
}); //
|
|
this.add('FileUpload_S3_BucketURL', '', { // 82
|
|
type: 'string', // 83
|
|
enableQuery: { // 84
|
|
_id: 'FileUpload_Storage_Type', // 85
|
|
value: 'AmazonS3' // 86
|
|
}, //
|
|
i18nDescription: 'Override_URL_to_which_files_are_uploaded_This_url_also_used_for_downloads_unless_a_CDN_is_given.'
|
|
}); //
|
|
}); //
|
|
//
|
|
this.section('File System', function () { // 92
|
|
this.add('FileUpload_FileSystemPath', '', { // 93
|
|
type: 'string', // 94
|
|
enableQuery: { // 95
|
|
_id: 'FileUpload_Storage_Type', // 96
|
|
value: 'FileSystem' // 97
|
|
} //
|
|
}); //
|
|
}); //
|
|
}); //
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
/* Exports */
|
|
if (typeof Package === 'undefined') Package = {};
|
|
Package['rocketchat:file-upload'] = {
|
|
fileUploadHandler: fileUploadHandler,
|
|
FileUpload: FileUpload
|
|
};
|
|
|
|
})();
|
|
|
|
//# sourceMappingURL=rocketchat_file-upload.js.map
|