pengjunjie/server
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/server.git synced 2026-02-10 18:05:07 +08:00
Code Issues Packages Projects Releases Wiki Activity

[linter] auto-fix

Browse Source
This commit is contained in:
PauI Ostrovckij
2025-08-27 10:43:09 +03:00
parent 8d90d40d27
commit d6be91f3e3
44 changed files with 1517 additions and 1517 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
3d-party-lic-report/json2md.js
View File

@ -34,7 +34,7 @@
const { readFile, writeFile } = require("node:fs/promises");
async function startTest() {
let args = process.argv.slice(2);
const args = process.argv.slice(2);
if (args.length < 1) {
console.error('missing arguments.USAGE: json2md.js [output.md] [input.json]');
return;
@ -42,19 +42,19 @@ async function startTest() {
console.info("3d license report start");
let outputMd = '';
let outputFlag = 'a';
let outputPath = args[0];
let inputPath = args[1];
const outputPath = args[0];
const inputPath = args[1];
if (inputPath) {
let licensesText = await readFile(inputPath, 'utf-8');
let licensesJson = JSON.parse(licensesText);
const licensesText = await readFile(inputPath, 'utf-8');
const licensesJson = JSON.parse(licensesText);
console.info("3d license report license count: %d", licensesJson.length);
for (const element of licensesJson) {
let name = element['name'];
let installedVersion = element['installedVersion'];
let licenseType = element['licenseType'];
let licenseFileLink = element['licenseFileLink'];
const name = element['name'];
const installedVersion = element['installedVersion'];
const licenseType = element['licenseType'];
const licenseFileLink = element['licenseFileLink'];
outputMd += `- ${name} ${installedVersion} ([${licenseType}](${licenseFileLink}))\n`
}
} else {

18
Common/sources/activeMQCore.js
View File

@ -41,7 +41,7 @@ const cfgRabbitSocketOptions = config.util.cloneDeep(config.get('activemq.connec
var RECONNECT_TIMEOUT = 1000;
function connetPromise(closeCallback) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
//todo use built-in reconnect logic
function startConnect() {
let onDisconnected = function() {
@ -51,24 +51,24 @@ function connetPromise(closeCallback) {
setTimeout(startConnect, RECONNECT_TIMEOUT);
}
}
let conn = container.create_container().connect(cfgRabbitSocketOptions);
const conn = container.create_container().connect(cfgRabbitSocketOptions);
let isConnected = false;
conn.on('connection_open', function(context) {
conn.on('connection_open', (context) => {
operationContext.global.logger.debug('[AMQP] connected');
isConnected = true;
resolve(conn);
});
conn.on('connection_error', function(context) {
conn.on('connection_error', (context) => {
operationContext.global.logger.debug('[AMQP] connection_error %s', context.error && context.error);
});
conn.on('connection_close', function(context) {
conn.on('connection_close', (context) => {
operationContext.global.logger.debug('[AMQP] conn close');
if (onDisconnected) {
onDisconnected();
onDisconnected = null;
}
});
conn.on('disconnected', function(context) {
conn.on('disconnected', (context) => {
operationContext.global.logger.error('[AMQP] disconnected %s', context.error && context.error.stack);
if (onDisconnected) {
onDisconnected();
@ -81,17 +81,17 @@ function connetPromise(closeCallback) {
});
}
function openSenderPromise(conn, options) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
resolve(conn.open_sender(options));
});
}
function openReceiverPromise(conn, options) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
resolve(conn.open_receiver(options));
});
}
function closePromise(conn) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
conn.close();
resolve();
});

254
Common/sources/commondefines.js
View File

@ -175,341 +175,341 @@ function InputCommand(data, copyExplicit) {
}
}
InputCommand.prototype = {
fillFromConnection: function(conn) {
fillFromConnection(conn) {
this['id'] = conn.docId;
},
getCommand: function() {
getCommand() {
return this['c'];
},
setCommand: function(data) {
setCommand(data) {
this['c'] = data;
},
getDocId: function() {
getDocId() {
return this['id'];
},
setDocId: function(data) {
setDocId(data) {
this['id'] = data;
},
getUserId: function() {
getUserId() {
return this['userid'];
},
setUserId: function(data) {
setUserId(data) {
this['userid'] = data;
},
getUserIndex: function() {
getUserIndex() {
return this['userindex'];
},
setUserIndex: function(data) {
setUserIndex(data) {
this['userindex'] = data;
},
getUserName: function() {
getUserName() {
return this['username'];
},
setUserName: function(data) {
setUserName(data) {
this['username'] = data;
},
getTokenSession: function() {
getTokenSession() {
return this['tokenSession'];
},
getTokenDownload: function() {
getTokenDownload() {
return this['tokenDownload'];
},
getData: function() {
getData() {
return this['data'];
},
setData: function(data) {
setData(data) {
this['data'] = data;
},
getFormat: function() {
getFormat() {
return this['format'];
},
setFormat: function(data) {
setFormat(data) {
this['format'] = data;
},
getOriginFormat: function() {
getOriginFormat() {
return this['originformat'];
},
setOriginFormat: function(data) {
setOriginFormat(data) {
this['originformat'] = data;
},
getUrl: function() {
getUrl() {
return this['url'];
},
setUrl: function(data) {
setUrl(data) {
this['url'] = data;
},
getTitle: function() {
getTitle() {
return this['title'];
},
setTitle: function(data) {
setTitle(data) {
this['title'] = data;
},
getOutputFormat: function() {
getOutputFormat() {
return this['outputformat'];
},
setOutputFormat: function(data) {
setOutputFormat(data) {
this['outputformat'] = data;
},
getOutputPath: function() {
getOutputPath() {
return this['outputpath'];
},
setOutputPath: function(data) {
setOutputPath(data) {
this['outputpath'] = data;
},
getSaveType: function() {
getSaveType() {
return this['savetype'];
},
setSaveType: function(data) {
setSaveType(data) {
this['savetype'] = data;
},
getSaveIndex: function() {
getSaveIndex() {
return this['saveindex'];
},
setSaveIndex: function(data) {
setSaveIndex(data) {
this['saveindex'] = data;
},
getCodepage: function() {
getCodepage() {
return this['codepage'];
},
setCodepage: function(data) {
setCodepage(data) {
this['codepage'] = data;
},
getDelimiter: function() {
getDelimiter() {
return this['delimiter'];
},
setDelimiter: function(data) {
setDelimiter(data) {
this['delimiter'] = data;
},
getDelimiterChar: function() {
getDelimiterChar() {
return this['delimiterChar'];
},
setDelimiterChar: function(data) {
setDelimiterChar(data) {
this['delimiterChar'] = data;
},
getEmbeddedFonts: function() {
getEmbeddedFonts() {
return this['embeddedfonts'];
},
setEmbeddedFonts: function(data) {
setEmbeddedFonts(data) {
this['embeddedfonts'] = data;
},
getMailMergeSend: function() {
getMailMergeSend() {
return this['mailmergesend'];
},
setMailMergeSend: function(data) {
setMailMergeSend(data) {
this['mailmergesend'] = data;
},
getThumbnail: function() {
getThumbnail() {
return this['thumbnail'];
},
setThumbnail: function(data) {
setThumbnail(data) {
this['thumbnail'] = data;
},
getTextParams: function() {
getTextParams() {
return this['textParams'];
},
setTextParams: function(data) {
setTextParams(data) {
this['textParams'] = data;
},
getStatus: function() {
getStatus() {
return this['status'];
},
setStatus: function(data) {
setStatus(data) {
this['status'] = data;
},
getStatusInfo: function() {
getStatusInfo() {
return this['status_info'];
},
setStatusInfo: function(data) {
setStatusInfo(data) {
this['status_info'] = data;
},
getSaveKey: function() {
getSaveKey() {
return this['savekey'];
},
setSaveKey: function(data) {
setSaveKey(data) {
this['savekey'] = data;
},
getForgotten: function() {
getForgotten() {
return this['forgotten'];
},
setForgotten: function(data) {
setForgotten(data) {
this['forgotten'] = data;
},
getUserConnectionId: function() {
getUserConnectionId() {
return this['userconnectionid'];
},
setUserConnectionId: function(data) {
setUserConnectionId(data) {
this['userconnectionid'] = data;
},
getUserConnectionDocId: function() {
getUserConnectionDocId() {
return this['userconnectiondocid'];
},
setUserConnectionDocId: function(data) {
setUserConnectionDocId(data) {
this['userconnectiondocid'] = data;
},
getResponseKey: function() {
getResponseKey() {
return this['responsekey'];
},
setResponseKey: function(data) {
setResponseKey(data) {
this['responsekey'] = data;
},
getJsonParams: function() {
getJsonParams() {
return this['jsonparams'];
},
appendJsonParams: function (data) {
appendJsonParams (data) {
if (this['jsonparams']) {
config.util.extendDeep(this['jsonparams'], data);
} else {
this['jsonparams'] = data;
}
},
getLCID: function() {
getLCID() {
return this['lcid'];
},
setLCID: function(data) {
setLCID(data) {
this['lcid'] = data;
},
getUserActionId: function() {
getUserActionId() {
return this['useractionid'];
},
setUserActionId: function(data) {
setUserActionId(data) {
this['useractionid'] = data;
},
getUserActionIndex: function() {
getUserActionIndex() {
return this['useractionindex'];
},
setUserActionIndex: function(data) {
setUserActionIndex(data) {
this['useractionindex'] = data;
},
/**
* @return {CForceSaveData | null}
*/
getForceSave: function() {
getForceSave() {
return this['forcesave'];
},
/**
* @param {CForceSaveData} data
*/
setForceSave: function(data) {
setForceSave(data) {
this['forcesave'] = data;
},
getUserData: function() {
getUserData() {
return this['userdata'];
},
setUserData: function(data) {
setUserData(data) {
this['userdata'] = data;
},
getFormData: function() {
getFormData() {
return this['formdata'];
},
setFormData: function(data) {
setFormData(data) {
this['formdata'] = data;
},
getInline: function() {
getInline() {
return this['inline'];
},
setInline: function(data) {
setInline(data) {
this['inline'] = data;
},
getPassword: function() {
getPassword() {
return this['password'];
},
setPassword: function(data) {
setPassword(data) {
this['password'] = data;
},
getSavePassword: function() {
getSavePassword() {
return this['savepassword'];
},
setSavePassword: function(data) {
setSavePassword(data) {
this['savepassword'] = data;
},
getWithoutPassword: function() {
getWithoutPassword() {
return this['withoutPassword'];
},
setWithoutPassword: function(data) {
setWithoutPassword(data) {
this['withoutPassword'] = data;
},
setOutputUrls: function(data) {
setOutputUrls(data) {
this['outputurls'] = data;
},
getOutputUrls: function() {
getOutputUrls() {
return this['outputurls'];
},
getServerVersion: function() {
getServerVersion() {
return this['serverVersion'];
},
setServerVersion: function(data) {
setServerVersion(data) {
this['serverVersion'] = data;
},
getRedisKey: function() {
getRedisKey() {
return this['rediskey'];
},
setRedisKey: function(data) {
setRedisKey(data) {
this['rediskey'] = data;
},
getNoBase64: function() {
getNoBase64() {
return this['nobase64'];
},
setNoBase64: function(data) {
setNoBase64(data) {
this['nobase64'] = data;
},
getStatusInfoIn: function() {
getStatusInfoIn() {
return this['status_info_in'];
},
setStatusInfoIn: function(data) {
setStatusInfoIn(data) {
this['status_info_in'] = data;
},
getAttempt: function() {
getAttempt() {
return this['attempt'];
},
setAttempt: function(data) {
setAttempt(data) {
this['attempt'] = data;
},
getWithAuthorization: function() {
getWithAuthorization() {
return this['withAuthorization'];
},
setWithAuthorization: function(data) {
setWithAuthorization(data) {
this['withAuthorization'] = data;
},
getExternalChangeInfo: function() {
getExternalChangeInfo() {
return this['externalChangeInfo'];
},
setExternalChangeInfo: function(data) {
setExternalChangeInfo(data) {
this['externalChangeInfo'] = data;
},
getBuilderParams: function() {
getBuilderParams() {
return this['builderParams'];
},
setBuilderParams: function(data) {
setBuilderParams(data) {
this['builderParams'] = data;
},
getWopiParams: function() {
getWopiParams() {
return this['wopiParams'];
},
setWopiParams: function(data) {
setWopiParams(data) {
this['wopiParams'] = data;
},
getConvertToOrigin: function() {
getConvertToOrigin() {
return this['convertToOrigin'];
},
setConvertToOrigin: function(data) {
setConvertToOrigin(data) {
this['convertToOrigin'] = data;
},
getIsSaveAs: function() {
getIsSaveAs() {
return this['isSaveAs'];
},
setIsSaveAs: function(data) {
setIsSaveAs(data) {
this['isSaveAs'] = data;
},
getSaveAsPath: function() {
getSaveAsPath() {
return this['saveAsPath'];
},
setSaveAsPath: function(data) {
setSaveAsPath(data) {
this['saveAsPath'] = data;
},
getOformAsPdf: function() {
getOformAsPdf() {
return this['oformAsPdf'];
},
setOformAsPdf: function(data) {
setOformAsPdf(data) {
this['oformAsPdf'] = data;
}
};
@ -770,58 +770,58 @@ function TaskQueueData(data) {
}
}
TaskQueueData.prototype = {
getCtx : function() {
getCtx() {
return this['ctx'];
},
setCtx : function(data) {
setCtx(data) {
return this['ctx'] = data;
},
getCmd : function() {
getCmd() {
return this['cmd'];
},
setCmd : function(data) {
setCmd(data) {
return this['cmd'] = data;
},
getToFile : function() {
getToFile() {
return this['toFile'];
},
setToFile : function(data) {
setToFile(data) {
return this['toFile'] = data;
},
getFromOrigin : function() {
getFromOrigin() {
return this['fromOrigin'];
},
setFromOrigin : function(data) {
setFromOrigin(data) {
return this['fromOrigin'] = data;
},
getFromSettings : function() {
getFromSettings() {
return this['fromSettings'];
},
setFromSettings : function(data) {
setFromSettings(data) {
return this['fromSettings'] = data;
},
getFromChanges : function() {
getFromChanges() {
return this['fromChanges'];
},
setFromChanges : function(data) {
setFromChanges(data) {
return this['fromChanges'] = data;
},
getPaid : function() {
getPaid() {
return this['paid'];
},
setPaid : function(data) {
setPaid(data) {
return this['paid'] = data;
},
getDataKey : function() {
getDataKey() {
return this['dataKey'];
},
setDataKey : function(data) {
setDataKey(data) {
return this['dataKey'] = data;
},
getVisibilityTimeout : function() {
getVisibilityTimeout() {
return this['visibilityTimeout'];
},
setVisibilityTimeout : function(data) {
setVisibilityTimeout(data) {
return this['visibilityTimeout'] = data;
}
};

6
Common/sources/formatchecker.js
View File

@ -591,7 +591,7 @@ function getDocumentFormatBySignature(buffer) {
if (!buffer) {
return constants.AVS_OFFICESTUDIO_FILE_UNKNOWN;
}
let text = buffer.toString("latin1");
const text = buffer.toString("latin1");
// Check for binary DOCT format.
if (4 <= text.length && text[0] === 'D' && text[1] === 'O' && text[2] === 'C' && text[3] === 'Y') {
return constants.AVS_OFFICESTUDIO_FILE_CANVAS_WORD;
@ -611,13 +611,13 @@ function getDocumentFormatBySignature(buffer) {
return constants.AVS_OFFICESTUDIO_FILE_UNKNOWN;
};
async function getDocumentFormatByFile(file) {
let firstBytesLen = 100;
const firstBytesLen = 100;
let buffer;
let fd;
try {
fd = await open(file, 'r');
const stream = fd.createReadStream({ start: 0, end: firstBytesLen });
let chunks = [];
const chunks = [];
for await (const chunk of stream) {
chunks.push(Buffer.from(chunk));
}

2
Common/sources/license.js
View File

@ -56,7 +56,7 @@ exports.readLicense = async function () {
usersExpire: constants.LICENSE_EXPIRE_USERS_ONE_DAY,
hasLicense: false,
buildDate: oBuildDate,
startDate: startDate,
startDate,
endDate: null,
customerId: "",
alias: "",

2
Common/sources/logger.js
View File

@ -53,7 +53,7 @@ var dateToJSONWithTZ = function (d) {
return iso + sign + leadingZero + Math.abs(timezoneOffsetInHours).toString() + ':00';
};
log4js.addLayout('json', function(config) {
log4js.addLayout('json', (config) => {
return function(logEvent) {
logEvent['startTime'] = dateToJSONWithTZ(logEvent['startTime']);
logEvent['message'] = util.format(...logEvent['data']);

4
Common/sources/notificationService.js
View File

@ -110,7 +110,7 @@ async function notify(ctx, notificationType, title, message, opt_cacheKey = unde
const tenRule = ctx.getCfg(`notification.rules.${notificationType}`, config.get(`notification.rules.${notificationType}`));
if (tenRule?.enable) {
ctx.logger.debug('Notification service: notify "%s"', notificationType);
let checkRes = await checkRulePolicies(ctx, notificationType, tenRule, opt_cacheKey);
const checkRes = await checkRulePolicies(ctx, notificationType, tenRule, opt_cacheKey);
if (checkRes) {
await notifyRule(ctx, tenRule, title, message);
}
@ -120,7 +120,7 @@ async function notify(ctx, notificationType, title, message, opt_cacheKey = unde
async function checkRulePolicies(ctx, notificationType, tenRule, opt_cacheKey) {
const { repeatInterval } = tenRule.policies;
//decrease repeatInterval by 1% to avoid race condition if timeout=repeatInterval
let ttl = Math.floor(ms(repeatInterval) * 0.99 / 1000);
const ttl = Math.floor(ms(repeatInterval) * 0.99 / 1000);
let isLock = false;
//todo for compatibility remove if after 8.2
if (editorStat?.lockNotification) {

20
Common/sources/operationContext.js
View File

@ -60,32 +60,32 @@ Context.prototype.initDefault = function() {
this.init(tenantManager.getDefautTenant(), constants.DEFAULT_DOC_ID, constants.DEFAULT_USER_ID, undefined);
};
Context.prototype.initFromConnection = function(conn) {
let tenant = tenantManager.getTenantByConnection(this, conn);
const tenant = tenantManager.getTenantByConnection(this, conn);
let docId = conn.docid;
if (!docId) {
let handshake = conn.handshake;
const handshake = conn.handshake;
const docIdParsed = constants.DOC_ID_SOCKET_PATTERN.exec(handshake.url);
if (docIdParsed && 1 < docIdParsed.length) {
docId = docIdParsed[1];
}
}
let userId = conn.user?.id;
let shardKey = utils.getShardKeyByConnection(this, conn);
let wopiSrc = utils.getWopiSrcByConnection(this, conn);
const userId = conn.user?.id;
const shardKey = utils.getShardKeyByConnection(this, conn);
const wopiSrc = utils.getWopiSrcByConnection(this, conn);
this.init(tenant, docId || this.docId, userId || this.userId, shardKey, wopiSrc);
};
Context.prototype.initFromRequest = function(req) {
let tenant = tenantManager.getTenantByRequest(this, req);
let shardKey = utils.getShardKeyByRequest(this, req);
let wopiSrc = utils.getWopiSrcByRequest(this, req);
const tenant = tenantManager.getTenantByRequest(this, req);
const shardKey = utils.getShardKeyByRequest(this, req);
const wopiSrc = utils.getWopiSrcByRequest(this, req);
this.init(tenant, this.docId, this.userId, shardKey, wopiSrc);
};
Context.prototype.initFromTaskQueueData = function(task) {
let ctx = task.getCtx();
const ctx = task.getCtx();
this.init(ctx.tenant, ctx.docId, ctx.userId, ctx.shardKey, ctx.wopiSrc);
};
Context.prototype.initFromPubSub = function(data) {
let ctx = data.ctx;
const ctx = data.ctx;
this.init(ctx.tenant, ctx.docId, ctx.userId, ctx.shardKey, ctx.wopiSrc);
};
Context.prototype.initTenantCache = async function() {

30
Common/sources/rabbitMQCore.js
View File

@ -42,14 +42,14 @@ var cfgRabbitSocketOptions = config.util.cloneDeep(config.get('rabbitmq.socketOp
var RECONNECT_TIMEOUT = 1000;
function connetPromise(closeCallback) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
function startConnect() {
amqp.connect(cfgRabbitUrl, cfgRabbitSocketOptions, function(err, conn) {
amqp.connect(cfgRabbitUrl, cfgRabbitSocketOptions, (err, conn) => {
if (null != err) {
operationContext.global.logger.error('[AMQP] %s', err.stack);
setTimeout(startConnect, RECONNECT_TIMEOUT);
} else {
conn.on('error', function(err) {
conn.on('error', (err) => {
operationContext.global.logger.error('[AMQP] conn error', err.stack);
});
var closeEventCallback = function() {
@ -68,8 +68,8 @@ function connetPromise(closeCallback) {
});
}
function createChannelPromise(conn) {
return new Promise(function(resolve, reject) {
conn.createChannel(function(err, channel) {
return new Promise((resolve, reject) => {
conn.createChannel((err, channel) => {
if (null != err) {
reject(err);
} else {
@ -79,8 +79,8 @@ function createChannelPromise(conn) {
});
}
function createConfirmChannelPromise(conn) {
return new Promise(function(resolve, reject) {
conn.createConfirmChannel(function(err, channel) {
return new Promise((resolve, reject) => {
conn.createConfirmChannel((err, channel) => {
if (null != err) {
reject(err);
} else {
@ -90,8 +90,8 @@ function createConfirmChannelPromise(conn) {
});
}
function assertExchangePromise(channel, exchange, type, options) {
return new Promise(function(resolve, reject) {
channel.assertExchange(exchange, type, options, function(err, ok) {
return new Promise((resolve, reject) => {
channel.assertExchange(exchange, type, options, (err, ok) => {
if (null != err) {
reject(err);
} else {
@ -101,8 +101,8 @@ function assertExchangePromise(channel, exchange, type, options) {
});
}
function assertQueuePromise(channel, queue, options) {
return new Promise(function(resolve, reject) {
channel.assertQueue(queue, options, function(err, ok) {
return new Promise((resolve, reject) => {
channel.assertQueue(queue, options, (err, ok) => {
if (null != err) {
reject(err);
} else {
@ -112,8 +112,8 @@ function assertQueuePromise(channel, queue, options) {
});
}
function consumePromise(channel, queue, messageCallback, options) {
return new Promise(function(resolve, reject) {
channel.consume(queue, messageCallback, options, function(err, ok) {
return new Promise((resolve, reject) => {
channel.consume(queue, messageCallback, options, (err, ok) => {
if (null != err) {
reject(err);
} else {
@ -123,8 +123,8 @@ function consumePromise(channel, queue, messageCallback, options) {
});
}
function closePromise(conn) {
return new Promise(function(resolve, reject) {
conn.close(function(err) {
return new Promise((resolve, reject) => {
conn.close((err) => {
if (err) {
reject(err);
} else {

4
Common/sources/storage/storage-az.js
View File

@ -175,14 +175,14 @@ async function deleteObject(storageCfg, strPath) {
}
async function deleteObjects(storageCfg, strPaths) {
let aKeys = strPaths.map(path => ({Key: getFilePath(storageCfg, path)}));
const aKeys = strPaths.map(path => ({Key: getFilePath(storageCfg, path)}));
for (let i = 0; i < aKeys.length; i += MAX_DELETE_OBJECTS) {
await deleteObjectsHelp(storageCfg, aKeys.slice(i, i + MAX_DELETE_OBJECTS));
}
}
async function deletePath(storageCfg, strPath) {
let list = await listObjects(storageCfg, strPath);
const list = await listObjects(storageCfg, strPath);
await deleteObjects(storageCfg, list);
}

76
Common/sources/storage/storage-base.js
View File

@ -72,57 +72,57 @@ function isDifferentPersistentStorage() {
}
async function headObject(ctx, strPath, opt_specialDir) {
let storage = getStorage(opt_specialDir);
let storageCfg = getStorageCfg(ctx, opt_specialDir);
const storage = getStorage(opt_specialDir);
const storageCfg = getStorageCfg(ctx, opt_specialDir);
return await storage.headObject(storageCfg, getStoragePath(ctx, strPath, opt_specialDir));
}
async function getObject(ctx, strPath, opt_specialDir) {
let storage = getStorage(opt_specialDir);
let storageCfg = getStorageCfg(ctx, opt_specialDir);
const storage = getStorage(opt_specialDir);
const storageCfg = getStorageCfg(ctx, opt_specialDir);
return await storage.getObject(storageCfg, getStoragePath(ctx, strPath, opt_specialDir));
}
async function createReadStream(ctx, strPath, opt_specialDir) {
let storage = getStorage(opt_specialDir);
let storageCfg = getStorageCfg(ctx, opt_specialDir);
const storage = getStorage(opt_specialDir);
const storageCfg = getStorageCfg(ctx, opt_specialDir);
return await storage.createReadStream(storageCfg, getStoragePath(ctx, strPath, opt_specialDir));
}
async function putObject(ctx, strPath, buffer, contentLength, opt_specialDir) {
let storage = getStorage(opt_specialDir);
let storageCfg = getStorageCfg(ctx, opt_specialDir);
const storage = getStorage(opt_specialDir);
const storageCfg = getStorageCfg(ctx, opt_specialDir);
return await storage.putObject(storageCfg, getStoragePath(ctx, strPath, opt_specialDir), buffer, contentLength);
}
async function uploadObject(ctx, strPath, filePath, opt_specialDir) {
let storage = getStorage(opt_specialDir);
let storageCfg = getStorageCfg(ctx, opt_specialDir);
const storage = getStorage(opt_specialDir);
const storageCfg = getStorageCfg(ctx, opt_specialDir);
return await storage.uploadObject(storageCfg, getStoragePath(ctx, strPath, opt_specialDir), filePath);
}
async function copyObject(ctx, sourceKey, destinationKey, opt_specialDirSrc, opt_specialDirDst) {
let storageSrc = getStorage(opt_specialDirSrc);
let storagePathSrc = getStoragePath(ctx, sourceKey, opt_specialDirSrc);
let storagePathDst = getStoragePath(ctx, destinationKey, opt_specialDirDst);
let storageCfgSrc = getStorageCfg(ctx, opt_specialDirSrc);
let storageCfgDst = getStorageCfg(ctx, opt_specialDirDst);
const storageSrc = getStorage(opt_specialDirSrc);
const storagePathSrc = getStoragePath(ctx, sourceKey, opt_specialDirSrc);
const storagePathDst = getStoragePath(ctx, destinationKey, opt_specialDirDst);
const storageCfgSrc = getStorageCfg(ctx, opt_specialDirSrc);
const storageCfgDst = getStorageCfg(ctx, opt_specialDirDst);
if (canCopyBetweenStorage(storageCfgSrc, storageCfgDst)){
return await storageSrc.copyObject(storageCfgSrc, storageCfgDst, storagePathSrc, storagePathDst);
} else {
let storageDst = getStorage(opt_specialDirDst);
const storageDst = getStorage(opt_specialDirDst);
//todo stream
let buffer = await storageSrc.getObject(storageCfgSrc, storagePathSrc);
const buffer = await storageSrc.getObject(storageCfgSrc, storagePathSrc);
return await storageDst.putObject(storageCfgDst, storagePathDst, buffer, buffer.length);
}
}
async function copyPath(ctx, sourcePath, destinationPath, opt_specialDirSrc, opt_specialDirDst) {
let list = await listObjects(ctx, sourcePath, opt_specialDirSrc);
await Promise.all(list.map(function(curValue) {
const list = await listObjects(ctx, sourcePath, opt_specialDirSrc);
await Promise.all(list.map((curValue) => {
return copyObject(ctx, curValue, destinationPath + '/' + getRelativePath(sourcePath, curValue), opt_specialDirSrc, opt_specialDirDst);
}));
}
async function listObjects(ctx, strPath, opt_specialDir) {
let storage = getStorage(opt_specialDir);
let storageCfg = getStorageCfg(ctx, opt_specialDir);
let prefix = getStoragePath(ctx, "", opt_specialDir);
const storage = getStorage(opt_specialDir);
const storageCfg = getStorageCfg(ctx, opt_specialDir);
const prefix = getStoragePath(ctx, "", opt_specialDir);
try {
let list = await storage.listObjects(storageCfg, getStoragePath(ctx, strPath, opt_specialDir));
const list = await storage.listObjects(storageCfg, getStoragePath(ctx, strPath, opt_specialDir));
return list.map((currentValue) => {
return currentValue.substring(prefix.length);
});
@ -132,19 +132,19 @@ async function listObjects(ctx, strPath, opt_specialDir) {
}
}
async function deleteObject(ctx, strPath, opt_specialDir) {
let storage = getStorage(opt_specialDir);
let storageCfg = getStorageCfg(ctx, opt_specialDir);
const storage = getStorage(opt_specialDir);
const storageCfg = getStorageCfg(ctx, opt_specialDir);
return await storage.deleteObject(storageCfg, getStoragePath(ctx, strPath, opt_specialDir));
}
async function deletePath(ctx, strPath, opt_specialDir) {
let storage = getStorage(opt_specialDir);
let storageCfg = getStorageCfg(ctx, opt_specialDir);
const storage = getStorage(opt_specialDir);
const storageCfg = getStorageCfg(ctx, opt_specialDir);
return await storage.deletePath(storageCfg, getStoragePath(ctx, strPath, opt_specialDir));
}
async function getSignedUrl(ctx, baseUrl, strPath, urlType, optFilename, opt_creationDate, opt_specialDir, useDirectStorageUrls) {
let storage = getStorage(opt_specialDir);
let storageCfg = getStorageCfg(ctx, opt_specialDir);
let storagePath = getStoragePath(ctx, strPath, opt_specialDir);
const storage = getStorage(opt_specialDir);
const storageCfg = getStorageCfg(ctx, opt_specialDir);
const storagePath = getStoragePath(ctx, strPath, opt_specialDir);
const directUrlsEnabled = useDirectStorageUrls ?? storageCfg.useDirectStorageUrls;
if (directUrlsEnabled && storage.getDirectSignedUrl) {
@ -163,8 +163,8 @@ async function getSignedUrl(ctx, baseUrl, strPath, urlType, optFilename, opt_cre
url += uri;
var date = Date.now();
let creationDate = opt_creationDate || date;
let expiredAfter = (commonDefines.c_oAscUrlTypes.Session === urlType ? (cfgExpSessionAbsolute / 1000) : storageUrlExpires) || 31536000;
const creationDate = opt_creationDate || date;
const expiredAfter = (commonDefines.c_oAscUrlTypes.Session === urlType ? (cfgExpSessionAbsolute / 1000) : storageUrlExpires) || 31536000;
//todo creationDate can be greater because mysql CURRENT_TIMESTAMP uses local time, not UTC
var expires = creationDate + Math.ceil(Math.abs(date - creationDate) / expiredAfter) * expiredAfter;
expires = Math.ceil(expires / 1000);
@ -195,24 +195,24 @@ async function getSignedUrl(ctx, baseUrl, strPath, urlType, optFilename, opt_cre
}
}
async function getSignedUrls(ctx, baseUrl, strPath, urlType, opt_creationDate, opt_specialDir) {
let list = await listObjects(ctx, strPath, opt_specialDir);
let outputMap = {};
const list = await listObjects(ctx, strPath, opt_specialDir);
const outputMap = {};
for (let i = 0; i < list.length; ++i) {
outputMap[getRelativePath(strPath, list[i])] = await getSignedUrl(ctx, baseUrl, list[i], urlType, undefined, opt_creationDate, opt_specialDir);
}
return outputMap;
}
async function getSignedUrlsArrayByArray(ctx, baseUrl, list, urlType, opt_specialDir) {
return await Promise.all(list.map(function (curValue) {
return await Promise.all(list.map((curValue) => {
return getSignedUrl(ctx, baseUrl, curValue, urlType, undefined, undefined, opt_specialDir);
}));
}
async function getSignedUrlsByArray(ctx, baseUrl, list, optPath, urlType, opt_specialDir) {
let urls = await getSignedUrlsArrayByArray(ctx, baseUrl, list, urlType, opt_specialDir);
const urls = await getSignedUrlsArrayByArray(ctx, baseUrl, list, urlType, opt_specialDir);
var outputMap = {};
for (var i = 0; i < list.length && i < urls.length; ++i) {
if (optPath) {
let storagePathSrc = getStoragePath(ctx, optPath, opt_specialDir);
const storagePathSrc = getStoragePath(ctx, optPath, opt_specialDir);
outputMap[getRelativePath(storagePathSrc, list[i])] = urls[i];
} else {
outputMap[list[i]] = urls[i];
@ -237,7 +237,7 @@ async function healthCheck(ctx, opt_specialDir) {
}
}
function needServeStatic(opt_specialDir) {
let storage = getStorage(opt_specialDir);
const storage = getStorage(opt_specialDir);
return storage.needServeStatic();
}

32
Common/sources/storage/storage-fs.js
View File

@ -47,24 +47,24 @@ function getOutputPath(strPath) {
}
async function headObject(storageCfg, strPath) {
let fsPath = getFilePath(storageCfg, strPath);
let stats = await stat(fsPath);
const fsPath = getFilePath(storageCfg, strPath);
const stats = await stat(fsPath);
return {ContentLength: stats.size};
}
async function getObject(storageCfg, strPath) {
let fsPath = getFilePath(storageCfg, strPath);
const fsPath = getFilePath(storageCfg, strPath);
return await readFile(fsPath);
}
async function createReadStream(storageCfg, strPath) {
let fsPath = getFilePath(storageCfg, strPath);
let stats = await stat(fsPath);
let contentLength = stats.size;
let readStream = await utils.promiseCreateReadStream(fsPath);
const fsPath = getFilePath(storageCfg, strPath);
const stats = await stat(fsPath);
const contentLength = stats.size;
const readStream = await utils.promiseCreateReadStream(fsPath);
return {
contentLength: contentLength,
readStream: readStream
contentLength,
readStream
};
}
@ -75,27 +75,27 @@ async function putObject(storageCfg, strPath, buffer, contentLength) {
if (Buffer.isBuffer(buffer)) {
await writeFile(fsPath, buffer);
} else {
let writable = await utils.promiseCreateWriteStream(fsPath);
const writable = await utils.promiseCreateWriteStream(fsPath);
await utils.pipeStreams(buffer, writable, true);
}
}
async function uploadObject(storageCfg, strPath, filePath) {
let fsPath = getFilePath(storageCfg, strPath);
const fsPath = getFilePath(storageCfg, strPath);
await cp(filePath, fsPath, {force: true, recursive: true});
}
async function copyObject(storageCfgSrc, storageCfgDst, sourceKey, destinationKey) {
let fsPathSource = getFilePath(storageCfgSrc, sourceKey);
let fsPathDestination = getFilePath(storageCfgDst, destinationKey);
const fsPathSource = getFilePath(storageCfgSrc, sourceKey);
const fsPathDestination = getFilePath(storageCfgDst, destinationKey);
await cp(fsPathSource, fsPathDestination, {force: true, recursive: true});
}
async function listObjects(storageCfg, strPath) {
const storageFolderPath = storageCfg.fs.folderPath;
let fsPath = getFilePath(storageCfg, strPath);
let values = await utils.listObjects(fsPath);
return values.map(function(curvalue) {
const fsPath = getFilePath(storageCfg, strPath);
const values = await utils.listObjects(fsPath);
return values.map((curvalue) => {
return getOutputPath(curvalue.substring(storageFolderPath.length + 1));
});
}

30
Common/sources/storage/storage-s3.js
View File

@ -52,7 +52,7 @@ const cfgCacheStorage = config.get('storage');
//This operation enables you to delete multiple objects from a bucket using a single HTTP request. You may specify up to 1000 keys.
const MAX_DELETE_OBJECTS = 1000;
let clients = {};
const clients = {};
/**
* @param {Object} input - S3 command
@ -60,7 +60,7 @@ let clients = {};
* @param {string} commandType - putObject, copyObject, etc.
*/
function applyCommandOptions(input, storageCfg, commandType) {
if (!storageCfg.commandOptions) return;
if (!storageCfg.commandOptions) {return;}
if (storageCfg.commandOptions.s3 && storageCfg.commandOptions.s3[commandType]) {
Object.assign(input, storageCfg.commandOptions.s3[commandType]);
@ -75,7 +75,7 @@ function getS3Client(storageCfg) {
* export AWS_ACCESS_KEY_ID='AKID'
* export AWS_SECRET_ACCESS_KEY='SECRET'
*/
let configS3 = {
const configS3 = {
region: storageCfg.region,
endpoint: storageCfg.endpoint
};
@ -94,10 +94,10 @@ function getS3Client(storageCfg) {
const httpsAgent = new HttpsAgent(cfgRequestDefaults);
const httpAgent = new HttpAgent(cfgRequestDefaults);
configS3.requestHandler = new NodeHttpHandler({
httpAgent: httpAgent,
httpsAgent: httpsAgent
httpAgent,
httpsAgent
});
let configJson = JSON.stringify(configS3);
const configJson = JSON.stringify(configS3);
let client = clients[configJson];
if (!client) {
client = new S3Client(configS3);
@ -115,7 +115,7 @@ function joinListObjects(storageCfg, inputArray, outputArray) {
return;
}
const storageFolderName = storageCfg.storageFolderName;
let length = inputArray.length;
const length = inputArray.length;
for (let i = 0; i < length; i++) {
outputArray.push(inputArray[i].Key.substring((storageFolderName + '/').length));
}
@ -154,7 +154,7 @@ async function headObject(storageCfg, strPath) {
Key: getFilePath(storageCfg, strPath)
};
const command = new HeadObjectCommand(input);
let output = await getS3Client(storageCfg).send(command);
const output = await getS3Client(storageCfg).send(command);
return {ContentLength: output.ContentLength};
}
async function getObject(storageCfg, strPath) {
@ -224,11 +224,11 @@ async function copyObject(storageCfgSrc, storageCfgDst, sourceKey, destinationKe
await getS3Client(storageCfgDst).send(command);
}
async function listObjects(storageCfg, strPath) {
let params = {
const params = {
Bucket: storageCfg.bucketName,
Prefix: getFilePath(storageCfg, strPath)
};
let output = [];
const output = [];
await listObjectsExec(storageCfg, output, params);
return output;
}
@ -243,7 +243,7 @@ async function deleteObject(storageCfg, strPath) {
await getS3Client(storageCfg).send(command);
};
async function deleteObjects(storageCfg, strPaths) {
let aKeys = strPaths.map(function (currentValue) {
const aKeys = strPaths.map((currentValue) => {
return {Key: getFilePath(storageCfg, currentValue)};
});
for (let i = 0; i < aKeys.length; i += MAX_DELETE_OBJECTS) {
@ -251,7 +251,7 @@ async function deleteObjects(storageCfg, strPaths) {
}
}
async function deletePath(storageCfg, strPath) {
let list = await listObjects(storageCfg, strPath);
const list = await listObjects(storageCfg, strPath);
await deleteObjects(storageCfg, list);
}
@ -261,8 +261,8 @@ async function getDirectSignedUrl(ctx, storageCfg, baseUrl, strPath, urlType, op
// Signature version 4 presigned URLs must have an expiration date less than one week in the future
expires = Math.min(expires, 604800);
let userFriendlyName = optFilename ? optFilename.replace(/\//g, "%2f") : path.basename(strPath);
let contentDisposition = utils.getContentDisposition(userFriendlyName, null, null);
const userFriendlyName = optFilename ? optFilename.replace(/\//g, "%2f") : path.basename(strPath);
const contentDisposition = utils.getContentDisposition(userFriendlyName, null, null);
const input = {
Bucket: storageCfg.bucketName,
@ -273,7 +273,7 @@ async function getDirectSignedUrl(ctx, storageCfg, baseUrl, strPath, urlType, op
const command = new GetObjectCommand(input);
//default Expires 900 seconds
let options = {
const options = {
expiresIn: expires
};
return await getSignedUrl(getS3Client(storageCfg), command, options);

106
Common/sources/taskqueueRabbitMQ.js
View File

@ -60,7 +60,7 @@ function initRabbit(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
return co(function* () {
var e = null;
try {
var conn = yield rabbitMQCore.connetPromise(function() {
var conn = yield rabbitMQCore.connetPromise(() => {
clear(taskqueue);
if (!taskqueue.isClose) {
setTimeout(() => {
@ -70,11 +70,11 @@ function initRabbit(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
});
taskqueue.connection = conn;
var bAssertTaskQueue = false;
let optionsTaskQueueDefault = {
const optionsTaskQueueDefault = {
messageTtl: cfgQueueRetentionPeriod * 1000,
deadLetterExchange: cfgRabbitExchangeConvertDead.name
};
let optionsTaskQueue = {...optionsTaskQueueDefault, ...cfgRabbitQueueConvertTask.options};
const optionsTaskQueue = {...optionsTaskQueueDefault, ...cfgRabbitQueueConvertTask.options};
if (isAddTask) {
taskqueue.channelConvertTask = yield rabbitMQCore.createConfirmChannelPromise(conn);
yield rabbitMQCore.assertQueuePromise(taskqueue.channelConvertTask, cfgRabbitQueueConvertTask.name,
@ -97,12 +97,12 @@ function initRabbit(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
optionsTaskQueue);
}
yield rabbitMQCore.consumePromise(taskqueue.channelConvertTaskReceive, cfgRabbitQueueConvertTask.name,
function (message) {
(message) => {
co(function* () {
let ack = function() {
const ack = function() {
taskqueue.channelConvertTaskReceive && taskqueue.channelConvertTaskReceive.ack(message);
};
let redelivered = yield* pushBackRedeliveredRabbit(taskqueue, message, ack);
const redelivered = yield* pushBackRedeliveredRabbit(taskqueue, message, ack);
if (!redelivered) {
if (message) {
taskqueue.emit('task', message.content.toString(), ack);
@ -118,19 +118,19 @@ function initRabbit(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
cfgRabbitQueueConvertResponse.options);
}
yield rabbitMQCore.consumePromise(taskqueue.channelConvertResponseReceive, cfgRabbitQueueConvertResponse.name,
function (message) {
(message) => {
if (message) {
taskqueue.emit('response', message.content.toString(), function() {
taskqueue.emit('response', message.content.toString(), () => {
taskqueue.channelConvertResponseReceive && taskqueue.channelConvertResponseReceive.ack(message);
});
}
}, optionsReceive);
}
if (isAddDelayed) {
let optionsDelayedQueueDefault = {
const optionsDelayedQueueDefault = {
deadLetterExchange: cfgRabbitExchangeConvertDead.name
};
let optionsDelayedQueue = {...optionsDelayedQueueDefault, ...cfgRabbitQueueDelayed.options};
const optionsDelayedQueue = {...optionsDelayedQueueDefault, ...cfgRabbitQueueDelayed.options};
taskqueue.channelDelayed = yield rabbitMQCore.createConfirmChannelPromise(conn);
yield rabbitMQCore.assertQueuePromise(taskqueue.channelDelayed, cfgRabbitQueueDelayed.name, optionsDelayedQueue);
}
@ -141,10 +141,10 @@ function initRabbit(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
var queue = yield rabbitMQCore.assertQueuePromise(taskqueue.channelConvertDead, cfgRabbitQueueConvertDead.name, cfgRabbitQueueConvertDead.options);
taskqueue.channelConvertDead.bindQueue(queue, cfgRabbitExchangeConvertDead.name, '');
yield rabbitMQCore.consumePromise(taskqueue.channelConvertDead, queue, function(message) {
yield rabbitMQCore.consumePromise(taskqueue.channelConvertDead, queue, (message) => {
if (null != taskqueue.channelConvertDead) {
if (message) {
taskqueue.emit('dead', message.content.toString(), function() {
taskqueue.emit('dead', message.content.toString(), () => {
taskqueue.channelConvertDead.ack(message);
});
}
@ -166,7 +166,7 @@ function initActive(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
return co(function*() {
var e = null;
try {
var conn = yield activeMQCore.connetPromise(function() {
var conn = yield activeMQCore.connetPromise(() => {
clear(taskqueue);
if (!taskqueue.isClose) {
setTimeout(() => {
@ -177,7 +177,7 @@ function initActive(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
taskqueue.connection = conn;
if (isAddTask) {
//https://github.com/amqp/rhea/issues/251#issuecomment-535076570
let optionsConvertTask = {
const optionsConvertTask = {
target: {
address: cfgActiveQueueConvertTask,
capabilities: ['queue']
@ -187,7 +187,7 @@ function initActive(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
initSenderActive(taskqueue.channelConvertTask, taskqueue.channelConvertTaskData);
}
if (isAddResponse) {
let optionsConvertResponse = {
const optionsConvertResponse = {
target: {
address: cfgActiveQueueConvertResponse,
capabilities: ['queue']
@ -197,7 +197,7 @@ function initActive(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
initSenderActive(taskqueue.channelConvertResponse, taskqueue.channelConvertResponseData);
}
if (isAddTaskReceive) {
let optionsConvertTask = {
const optionsConvertTask = {
source: {
address: cfgActiveQueueConvertTask,
capabilities: ['queue']
@ -205,16 +205,16 @@ function initActive(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
credit_window: 0,
autoaccept: false
};
let receiver = yield activeMQCore.openReceiverPromise(conn, optionsConvertTask);
const receiver = yield activeMQCore.openReceiverPromise(conn, optionsConvertTask);
//todo ?consumer.dispatchAsync=false&consumer.prefetchSize=1
receiver.add_credit(1);
receiver.on("message", function(context) {
receiver.on("message", (context) => {
co(function*() {
let ack = function() {
const ack = function() {
context.delivery.accept();
receiver.add_credit(1);
};
let redelivered = yield* pushBackRedeliveredActive(taskqueue, context, ack);
const redelivered = yield* pushBackRedeliveredActive(taskqueue, context, ack);
if (!redelivered) {
if (context) {
taskqueue.emit('task', context.message.body, ack);
@ -225,7 +225,7 @@ function initActive(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
taskqueue.channelConvertTaskReceive = receiver;
}
if (isAddResponseReceive) {
let optionsConvertResponse = {
const optionsConvertResponse = {
source: {
address: cfgActiveQueueConvertResponse,
capabilities: ['queue']
@ -233,12 +233,12 @@ function initActive(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
credit_window: 0,
autoaccept: false
};
let receiver = yield activeMQCore.openReceiverPromise(conn, optionsConvertResponse);
const receiver = yield activeMQCore.openReceiverPromise(conn, optionsConvertResponse);
//todo ?consumer.dispatchAsync=false&consumer.prefetchSize=1
receiver.add_credit(1);
receiver.on("message", function(context) {
receiver.on("message", (context) => {
if (context) {
taskqueue.emit('response', context.message.body, function() {
taskqueue.emit('response', context.message.body, () => {
context.delivery.accept();
receiver.add_credit(1);
});
@ -247,7 +247,7 @@ function initActive(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
taskqueue.channelConvertResponseReceive = receiver;
}
if (isAddDelayed) {
let optionsDelayed = {
const optionsDelayed = {
target: {
address: cfgActiveQueueDelayed,
capabilities: ['queue']
@ -257,7 +257,7 @@ function initActive(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
initSenderActive(taskqueue.channelDelayed, taskqueue.channelDelayedData);
}
if (isEmitDead) {
let optionsConvertDead = {
const optionsConvertDead = {
source: {
address: cfgActiveQueueConvertDead,
capabilities: ['queue']
@ -265,12 +265,12 @@ function initActive(taskqueue, isAddTask, isAddResponse, isAddTaskReceive, isAdd
credit_window: 0,
autoaccept: false
};
let receiver = yield activeMQCore.openReceiverPromise(conn, optionsConvertDead);
const receiver = yield activeMQCore.openReceiverPromise(conn, optionsConvertDead);
//todo ?consumer.dispatchAsync=false&consumer.prefetchSize=1
receiver.add_credit(1);
receiver.on("message", function(context) {
receiver.on("message", (context) => {
if (context) {
taskqueue.emit('dead', context.message.body, function(){
taskqueue.emit('dead', context.message.body, () =>{
context.delivery.accept();
receiver.add_credit(1);
});
@ -306,8 +306,8 @@ function* pushBackRedeliveredRabbit(taskqueue, message, ack) {
try {
operationContext.global.logger.warn('checkRedelivered redelivered data=%j', message);
//remove current task and add new into tail of queue to remove redelivered flag
let data = message.content.toString();
let redeliveredCount = message.properties.headers['x-redelivered-count'];
const data = message.content.toString();
const redeliveredCount = message.properties.headers['x-redelivered-count'];
if (!redeliveredCount || redeliveredCount < cfgMaxRedeliveredCount) {
message.properties.headers['x-redelivered-count'] = redeliveredCount ? redeliveredCount + 1 : 1;
yield addTaskString(taskqueue, data, message.properties.priority, undefined, message.properties.headers);
@ -347,17 +347,17 @@ function repeat(taskqueue) {
//acknowledge data after reconnect raises an exception 'PRECONDITION_FAILED - unknown delivery tag'
for (var i = 0; i < taskqueue.addTaskStore.length; ++i) {
var elem = taskqueue.addTaskStore[i];
addTask(taskqueue, elem.task, elem.priority, function () {}, elem.expiration, elem.headers);
addTask(taskqueue, elem.task, elem.priority, () => {}, elem.expiration, elem.headers);
}
taskqueue.addTaskStore.length = 0;
for (var i = 0; i < taskqueue.addDelayedStore.length; ++i) {
var elem = taskqueue.addDelayedStore[i];
addDelayed(taskqueue, elem.task, elem.ttl, function () {});
addDelayed(taskqueue, elem.task, elem.ttl, () => {});
}
taskqueue.addDelayedStore.length = 0;
}
function addTaskRabbit(taskqueue, content, priority, callback, opt_expiration, opt_headers) {
var options = {persistent: true, priority: priority};
var options = {persistent: true, priority};
if (undefined !== opt_expiration) {
options.expiration = opt_expiration.toString();
}
@ -367,21 +367,21 @@ function addTaskRabbit(taskqueue, content, priority, callback, opt_expiration, o
taskqueue.channelConvertTask.sendToQueue(cfgRabbitQueueConvertTask.name, content, options, callback);
}
function addTaskActive(taskqueue, content, priority, callback, opt_expiration, opt_headers) {
var msg = {durable: true, priority: priority, body: content, ttl: cfgQueueRetentionPeriod * 1000};
var msg = {durable: true, priority, body: content, ttl: cfgQueueRetentionPeriod * 1000};
if (undefined !== opt_expiration) {
msg.ttl = opt_expiration;
}
let delivery = taskqueue.channelConvertTask.send(msg);
const delivery = taskqueue.channelConvertTask.send(msg);
if (delivery) {
taskqueue.channelConvertTaskData[delivery.id] = callback;
}
}
function addTaskString(taskqueue, task, priority, opt_expiration, opt_headers) {
//todo confirmation mode
return new Promise(function (resolve, reject) {
return new Promise((resolve, reject) => {
var content = Buffer.from(task);
if (null != taskqueue.channelConvertTask) {
addTask(taskqueue, content, priority, function (err, ok) {
addTask(taskqueue, content, priority, (err, ok) => {
if (null != err) {
reject(err);
} else {
@ -389,7 +389,7 @@ function addTaskString(taskqueue, task, priority, opt_expiration, opt_headers) {
}
}, opt_expiration, opt_headers);
} else {
taskqueue.addTaskStore.push({task: content, priority: priority, expiration: opt_expiration, headers: opt_headers});
taskqueue.addTaskStore.push({task: content, priority, expiration: opt_expiration, headers: opt_headers});
resolve();
}
});
@ -400,7 +400,7 @@ function addResponseRabbit(taskqueue, content, callback) {
}
function addResponseActive(taskqueue, content, callback) {
var msg = {durable: true, body: content};
let delivery = taskqueue.channelConvertResponse.send(msg);
const delivery = taskqueue.channelConvertResponse.send(msg);
if (delivery) {
taskqueue.channelConvertResponseData[delivery.id] = callback;
}
@ -416,8 +416,8 @@ function addDelayedRabbit(taskqueue, content, ttl, callback) {
taskqueue.channelDelayed.sendToQueue(cfgRabbitQueueDelayed.name, content, options, callback);
}
function addDelayedActive(taskqueue, content, ttl, callback) {
var msg = {durable: true, body: content, ttl: ttl};
let delivery = taskqueue.channelDelayed.send(msg);
var msg = {durable: true, body: content, ttl};
const delivery = taskqueue.channelDelayed.send(msg);
if (delivery) {
taskqueue.channelDelayedData[delivery.id] = callback;
}
@ -444,9 +444,9 @@ function healthCheckActive(taskqueue) {
}
function initSenderActive(sender, senderData) {
let processEvent = function (context, res) {
let id = context?.delivery?.id;
let callback = senderData[id];
const processEvent = function (context, res) {
const id = context?.delivery?.id;
const callback = senderData[id];
if (callback) {
delete senderData[id];
callback(res);
@ -518,8 +518,8 @@ TaskQueueRabbitMQ.prototype.init = function (isAddTask, isAddResponse, isAddTask
};
TaskQueueRabbitMQ.prototype.initPromise = function(isAddTask, isAddResponse, isAddTaskReceive, isAddResponseReceive, isEmitDead, isAddDelayed) {
var t = this;
return new Promise(function(resolve, reject) {
init(t, isAddTask, isAddResponse, isAddTaskReceive, isAddResponseReceive, isEmitDead, isAddDelayed, function(err) {
return new Promise((resolve, reject) => {
init(t, isAddTask, isAddResponse, isAddTaskReceive, isAddResponseReceive, isEmitDead, isAddDelayed, (err) => {
if (err) {
reject(err);
} else {
@ -534,10 +534,10 @@ TaskQueueRabbitMQ.prototype.addTask = function (task, priority, opt_expiration,
};
TaskQueueRabbitMQ.prototype.addResponse = function (task) {
var t = this;
return new Promise(function (resolve, reject) {
return new Promise((resolve, reject) => {
var content = Buffer.from(JSON.stringify(task));
if (null != t.channelConvertResponse) {
addResponse(t, content, function (err, ok) {
addResponse(t, content, (err, ok) => {
if (null != err) {
reject(err);
} else {
@ -551,10 +551,10 @@ TaskQueueRabbitMQ.prototype.addResponse = function (task) {
};
TaskQueueRabbitMQ.prototype.addDelayed = function (task, ttl) {
var t = this;
return new Promise(function (resolve, reject) {
return new Promise((resolve, reject) => {
var content = new Buffer(JSON.stringify(task));
if (null != t.channelDelayed) {
addDelayed(t, content, ttl, function (err, ok) {
addDelayed(t, content, ttl, (err, ok) => {
if (null != err) {
reject(err);
} else {
@ -562,13 +562,13 @@ TaskQueueRabbitMQ.prototype.addDelayed = function (task, ttl) {
}
});
} else {
t.addDelayedStore.push({task: content, ttl: ttl});
t.addDelayedStore.push({task: content, ttl});
resolve();
}
});
};
TaskQueueRabbitMQ.prototype.close = function () {
let t = this;
const t = this;
return co(function* () {
t.isClose = true;
if (t.channelConvertTask) {

28
Common/sources/tenantManager.js
View File

@ -104,14 +104,14 @@ function getTenantPathPrefix(ctx) {
async function getTenantConfig(ctx) {
let res = null;
if (isMultitenantMode(ctx) && !isDefaultTenant(ctx)) {
let tenantPath = utils.removeIllegalCharacters(ctx.tenant);
let configPath = path.join(cfgTenantsBaseDir, tenantPath, cfgTenantsFilenameConfig);
const tenantPath = utils.removeIllegalCharacters(ctx.tenant);
const configPath = path.join(cfgTenantsBaseDir, tenantPath, cfgTenantsFilenameConfig);
res = nodeCache.get(configPath);
if (res) {
ctx.logger.debug('getTenantConfig from cache');
} else {
try {
let cfgString = await readFile(configPath, {encoding: 'utf8'});
const cfgString = await readFile(configPath, {encoding: 'utf8'});
res = config.util.parseString(cfgString, path.extname(configPath).substring(1));
ctx.logger.debug('getTenantConfig from %s', configPath);
} catch (e) {
@ -133,8 +133,8 @@ async function setTenantConfig(ctx, config) {
let newConfig = await getTenantConfig(ctx);
if (isMultitenantMode(ctx) && !isDefaultTenant(ctx)) {
newConfig = utils.deepMergeObjects(newConfig || {}, config);
let tenantPath = utils.removeIllegalCharacters(ctx.tenant);
let configPath = path.join(cfgTenantsBaseDir, tenantPath, cfgTenantsFilenameConfig);
const tenantPath = utils.removeIllegalCharacters(ctx.tenant);
const configPath = path.join(cfgTenantsBaseDir, tenantPath, cfgTenantsFilenameConfig);
await writeFile(configPath, JSON.stringify(newConfig, null, 2), 'utf8');
nodeCache.set(configPath, newConfig);
}
@ -163,14 +163,14 @@ function getTenantSecret(ctx, type) {
let res = undefined;
//read secret file
if (isMultitenantMode(ctx) && !isDefaultTenant(ctx)) {
let tenantPath = utils.removeIllegalCharacters(ctx.tenant);
let secretPath = path.join(cfgTenantsBaseDir, tenantPath, cfgTenantsFilenameSecret);
const tenantPath = utils.removeIllegalCharacters(ctx.tenant);
const secretPath = path.join(cfgTenantsBaseDir, tenantPath, cfgTenantsFilenameSecret);
res = nodeCache.get(secretPath);
if (res) {
ctx.logger.debug('getTenantSecret from cache');
} else {
try {
let secret = yield readFile(secretPath, {encoding: 'utf8'});
const secret = yield readFile(secretPath, {encoding: 'utf8'});
//trim whitespace plus line terminators from string (newline is common on Posix systems)
res = secret.trim();
if (res.length !== secret.length) {
@ -209,7 +209,7 @@ function setDefLicense(data, original) {
}
//todo move to license file?
function fixTenantLicense(ctx, licenseInfo, licenseInfoTenant) {
let errors = [];
const errors = [];
//bitwise
if (0 !== (licenseInfo.mode & c_LM.Limited) && 0 === (licenseInfoTenant.mode & c_LM.Limited)) {
licenseInfoTenant.mode |= c_LM.Limited;
@ -224,7 +224,7 @@ function fixTenantLicense(ctx, licenseInfo, licenseInfoTenant) {
errors.push('developer');
}
//can not turn on
let flags = ['branding', 'customization'];
const flags = ['branding', 'customization'];
flags.forEach((flag) => {
if (!licenseInfo[flag] && licenseInfoTenant[flag]) {
licenseInfoTenant[flag] = licenseInfo[flag];
@ -266,8 +266,8 @@ async function getTenantLicense(ctx) {
if (isMultitenantMode(ctx) && !isDefaultTenant(ctx)) {
//todo alias is deprecated. remove one year after 8.3
if (licenseInfo.multitenancy || licenseInfo.alias) {
let tenantPath = utils.removeIllegalCharacters(ctx.tenant);
let licensePath = path.join(cfgTenantsBaseDir, tenantPath, cfgTenantsFilenameLicense);
const tenantPath = utils.removeIllegalCharacters(ctx.tenant);
const licensePath = path.join(cfgTenantsBaseDir, tenantPath, cfgTenantsFilenameLicense);
let licenseTupleTenant = nodeCache.get(licensePath);
if (licenseTupleTenant) {
ctx.logger.debug('getTenantLicense from cache');
@ -305,7 +305,7 @@ function isDefaultTenant(ctx) {
async function readLicenseTenant(ctx, licenseFile, baseVerifiedLicense) {
const c_LR = constants.LICENSE_RESULT;
const c_LM = constants.LICENSE_MODE;
let res = {...baseVerifiedLicense};
const res = {...baseVerifiedLicense};
let oLicense = null;
try {
const oFile = (await readFile(licenseFile)).toString();
@ -395,7 +395,7 @@ async function readLicenseTenant(ctx, licenseFile, baseVerifiedLicense) {
res.connectionsView = Math.min(res.connectionsView, constants.LICENSE_CONNECTIONS);
res.usersCount = Math.min(res.usersCount, constants.LICENSE_USERS);
res.usersViewCount = Math.min(res.usersViewCount, constants.LICENSE_USERS);
let errStr = res.usersCount ? `${res.usersCount} unique users` : `${res.connections} concurrent connections`;
const errStr = res.usersCount ? `${res.usersCount} unique users` : `${res.connections} concurrent connections`;
ctx.logger.error(`License: License needs to be renewed.\nYour users have only ${errStr} ` +
`available for document editing for the next ${graceDays} days.\nPlease renew the ` +
'license to restore the full access');

118
Common/sources/utils.js
View File

@ -103,7 +103,7 @@ var g_oIpFilterRules = new Map();
function getIpFilterRule(address) {
let exp = g_oIpFilterRules.get(address);
if (!exp) {
let regExpStr = address.split('*').map(escapeStringRegexp).join('.*');
const regExpStr = address.split('*').map(escapeStringRegexp).join('.*');
exp = new RegExp('^' + regExpStr + '$', 'i');
g_oIpFilterRules.set(address, exp);
}
@ -128,7 +128,7 @@ exports.getMillisecondsOfHour = function(date) {
return (date.getUTCMinutes() * 60 + date.getUTCSeconds()) * 1000 + date.getUTCMilliseconds();
};
exports.encodeXml = function(value) {
return value.replace(/[<>&'"\r\n\t\xA0]/g, function (c) {
return value.replace(/[<>&'"\r\n\t\xA0]/g, (c) => {
switch (c) {
case '<': return '&lt;';
case '>': return '&gt;';
@ -143,8 +143,8 @@ exports.encodeXml = function(value) {
});
};
function fsStat(fsPath) {
return new Promise(function(resolve, reject) {
fs.stat(fsPath, function(err, stats) {
return new Promise((resolve, reject) => {
fs.stat(fsPath, (err, stats) => {
if (err) {
reject(err);
} else {
@ -155,8 +155,8 @@ function fsStat(fsPath) {
}
exports.fsStat = fsStat;
function fsReadDir(fsPath) {
return new Promise(function(resolve, reject) {
fs.readdir(fsPath, function(err, list) {
return new Promise((resolve, reject) => {
fs.readdir(fsPath, (err, list) => {
if (err) {
return reject(err);
} else {
@ -225,13 +225,13 @@ exports.listObjects = function(fsPath, optNoSubDir) {
});
};
exports.sleep = function(ms) {
return new Promise(function(resolve) {
return new Promise((resolve) => {
setTimeout(resolve, ms);
});
};
exports.readFile = function(file) {
return new Promise(function(resolve, reject) {
fs.readFile(file, function(err, data) {
return new Promise((resolve, reject) => {
fs.readFile(file, (err, data) => {
if (err) {
reject(err);
} else {
@ -241,17 +241,17 @@ exports.readFile = function(file) {
});
};
function getContentDisposition (opt_filename, opt_useragent, opt_type) {
let type = opt_type || constants.CONTENT_DISPOSITION_ATTACHMENT;
return contentDisposition(opt_filename, {type: type});
const type = opt_type || constants.CONTENT_DISPOSITION_ATTACHMENT;
return contentDisposition(opt_filename, {type});
}
exports.getContentDisposition = getContentDisposition;
function isAllowDirectRequest(ctx, uri, isInJwtToken) {
let res = false;
const tenExternalRequestDirectIfIn = ctx.getCfg('externalRequest.directIfIn', cfgExternalRequestDirectIfIn);
let allowList = tenExternalRequestDirectIfIn.allowList;
const allowList = tenExternalRequestDirectIfIn.allowList;
if (allowList.length > 0) {
let allowIndex = allowList.findIndex((allowPrefix) => {
const allowIndex = allowList.findIndex((allowPrefix) => {
return uri.startsWith(allowPrefix);
}, uri);
res = -1 !== allowIndex;
@ -337,7 +337,7 @@ async function downloadUrlPromise(ctx, uri, optTimeout, optLimit, opt_Authorizat
const tenTenantRequestDefaults = ctx.getCfg('services.CoAuthoring.requestDefaults', cfgRequestDefaults);
const tenTokenOutboxHeader = ctx.getCfg('services.CoAuthoring.token.outbox.header', cfgTokenOutboxHeader);
const tenTokenOutboxPrefix = ctx.getCfg('services.CoAuthoring.token.outbox.prefix', cfgTokenOutboxPrefix);
let sizeLimit = optLimit || Number.MAX_VALUE;
const sizeLimit = optLimit || Number.MAX_VALUE;
uri = URI.serialize(URI.parse(uri));
const options = config.util.cloneDeep(tenTenantRequestDefaults);
@ -472,7 +472,7 @@ async function postRequestPromise(ctx, uri, postData, postDataStream, postDataSi
return {
response: {
statusCode: status,
headers: headers,
headers,
body: data
},
body: JSON.stringify(data)
@ -533,7 +533,7 @@ async function httpRequest(ctx, method, uri, opt_headers, opt_body, opt_timeout,
const axiosConfig = {
...options,
url: uri,
method: method,
method,
headers: requestHeaders,
responseType: 'stream',
signal: opt_timeout?.wholeCycle && AbortSignal.timeout ? AbortSignal.timeout(ms(opt_timeout.wholeCycle)) : undefined,
@ -664,7 +664,7 @@ function fillXmlResponse(val) {
}
function fillResponseSimple(res, str, contentType) {
let body = Buffer.from(str, 'utf-8');
const body = Buffer.from(str, 'utf-8');
res.setHeader('Content-Type', contentType + '; charset=UTF-8');
res.setHeader('Content-Length', body.length);
res.send(body);
@ -709,7 +709,7 @@ function fillResponseBuilder(res, key, urls, end, error) {
if (constants.NO_ERROR != error) {
output = {error: exports.mapAscServerErrorToOldError(error)};
} else {
output = {key: key, urls: urls, end: end};
output = {key, urls, end};
}
_fillResponse(res, output, true);
}
@ -717,13 +717,13 @@ function fillResponseBuilder(res, key, urls, end, error) {
exports.fillResponseBuilder = fillResponseBuilder;
function promiseCreateWriteStream(strPath, optOptions) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
var file = fs.createWriteStream(strPath, optOptions);
var errorCallback = function(e) {
reject(e);
};
file.on('error', errorCallback);
file.on('open', function() {
file.on('open', () => {
file.removeListener('error', errorCallback);
resolve(file);
});
@ -732,27 +732,27 @@ function promiseCreateWriteStream(strPath, optOptions) {
exports.promiseCreateWriteStream = promiseCreateWriteStream;
function promiseWaitDrain(stream) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
stream.once('drain', resolve);
});
}
exports.promiseWaitDrain = promiseWaitDrain;
function promiseWaitClose(stream) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
stream.once('close', resolve);
});
}
exports.promiseWaitClose = promiseWaitClose;
function promiseCreateReadStream(strPath) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
var file = fs.createReadStream(strPath);
var errorCallback = function(e) {
reject(e);
};
file.on('error', errorCallback);
file.on('open', function() {
file.on('open', () => {
file.removeListener('error', errorCallback);
resolve(file);
});
@ -777,8 +777,8 @@ exports.compareStringByLength = function(x, y) {
};
exports.promiseRedis = function(client, func) {
var newArguments = Array.prototype.slice.call(arguments, 2);
return new Promise(function(resolve, reject) {
newArguments.push(function(err, data) {
return new Promise((resolve, reject) => {
newArguments.push((err, data) => {
if (err) {
reject(err);
} else {
@ -831,25 +831,25 @@ function getBaseUrl(protocol, hostHeader, forwardedProtoHeader, forwardedHostHea
function getBaseUrlByConnection(ctx, conn) {
conn = conn.request;
//Header names are lower-cased. https://nodejs.org/api/http.html#messageheaders
let cloudfrontForwardedProto = conn.headers['cloudfront-forwarded-proto'];
let forwardedProto = conn.headers['x-forwarded-proto'];
let forwardedHost = conn.headers['x-forwarded-host'];
let forwardedPrefix = conn.headers['x-forwarded-prefix'];
let host = conn.headers['host'];
let proto = cloudfrontForwardedProto || forwardedProto;
const cloudfrontForwardedProto = conn.headers['cloudfront-forwarded-proto'];
const forwardedProto = conn.headers['x-forwarded-proto'];
const forwardedHost = conn.headers['x-forwarded-host'];
const forwardedPrefix = conn.headers['x-forwarded-prefix'];
const host = conn.headers['host'];
const proto = cloudfrontForwardedProto || forwardedProto;
ctx.logger.debug(`getBaseUrlByConnection host=%s x-forwarded-host=%s x-forwarded-proto=%s x-forwarded-prefix=%s cloudfront-forwarded-proto=%s `,
host, forwardedHost, forwardedProto, forwardedPrefix, cloudfrontForwardedProto);
return getBaseUrl('', host, proto, forwardedHost, forwardedPrefix);
}
function getBaseUrlByRequest(ctx, req) {
//case-insensitive match. https://expressjs.com/en/api.html#req.get
let cloudfrontForwardedProto = req.get('cloudfront-forwarded-proto');
let forwardedProto = req.get('x-forwarded-proto');
let forwardedHost = req.get('x-forwarded-host');
let forwardedPrefix = req.get('x-forwarded-prefix');
let host = req.get('host');
let protocol = req.protocol;
let proto = cloudfrontForwardedProto || forwardedProto;
const cloudfrontForwardedProto = req.get('cloudfront-forwarded-proto');
const forwardedProto = req.get('x-forwarded-proto');
const forwardedHost = req.get('x-forwarded-host');
const forwardedPrefix = req.get('x-forwarded-prefix');
const host = req.get('host');
const protocol = req.protocol;
const proto = cloudfrontForwardedProto || forwardedProto;
ctx.logger.debug(`getBaseUrlByRequest protocol=%s host=%s x-forwarded-host=%s x-forwarded-proto=%s x-forwarded-prefix=%s cloudfront-forwarded-proto=%s `,
protocol, host, forwardedHost, forwardedProto, forwardedPrefix, cloudfrontForwardedProto);
return getBaseUrl(protocol, host, proto, forwardedHost, forwardedPrefix);
@ -857,15 +857,15 @@ function getBaseUrlByRequest(ctx, req) {
exports.getBaseUrlByConnection = getBaseUrlByConnection;
exports.getBaseUrlByRequest = getBaseUrlByRequest;
function getDomainByConnection(ctx, conn) {
let incomingMessage = conn.request;
let host = incomingMessage.headers['host'];
let forwardedHost = incomingMessage.headers['x-forwarded-host'];
const incomingMessage = conn.request;
const host = incomingMessage.headers['host'];
const forwardedHost = incomingMessage.headers['x-forwarded-host'];
ctx.logger.debug("getDomainByConnection headers['host']=%s headers['x-forwarded-host']=%s", host, forwardedHost);
return getDomain(host, forwardedHost);
}
function getDomainByRequest(ctx, req) {
let host = req.get('host');
let forwardedHost = req.get('x-forwarded-host');
const host = req.get('host');
const forwardedHost = req.get('x-forwarded-host');
ctx.logger.debug("getDomainByRequest headers['host']=%s headers['x-forwarded-host']=%s", host, forwardedHost);
return getDomain(req.get('host'), req.get('x-forwarded-host'));
}
@ -888,12 +888,12 @@ exports.getWopiSrcByConnection = getWopiSrcByConnection;
exports.getShardKeyByRequest = getShardKeyByRequest;
exports.getWopiSrcByRequest = getWopiSrcByRequest;
function stream2Buffer(stream) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
if (!stream.readable) {
resolve(Buffer.alloc(0));
}
var bufs = [];
stream.on('data', function(data) {
stream.on('data', (data) => {
bufs.push(data);
});
function onEnd(err) {
@ -919,12 +919,12 @@ function changeOnlyOfficeUrl(inputUrl, strPath, optFilename) {
}
exports.changeOnlyOfficeUrl = changeOnlyOfficeUrl;
function pipeStreams(from, to, isEnd) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
from.pipe(to, {end: isEnd});
from.on('end', function() {
from.on('end', () => {
resolve();
});
from.on('error', function(e) {
from.on('error', (e) => {
reject(e);
});
});
@ -956,8 +956,8 @@ function checkIpFilter(ctx, ipString, opt_hostname) {
}
for (let i = 0; i < tenIpFilterRules.length; ++i) {
let rule = tenIpFilterRules[i];
let exp = getIpFilterRule(rule.address);
const rule = tenIpFilterRules[i];
const exp = getIpFilterRule(rule.address);
if ((opt_hostname && exp.test(opt_hostname)) || (ip4 && exp.test(ip4)) || (ip6 && exp.test(ip6))) {
if (!rule.allowed) {
const tenIpFilterErrorCode = ctx.getCfg('services.CoAuthoring.ipfilter.errorcode', cfgIpFilterErrorCode);
@ -986,7 +986,7 @@ function* checkHostFilter(ctx, hostname) {
}
exports.checkHostFilter = checkHostFilter;
function checkClientIp(req, res, next) {
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
ctx.initFromRequest(req);
const tenIpFilterUseForRequest = ctx.getCfg('services.CoAuthoring.ipfilter.useforrequest', cfgIpFilterUseForRequest);
let status = 0;
@ -1013,8 +1013,8 @@ function lowercaseQueryString(req, res, next) {
}
exports.lowercaseQueryString = lowercaseQueryString;
function dnsLookup(hostname, options) {
return new Promise(function(resolve, reject) {
dnscache.lookup(hostname, options, function(err, addresses){
return new Promise((resolve, reject) => {
dnscache.lookup(hostname, options, (err, addresses) =>{
if (err) {
reject(err);
} else {
@ -1054,10 +1054,10 @@ function fillJwtForRequest(ctx, payload, secret, opt_inBody) {
if (opt_inBody) {
data = payload;
} else {
data = {payload: payload};
data = {payload};
}
let options = {algorithm: tenTokenOutboxAlgorithm, expiresIn: tenTokenOutboxExpires};
const options = {algorithm: tenTokenOutboxAlgorithm, expiresIn: tenTokenOutboxExpires};
return jwt.sign(data, secret, options);
}
exports.fillJwtForRequest = fillJwtForRequest;
@ -1198,7 +1198,7 @@ exports.convertLicenseInfoToFileParams = function(licenseInfo) {
// ssbranding = false;
// whiteLabel = false;
// }
let license = {};
const license = {};
license.start_date = licenseInfo.startDate && licenseInfo.startDate.toJSON();
license.end_date = licenseInfo.endDate && licenseInfo.endDate.toJSON();
license.timelimited = 0 !== (constants.LICENSE_MODE.Limited & licenseInfo.mode);
@ -1219,7 +1219,7 @@ exports.convertLicenseInfoToFileParams = function(licenseInfo) {
return license;
};
exports.convertLicenseInfoToServerParams = function(licenseInfo) {
let license = {};
const license = {};
license.workersCount = licenseInfo.count;
license.resultType = licenseInfo.type;
license.packageType = licenseInfo.packageType;
@ -1229,7 +1229,7 @@ exports.convertLicenseInfoToServerParams = function(licenseInfo) {
return license;
};
exports.checkBaseUrl = function(ctx, baseUrl, opt_storageCfg) {
let storageExternalHost = opt_storageCfg ? opt_storageCfg.externalHost : cfgStorageExternalHost
const storageExternalHost = opt_storageCfg ? opt_storageCfg.externalHost : cfgStorageExternalHost
const tenStorageExternalHost = ctx.getCfg('storage.externalHost', storageExternalHost);
return tenStorageExternalHost ? tenStorageExternalHost : baseUrl;
};

610
DocService/sources/DocsCoServer.js
View File

File diff suppressed because it is too large Load Diff

30
DocService/sources/ai/aiEngineWrapper.js
View File

@ -60,21 +60,21 @@ const sandbox = {
TmpProviderForModels: null,
Providers: {},
InternalProviders: [],
_getHeaders: function() {return {};},
_getEndpointUrl: function() {return "";},
serializeProviders: function() {return [];},
ActionsGetSorted: function() {return [];},
getModels: function() {return [];},
onLoadInternalProviders: function() {},
_getHeaders() {return {};},
_getEndpointUrl() {return "";},
serializeProviders() {return [];},
ActionsGetSorted() {return [];},
getModels() {return [];},
onLoadInternalProviders() {},
Storage: {
serializeModels: function() {return [];}
serializeModels() {return [];}
},
CapabilitiesUI: {}
}
},
Asc: {
plugin: {
tr: function(text) {
tr(text) {
// Just return the original text in the stub
return text;
}
@ -88,7 +88,7 @@ const sandbox = {
* @param {Object} options - Fetch options (method, headers, body)
* @returns {Promise<Object>} - A promise that resolves to a response-like object
*/
fetch: function(url, options = {}) {
fetch(url, options = {}) {
const ctx = sandbox.ctx;
const method = options.method || 'GET';
@ -155,9 +155,9 @@ function loadInternalProviders() {
try {
//sandbox.ctx.logger.debug(`Loading provider ${file}:`);
let content = "(function(){\n" + providerCode + "\nreturn new Provider();})();";
const content = "(function(){\n" + providerCode + "\nreturn new Provider();})();";
// Execute provider code in sandbox
let provider = vm.runInNewContext(content, sandbox, {
const provider = vm.runInNewContext(content, sandbox, {
filename: file,
timeout: 5000
});
@ -243,12 +243,12 @@ if (engineCode) {
AI.ActionsGetSorted = function()
{
let keys = AI.ActionsGetKeys();
let count = keys.length;
let actions = new Array(count);
const keys = AI.ActionsGetKeys();
const count = keys.length;
const actions = new Array(count);
for (let i = 0; i < count; i++)
{
let src = AI.Actions[keys[i]];
const src = AI.Actions[keys[i]];
actions[i] = {
id : keys[i],
name : Asc.plugin.tr(src.name),

26
DocService/sources/ai/aiProxyHandler.js
View File

@ -175,7 +175,7 @@ async function proxyRequest(req, res) {
let docId = '';
let userId = '';
if (tenTokenEnableBrowser) {
let checkJwtRes = await docsCoServer.checkJwtHeader(ctx, req, 'Authorization', 'Bearer ', commonDefines.c_oAscSecretType.Session);
const checkJwtRes = await docsCoServer.checkJwtHeader(ctx, req, 'Authorization', 'Bearer ', commonDefines.c_oAscSecretType.Session);
if (!checkJwtRes || checkJwtRes.err) {
ctx.logger.error('proxyRequest: checkJwtHeader error: %s', checkJwtRes?.err);
res.status(403).json({
@ -204,7 +204,7 @@ async function proxyRequest(req, res) {
return;
}
let body = JSON.parse(req.body);
const body = JSON.parse(req.body);
let uri = body.target;
let providerHeaders;
@ -247,16 +247,16 @@ async function proxyRequest(req, res) {
if (tenTokenEnableOutbox) {
const tenTokenOutboxHeader = ctx.getCfg('services.CoAuthoring.token.outbox.header', cfgTokenOutboxHeader);
const tenTokenOutboxPrefix = ctx.getCfg('services.CoAuthoring.token.outbox.prefix', cfgTokenOutboxPrefix);
let [licenseInfo] = await tenantManager.getTenantLicense(ctx);
const [licenseInfo] = await tenantManager.getTenantLicense(ctx);
let dataObject = {
const dataObject = {
key: docId,
user: userId,
customer_id: licenseInfo.customerId
}
let secret = await tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Outbox);
let auth = utils.fillJwtForRequest(ctx, dataObject, secret, false);
const secret = await tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Outbox);
const auth = utils.fillJwtForRequest(ctx, dataObject, secret, false);
headers[tenTokenOutboxHeader] = tenTokenOutboxPrefix + auth;
}
// Replace protocol, host and port in URI with proxy URL
@ -277,7 +277,7 @@ async function proxyRequest(req, res) {
// Create request parameters object
const requestParams = {
method: body.method,
uri: uri,
uri,
headers,
body: body.data,
timeout: timeoutOptions,
@ -345,8 +345,8 @@ async function processProvider(ctx, provider) {
if (!provider.url) {
return null;
}
let engineModels = [];
let engineModelsUI = [];
const engineModels = [];
const engineModelsUI = [];
try {
// Call getModels from engine.js
if (provider.key && AI.Providers[provider.name]) {
@ -452,7 +452,7 @@ async function getPluginSettingsForInterface(ctx) {
//check empty settings
if (pluginSettings && pluginSettings.actions) {
let isEmptySettings = true;
for (let key in pluginSettings.actions) {
for (const key in pluginSettings.actions) {
if (pluginSettings.actions[key].model) {
isEmptySettings = false;
}
@ -463,7 +463,7 @@ async function getPluginSettingsForInterface(ctx) {
}
//remove keys from providers
if (pluginSettings && pluginSettings.providers) {
for (let key in pluginSettings.providers) {
for (const key in pluginSettings.providers) {
pluginSettings.providers[key].key = "";
}
}
@ -488,12 +488,12 @@ async function requestModels(req, res) {
ctx.initFromRequest(req);
try {
await ctx.initTenantCache();
let body = JSON.parse(req.body);
const body = JSON.parse(req.body);
if (AI.Providers[body.name]) {
AI.Providers[body.name].key = body.key;
AI.Providers[body.name].url = body.url;
}
let getRes = await AI.getModels(body);
const getRes = await AI.getModels(body);
getRes.modelsApi = AI.TmpProviderForModels?.models;
res.json(getRes);
} catch (error) {

296
DocService/sources/canvasservice.js
View File

@ -91,21 +91,21 @@ function OutputDataWrap(type, data) {
this['data'] = data;
}
OutputDataWrap.prototype = {
fromObject: function(data) {
fromObject(data) {
this['type'] = data['type'];
this['data'] = new OutputData();
this['data'].fromObject(data['data']);
},
getType: function() {
getType() {
return this['type'];
},
setType: function(data) {
setType(data) {
this['type'] = data;
},
getData: function() {
getData() {
return this['data'];
},
setData: function(data) {
setData(data) {
this['data'] = data;
}
};
@ -117,41 +117,41 @@ function OutputData(type) {
this['openedAt'] = undefined;
}
OutputData.prototype = {
fromObject: function(data) {
fromObject(data) {
this['type'] = data['type'];
this['status'] = data['status'];
this['data'] = data['data'];
this['filetype'] = data['filetype'];
this['openedAt'] = data['openedAt'];
},
getType: function() {
getType() {
return this['type'];
},
setType: function(data) {
setType(data) {
this['type'] = data;
},
getStatus: function() {
getStatus() {
return this['status'];
},
setStatus: function(data) {
setStatus(data) {
this['status'] = data;
},
getData: function() {
getData() {
return this['data'];
},
setData: function(data) {
setData(data) {
this['data'] = data;
},
getExtName: function() {
getExtName() {
return this['filetype'];
},
setExtName: function(data) {
setExtName(data) {
this['filetype'] = data.substring(1);
},
getOpenedAt: function() {
getOpenedAt() {
return this['openedAt'];
},
setOpenedAt: function(data) {
setOpenedAt(data) {
this['openedAt'] = data;
}
};
@ -160,12 +160,12 @@ function getOpenedAt(row) {
if (row) {
return sqlBase.DocumentAdditional.prototype.getOpenedAt(row.additional);
}
return;
}
function getOpenedAtJSONParams(row) {
let documentLayout = row && sqlBase.DocumentAdditional.prototype.getDocumentLayout(row.additional);
const documentLayout = row && sqlBase.DocumentAdditional.prototype.getDocumentLayout(row.additional);
if (documentLayout) {
return {'documentLayout': documentLayout};
return {documentLayout};
}
return undefined;
}
@ -174,7 +174,7 @@ async function getOutputData(ctx, cmd, outputData, key, optConn, optAdditionalOu
const tenExpUpdateVersionStatus = ms(ctx.getCfg('services.CoAuthoring.expire.updateVersionStatus', cfgExpUpdateVersionStatus));
let status, statusInfo, password, creationDate, openedAt, originFormat, row;
let selectRes = await taskResult.select(ctx, key);
const selectRes = await taskResult.select(ctx, key);
if (selectRes.length > 0) {
row = selectRes[0];
status = row.status;
@ -239,7 +239,7 @@ async function getOutputData(ctx, cmd, outputData, key, optConn, optAdditionalOu
optAdditionalOutput.needUrlType = commonDefines.c_oAscUrlTypes.Temporary;
}
} else {
let encryptedUserPassword = cmd.getPassword();
const encryptedUserPassword = cmd.getPassword();
let userPassword;
let decryptedPassword;
let isCorrectPassword;
@ -252,7 +252,7 @@ async function getOutputData(ctx, cmd, outputData, key, optConn, optAdditionalOu
if (isNeedPassword && formatChecker.isBrowserEditorFormat(originFormat)) {
//check pdf form
//todo check without storage
let formEditor = await storage.listObjects(ctx, key + '/Editor.bin');
const formEditor = await storage.listObjects(ctx, key + '/Editor.bin');
isNeedPassword = 0 !== formEditor.length;
}
if (isNeedPassword) {
@ -281,7 +281,7 @@ async function getOutputData(ctx, cmd, outputData, key, optConn, optAdditionalOu
outputData.setStatus('needparams');
var settingsPath = key + '/' + 'origin.' + cmd.getFormat();
if (optConn) {
let url = await storage.getSignedUrl(ctx, optConn.baseUrl, settingsPath, commonDefines.c_oAscUrlTypes.Temporary);
const url = await storage.getSignedUrl(ctx, optConn.baseUrl, settingsPath, commonDefines.c_oAscUrlTypes.Temporary);
outputData.setData(url);
} else if (optAdditionalOutput) {
optAdditionalOutput.needUrlKey = settingsPath;
@ -316,13 +316,13 @@ async function getOutputData(ctx, cmd, outputData, key, optConn, optAdditionalOu
return status;
}
function* addRandomKeyTaskCmd(ctx, cmd) {
let docId = cmd.getDocId();
let task = yield* taskResult.addRandomKeyTask(ctx, docId);
const docId = cmd.getDocId();
const task = yield* taskResult.addRandomKeyTask(ctx, docId);
//set saveKey as postfix to fix vulnerability with path traversal to docId or other files
cmd.setSaveKey(task.key.substring(docId.length));
}
function addPasswordToCmd(ctx, cmd, docPasswordStr, originFormat) {
let docPassword = sqlBase.DocumentPassword.prototype.getDocPassword(ctx, docPasswordStr);
const docPassword = sqlBase.DocumentPassword.prototype.getDocPassword(ctx, docPasswordStr);
if (docPassword.current) {
if (formatChecker.isBrowserEditorFormat(originFormat)) {
//todo not allowed different password
@ -341,14 +341,14 @@ function addOriginFormat(ctx, cmd, row) {
function changeFormatByOrigin(ctx, row, format) {
const tenAssemblyFormatAsOrigin = ctx.getCfg('services.CoAuthoring.server.assemblyFormatAsOrigin', cfgAssemblyFormatAsOrigin);
let originFormat = row && row.change_id;
const originFormat = row && row.change_id;
if (originFormat && constants.AVS_OFFICESTUDIO_FILE_UNKNOWN !== originFormat) {
if (tenAssemblyFormatAsOrigin) {
format = originFormat;
} else {
//for wopi always save origin
let userAuthStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback);
let wopiParams = wopiClient.parseWopiCallback(ctx, userAuthStr, row.callback);
const userAuthStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback);
const wopiParams = wopiClient.parseWopiCallback(ctx, userAuthStr, row.callback);
if (wopiParams) {
format = originFormat;
}
@ -360,8 +360,8 @@ function* saveParts(ctx, cmd, filename) {
var result = false;
var saveType = cmd.getSaveType();
if (SAVE_TYPE_COMPLETE_ALL !== saveType) {
let ext = pathModule.extname(filename);
let saveIndex = parseInt(cmd.getSaveIndex()) || 1;//prevent path traversal
const ext = pathModule.extname(filename);
const saveIndex = parseInt(cmd.getSaveIndex()) || 1;//prevent path traversal
filename = pathModule.basename(filename, ext) + saveIndex + ext;
}
if ((SAVE_TYPE_PART_START === saveType || SAVE_TYPE_COMPLETE_ALL === saveType) && !cmd.getSaveKey()) {
@ -407,10 +407,10 @@ async function getUpdateResponse(ctx, cmd) {
var statusInfo = cmd.getStatusInfo();
if (constants.NO_ERROR === statusInfo) {
updateTask.status = commonDefines.FileStatus.Ok;
let password = cmd.getPassword();
const password = cmd.getPassword();
if (password) {
if (false === hasPasswordCol) {
let selectRes = await taskResult.select(ctx, updateTask.key);
const selectRes = await taskResult.select(ctx, updateTask.key);
hasPasswordCol = selectRes.length > 0 && undefined !== selectRes[0].password;
}
if(hasPasswordCol) {
@ -465,7 +465,7 @@ var cleanupCacheIf = co.wrap(function* (ctx, mask) {
return res;
});
async function cleanupErrToReload(ctx, key) {
let updateTask = new taskResult.TaskResultData();
const updateTask = new taskResult.TaskResultData();
updateTask.tenant = ctx.tenant;
updateTask.key = key;
updateTask.status = commonDefines.FileStatus.None;
@ -498,7 +498,7 @@ function* commandOpen(ctx, conn, cmd, outputData, opt_upsertRes, opt_bIsRestore)
} else {
upsertRes = yield commandOpenStartPromise(ctx, cmd.getDocId(), utils.getBaseUrlByConnection(ctx, conn), undefined, cmd.getFormat());
}
let bCreate = upsertRes.isInsert;
const bCreate = upsertRes.isInsert;
let needAddTask = bCreate;
if (!bCreate) {
needAddTask = yield* commandOpenFillOutput(ctx, conn, cmd, outputData, opt_bIsRestore);
@ -510,18 +510,18 @@ function* commandOpen(ctx, conn, cmd, outputData, opt_upsertRes, opt_bIsRestore)
outputData.setStatus(undefined);
}
} else if (needAddTask) {
let updateMask = new taskResult.TaskResultData();
const updateMask = new taskResult.TaskResultData();
updateMask.tenant = ctx.tenant;
updateMask.key = cmd.getDocId();
updateMask.status = commonDefines.FileStatus.None;
let task = new taskResult.TaskResultData();
const task = new taskResult.TaskResultData();
task.status = commonDefines.FileStatus.WaitQueue;
task.statusInfo = constants.NO_ERROR;
let updateIfRes = yield taskResult.updateIf(ctx, task, updateMask);
const updateIfRes = yield taskResult.updateIf(ctx, task, updateMask);
if (updateIfRes.affectedRows > 0) {
let forgotten = yield storage.listObjects(ctx, cmd.getDocId(), tenForgottenFiles);
const forgotten = yield storage.listObjects(ctx, cmd.getDocId(), tenForgottenFiles);
//replace url with forgotten file because it absorbed all lost changes
if (forgotten.length > 0) {
ctx.logger.debug("commandOpen from forgotten");
@ -545,18 +545,18 @@ function* commandOpen(ctx, conn, cmd, outputData, opt_upsertRes, opt_bIsRestore)
}
}
function* commandOpenFillOutput(ctx, conn, cmd, outputData, opt_bIsRestore) {
let status = yield getOutputData(ctx, cmd, outputData, cmd.getDocId(), conn, undefined, opt_bIsRestore);
const status = yield getOutputData(ctx, cmd, outputData, cmd.getDocId(), conn, undefined, opt_bIsRestore);
return commonDefines.FileStatus.None === status;
}
function* commandReopen(ctx, conn, cmd, outputData) {
const tenOpenProtectedFile = ctx.getCfg('services.CoAuthoring.server.openProtectedFile', cfgOpenProtectedFile);
let res = true;
let isPassword = undefined !== cmd.getPassword();
const isPassword = undefined !== cmd.getPassword();
if (isPassword) {
let selectRes = yield taskResult.select(ctx, cmd.getDocId());
const selectRes = yield taskResult.select(ctx, cmd.getDocId());
if (selectRes.length > 0) {
let row = selectRes[0];
const row = selectRes[0];
if (sqlBase.DocumentPassword.prototype.getCurPassword(ctx, row.password)) {
ctx.logger.debug('commandReopen has password');
yield* commandOpenFillOutput(ctx, conn, cmd, outputData, false);
@ -566,7 +566,7 @@ function* commandReopen(ctx, conn, cmd, outputData) {
}
}
if (!isPassword || tenOpenProtectedFile) {
let updateMask = new taskResult.TaskResultData();
const updateMask = new taskResult.TaskResultData();
updateMask.tenant = ctx.tenant;
updateMask.key = cmd.getDocId();
updateMask.status = isPassword ? commonDefines.FileStatus.NeedPassword : commonDefines.FileStatus.NeedParams;
@ -603,7 +603,7 @@ function* commandReopen(ctx, conn, cmd, outputData) {
return res;
}
function* commandSave(ctx, cmd, outputData) {
let format = cmd.getFormat() || 'bin';
const format = cmd.getFormat() || 'bin';
var completeParts = yield* saveParts(ctx, cmd, "Editor." + format);
if (completeParts) {
var queueData = getSaveTask(ctx, cmd);
@ -613,8 +613,8 @@ function* commandSave(ctx, cmd, outputData) {
outputData.setData(cmd.getSaveKey());
}
function* commandSendMailMerge(ctx, cmd, outputData) {
let mailMergeSend = cmd.getMailMergeSend();
let isJson = mailMergeSend.getIsJsonKey();
const mailMergeSend = cmd.getMailMergeSend();
const isJson = mailMergeSend.getIsJsonKey();
var completeParts = yield* saveParts(ctx, cmd, isJson ? "Editor.json" : "Editor.bin");
var isErr = false;
if (completeParts && !isJson) {
@ -642,7 +642,7 @@ function* commandSendMailMerge(ctx, cmd, outputData) {
outputData.setData(cmd.getSaveKey());
}
}
let commandSfctByCmd = co.wrap(function*(ctx, cmd, opt_priority, opt_expiration, opt_queue, opt_initShardKey) {
const commandSfctByCmd = co.wrap(function*(ctx, cmd, opt_priority, opt_expiration, opt_queue, opt_initShardKey) {
var selectRes = yield taskResult.selectWithCache(ctx, cmd.getDocId());
var row = selectRes.length > 0 ? selectRes[0] : null;
if (!row) {
@ -655,13 +655,13 @@ let commandSfctByCmd = co.wrap(function*(ctx, cmd, opt_priority, opt_expiration,
yield* addRandomKeyTaskCmd(ctx, cmd);
addPasswordToCmd(ctx, cmd, row.password, row.change_id);
addOriginFormat(ctx, cmd, row);
let userAuthStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback);
const userAuthStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback);
cmd.setWopiParams(wopiClient.parseWopiCallback(ctx, userAuthStr, row.callback));
cmd.setOutputFormat(changeFormatByOrigin(ctx, row, cmd.getOutputFormat()));
cmd.appendJsonParams(getOpenedAtJSONParams(row));
var queueData = getSaveTask(ctx, cmd);
queueData.setFromChanges(true);
let priority = null != opt_priority ? opt_priority : constants.QUEUE_PRIORITY_LOW;
const priority = null != opt_priority ? opt_priority : constants.QUEUE_PRIORITY_LOW;
yield* docsCoServer.addTask(queueData, priority, opt_queue, opt_expiration);
return true;
});
@ -677,7 +677,7 @@ function isDisplayedImage(strName) {
if (!isNaN(displayN)) {
var imageIndex = index + findStr.length + 1;
if (imageIndex == strName.indexOf("image", imageIndex))
res = displayN;
{res = displayN;}
}
}
}
@ -692,15 +692,15 @@ function* commandImgurls(ctx, conn, cmd, outputData) {
var errorCode = constants.NO_ERROR;
let urls = cmd.getData();
let authorizations = [];
const authorizations = [];
let isInJwtToken = false;
let token = cmd.getTokenDownload();
const token = cmd.getTokenDownload();
if (tenTokenEnableBrowser && token) {
let checkJwtRes = yield docsCoServer.checkJwt(ctx, token, commonDefines.c_oAscSecretType.Browser);
const checkJwtRes = yield docsCoServer.checkJwt(ctx, token, commonDefines.c_oAscSecretType.Browser);
if (checkJwtRes.decoded) {
//todo multiple url case
if (checkJwtRes.decoded.images) {
urls = checkJwtRes.decoded.images.map(function(curValue) {
urls = checkJwtRes.decoded.images.map((curValue) => {
return curValue.url;
});
} else {
@ -708,7 +708,7 @@ function* commandImgurls(ctx, conn, cmd, outputData) {
}
for (let i = 0; i < urls.length; ++i) {
if (utils.canIncludeOutboxAuthorization(ctx, urls[i])) {
let secret = yield tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Outbox);
const secret = yield tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Outbox);
authorizations[i] = [utils.fillJwtForRequest(ctx, {url: urls[i]}, secret, false)];
}
}
@ -722,15 +722,15 @@ function* commandImgurls(ctx, conn, cmd, outputData) {
var outputUrls = [];
if (constants.NO_ERROR === errorCode && !conn.user.view && !conn.isCloseCoAuthoring) {
//todo Promise.all()
let displayedImageMap = {};//to make one prefix for ole object urls
const displayedImageMap = {};//to make one prefix for ole object urls
for (var i = 0; i < urls.length; ++i) {
var urlSource = urls[i];
var urlParsed;
var data = undefined;
if (urlSource?.startsWith('data:')) {
let delimiterIndex = urlSource.indexOf(',');
const delimiterIndex = urlSource.indexOf(',');
if (-1 != delimiterIndex) {
let dataLen = urlSource.length - (delimiterIndex + 1);
const dataLen = urlSource.length - (delimiterIndex + 1);
if ('hex' === urlSource.substring(delimiterIndex - 3, delimiterIndex).toLowerCase()) {
if (dataLen * 0.5 <= tenImageSize) {
data = Buffer.from(urlSource.substring(delimiterIndex + 1), 'hex');
@ -748,14 +748,14 @@ function* commandImgurls(ctx, conn, cmd, outputData) {
} else if (urlSource) {
try {
if (authorizations[i]) {
let urlParsed = urlModule.parse(urlSource);
let filterStatus = yield* utils.checkHostFilter(ctx, urlParsed.hostname);
const urlParsed = urlModule.parse(urlSource);
const filterStatus = yield* utils.checkHostFilter(ctx, urlParsed.hostname);
if (0 !== filterStatus) {
throw Error('checkIpFilter');
}
}
//todo stream
let getRes = yield utils.downloadUrlPromise(ctx, urlSource, tenImageDownloadTimeout, tenImageSize, authorizations[i], isInJwtToken);
const getRes = yield utils.downloadUrlPromise(ctx, urlSource, tenImageDownloadTimeout, tenImageSize, authorizations[i], isInJwtToken);
data = getRes.body;
urlParsed = urlModule.parse(urlSource);
} catch (e) {
@ -784,9 +784,9 @@ function* commandImgurls(ctx, conn, cmd, outputData) {
}
if (!isAllow && urlParsed) {
//for ole object, presentation video/audio
let ext = pathModule.extname(urlParsed.pathname).substring(1);
let urlBasename = pathModule.basename(urlParsed.pathname);
let displayedImageName = urlBasename.substring(0, urlBasename.length - ext.length - 1);
const ext = pathModule.extname(urlParsed.pathname).substring(1);
const urlBasename = pathModule.basename(urlParsed.pathname);
const displayedImageName = urlBasename.substring(0, urlBasename.length - ext.length - 1);
if (displayedImageMap.hasOwnProperty(displayedImageName)) {
formatStr = ext;
isAllow = true;
@ -837,10 +837,10 @@ function* commandImgurls(ctx, conn, cmd, outputData) {
}
}
function* commandPathUrls(ctx, conn, data, outputData) {
let listImages = data.map(function callback(currentValue) {
const listImages = data.map((currentValue) => {
return conn.docId + '/' + currentValue;
});
let urls = yield storage.getSignedUrlsArrayByArray(ctx, conn.baseUrl, listImages, commonDefines.c_oAscUrlTypes.Session);
const urls = yield storage.getSignedUrlsArrayByArray(ctx, conn.baseUrl, listImages, commonDefines.c_oAscUrlTypes.Session);
outputData.setStatus('ok');
outputData.setData(urls);
}
@ -860,7 +860,7 @@ function* commandPathUrl(ctx, conn, cmd, outputData) {
function* commandSaveFromOrigin(ctx, cmd, outputData, password) {
var completeParts = yield* saveParts(ctx, cmd, "changes0.json");
if (completeParts) {
let docPassword = sqlBase.DocumentPassword.prototype.getDocPassword(ctx, password);
const docPassword = sqlBase.DocumentPassword.prototype.getDocPassword(ctx, password);
//Use current password for pdf because password is entered in the browser when opening and is set via setPassword
if (docPassword.initial || docPassword.current) {
cmd.setPassword(docPassword.initial || docPassword.current);
@ -880,13 +880,13 @@ function* commandSetPassword(ctx, conn, cmd, outputData) {
let hasDocumentPassword = false;
let isDocumentPasswordModified = true;
let originFormat;
let selectRes = yield taskResult.select(ctx, cmd.getDocId());
const selectRes = yield taskResult.select(ctx, cmd.getDocId());
if (selectRes.length > 0) {
let row = selectRes[0];
const row = selectRes[0];
originFormat = row.change_id;
hasPasswordCol = undefined !== row.password;
if (commonDefines.FileStatus.Ok === row.status) {
let documentPasswordCurEnc = sqlBase.DocumentPassword.prototype.getCurPassword(ctx, row.password);
const documentPasswordCurEnc = sqlBase.DocumentPassword.prototype.getCurPassword(ctx, row.password);
if (documentPasswordCurEnc) {
hasDocumentPassword = true;
if (cmd.getPassword()) {
@ -899,17 +899,17 @@ function* commandSetPassword(ctx, conn, cmd, outputData) {
}
//https://github.com/ONLYOFFICE/web-apps/blob/4a7879b4f88f315fe94d9f7d97c0ed8aa9f82221/apps/documenteditor/main/app/controller/Main.js#L1652
//this.appOptions.isPasswordSupport = this.appOptions.isEdit && this.api.asc_isProtectionSupport() && (this.permissions.protect!==false);
let isPasswordSupport = tenOpenProtectedFile && !conn.user?.view && false !== conn.permissions?.protect;
const isPasswordSupport = tenOpenProtectedFile && !conn.user?.view && false !== conn.permissions?.protect;
ctx.logger.debug('commandSetPassword isEnterCorrectPassword=%s, hasDocumentPassword=%s, hasPasswordCol=%s, isPasswordSupport=%s', conn.isEnterCorrectPassword, hasDocumentPassword, hasPasswordCol, isPasswordSupport);
if (isPasswordSupport && hasPasswordCol && hasDocumentPassword && !isDocumentPasswordModified) {
outputData.setStatus('ok');
} else if (isPasswordSupport && (conn.isEnterCorrectPassword || !hasDocumentPassword) && hasPasswordCol) {
let updateMask = new taskResult.TaskResultData();
const updateMask = new taskResult.TaskResultData();
updateMask.tenant = ctx.tenant;
updateMask.key = cmd.getDocId();
updateMask.status = commonDefines.FileStatus.Ok;
let newChangesLastDate = new Date();
const newChangesLastDate = new Date();
newChangesLastDate.setMilliseconds(0);//remove milliseconds avoid issues with MySQL datetime rounding
var task = new taskResult.TaskResultData();
@ -926,8 +926,8 @@ function* commandSetPassword(ctx, conn, cmd, outputData) {
yield docsCoServer.modifyConnectionForPassword(ctx, conn, true);
}
if (changeInfo) {
let forceSave = yield docsCoServer.editorData.getForceSave(ctx, cmd.getDocId());
let index = forceSave?.index || 0;
const forceSave = yield docsCoServer.editorData.getForceSave(ctx, cmd.getDocId());
const index = forceSave?.index || 0;
yield docsCoServer.resetForceSaveAfterChanges(ctx, cmd.getDocId(), newChangesLastDate.getTime(), index, utils.getBaseUrlByConnection(ctx, conn), changeInfo);
}
} else {
@ -941,7 +941,7 @@ function* commandSetPassword(ctx, conn, cmd, outputData) {
}
}
function* commandChangeDocInfo(ctx, conn, cmd, outputData) {
let res = yield docsCoServer.changeConnectionInfo(ctx, conn, cmd);
const res = yield docsCoServer.changeConnectionInfo(ctx, conn, cmd);
if(res) {
outputData.setStatus('ok');
} else {
@ -952,7 +952,7 @@ function* commandChangeDocInfo(ctx, conn, cmd, outputData) {
function checkAndFixAuthorizationLength(authorization, data){
//todo it is stub (remove in future versions)
//8kb(https://stackoverflow.com/questions/686217/maximum-on-http-header-values) - 1kb(for other headers)
let res = authorization.length < 7168;
const res = authorization.length < 7168;
if (!res) {
data.setChangeUrl(undefined);
data.setChangeHistory({});
@ -985,12 +985,12 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
var savePathHistory = saveKey + '/changesHistory.json';
var forceSave = cmd.getForceSave();
var forceSaveType = forceSave ? forceSave.getType() : commonDefines.c_oAscForceSaveTypes.Command;
let forceSaveUserId = forceSave ? forceSave.getAuthorUserId() : undefined;
let forceSaveUserIndex = forceSave ? forceSave.getAuthorUserIndex() : undefined;
let callbackUserIndex = (forceSaveUserIndex || 0 === forceSaveUserIndex) ? forceSaveUserIndex : userLastChangeIndex;
const forceSaveUserId = forceSave ? forceSave.getAuthorUserId() : undefined;
const forceSaveUserIndex = forceSave ? forceSave.getAuthorUserIndex() : undefined;
const callbackUserIndex = (forceSaveUserIndex || 0 === forceSaveUserIndex) ? forceSaveUserIndex : userLastChangeIndex;
let uri, baseUrl, wopiParams, lastOpenDate;
let selectRes = yield taskResult.select(ctx, docId);
let row = selectRes.length > 0 ? selectRes[0] : null;
const selectRes = yield taskResult.select(ctx, docId);
const row = selectRes.length > 0 ? selectRes[0] : null;
if (row) {
if (row.callback) {
uri = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback, callbackUserIndex);
@ -1011,7 +1011,7 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
statusOk = docsCoServer.c_oAscServerStatus.MustSave;
statusErr = docsCoServer.c_oAscServerStatus.Corrupted;
}
let recoverTask = new taskResult.TaskResultData();
const recoverTask = new taskResult.TaskResultData();
recoverTask.status = commonDefines.FileStatus.Ok;
recoverTask.statusInfo = constants.NO_ERROR;
let updateIfTask = new taskResult.TaskResultData();
@ -1019,7 +1019,7 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
updateIfTask.statusInfo = Math.floor(Date.now() / 60000);//minutes
let updateIfRes;
let updateMask = new taskResult.TaskResultData();
const updateMask = new taskResult.TaskResultData();
updateMask.tenant = ctx.tenant;
updateMask.key = docId;
if (row) {
@ -1064,17 +1064,17 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
outputSfc.setActions([new commonDefines.OutputAction(commonDefines.c_oAscUserAction.ForceSaveButton, forceSaveUserId)]);
}
outputSfc.setUserData(cmd.getUserData());
let formsData = cmd.getFormData();
const formsData = cmd.getFormData();
if (formsData) {
let formsDataPath = saveKey + '/formsdata.json';
let formsBuffer = Buffer.from(JSON.stringify(formsData), 'utf8');
const formsDataPath = saveKey + '/formsdata.json';
const formsBuffer = Buffer.from(JSON.stringify(formsData), 'utf8');
yield storage.putObject(ctx, formsDataPath, formsBuffer, formsBuffer.length);
let formsDataUrl = yield storage.getSignedUrl(ctx, baseUrl, formsDataPath, commonDefines.c_oAscUrlTypes.Temporary);
const formsDataUrl = yield storage.getSignedUrl(ctx, baseUrl, formsDataPath, commonDefines.c_oAscUrlTypes.Temporary);
outputSfc.setFormsDataUrl(formsDataUrl);
}
if (!isError || isErrorCorrupted) {
try {
let forgotten = yield storage.listObjects(ctx, docId, tenForgottenFiles);
const forgotten = yield storage.listObjects(ctx, docId, tenForgottenFiles);
let isSendHistory = 0 === forgotten.length;
if (!isSendHistory) {
//check indicator file to determine if opening was from the forgotten file
@ -1088,14 +1088,14 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
//don't send history info because changes isn't from file in storage
var data = yield storage.getObject(ctx, savePathHistory);
outputSfc.setChangeHistory(JSON.parse(data.toString('utf-8')));
let changeUrl = yield storage.getSignedUrl(ctx, baseUrl, savePathChanges,
const changeUrl = yield storage.getSignedUrl(ctx, baseUrl, savePathChanges,
commonDefines.c_oAscUrlTypes.Temporary);
outputSfc.setChangeUrl(changeUrl);
} else {
//for backward compatibility. remove this when Community is ready
outputSfc.setChangeHistory({});
}
let url = yield storage.getSignedUrl(ctx, baseUrl, savePathDoc, commonDefines.c_oAscUrlTypes.Temporary);
const url = yield storage.getSignedUrl(ctx, baseUrl, savePathDoc, commonDefines.c_oAscUrlTypes.Temporary);
outputSfc.setUrl(url);
outputSfc.setExtName(pathModule.extname(savePathDoc));
} catch (e) {
@ -1111,12 +1111,12 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
outputSfc.setStatus(statusErr);
}
if (isSfcm) {
let selectRes = yield taskResult.select(ctx, docId);
let row = selectRes.length > 0 ? selectRes[0] : null;
const selectRes = yield taskResult.select(ctx, docId);
const row = selectRes.length > 0 ? selectRes[0] : null;
//send only if FileStatus.Ok to prevent forcesave after final save
if (row && row.status == commonDefines.FileStatus.Ok) {
if (forceSave) {
let forceSaveDate = forceSave.getTime() ? new Date(forceSave.getTime()): new Date();
const forceSaveDate = forceSave.getTime() ? new Date(forceSave.getTime()): new Date();
outputSfc.setForceSaveType(forceSaveType);
outputSfc.setLastSave(forceSaveDate.toISOString());
}
@ -1131,7 +1131,7 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
yield processWopiSaveAs(ctx, cmd);
replyStr = JSON.stringify({error: 0});
} else {
let isAutoSave = forceSaveType !== commonDefines.c_oAscForceSaveTypes.Button && forceSaveType !== commonDefines.c_oAscForceSaveTypes.Form;
const isAutoSave = forceSaveType !== commonDefines.c_oAscForceSaveTypes.Button && forceSaveType !== commonDefines.c_oAscForceSaveTypes.Form;
replyStr = yield processWopiPutFile(ctx, docId, wopiParams, savePathDoc, userLastChangeId, true, isAutoSave, false);
}
} else {
@ -1140,7 +1140,7 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
} else {
replyStr = yield docsCoServer.sendServerRequest(ctx, uri, outputSfc, checkAndFixAuthorizationLength);
}
let replyData = docsCoServer.parseReplyData(ctx, replyStr);
const replyData = docsCoServer.parseReplyData(ctx, replyStr);
isSfcmSuccess = replyData && commonDefines.c_oAscServerCommandErrors.NoError == replyData.error;
if (replyData && commonDefines.c_oAscServerCommandErrors.NoError != replyData.error) {
ctx.logger.warn('sendServerRequest returned an error: data = %s', replyStr);
@ -1152,16 +1152,16 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
}
} else {
//if anybody in document stop save
let editorsCount = yield docsCoServer.getEditorsCountPromise(ctx, docId);
const editorsCount = yield docsCoServer.getEditorsCountPromise(ctx, docId);
ctx.logger.debug('commandSfcCallback presence: count = %d', editorsCount);
if (0 === editorsCount || (isEncrypted && 1 === editorsCount)) {
if (!updateIfRes) {
updateIfRes = yield taskResult.updateIf(ctx, updateIfTask, updateMask);
}
if (updateIfRes.affectedRows > 0) {
let actualForceSave = yield docsCoServer.editorData.getForceSave(ctx, docId);
let forceSaveDate = (actualForceSave && actualForceSave.time) ? new Date(actualForceSave.time) : new Date();
let notModified = actualForceSave && true === actualForceSave.ended;
const actualForceSave = yield docsCoServer.editorData.getForceSave(ctx, docId);
const forceSaveDate = (actualForceSave && actualForceSave.time) ? new Date(actualForceSave.time) : new Date();
const notModified = actualForceSave && true === actualForceSave.ended;
outputSfc.setLastSave(forceSaveDate.toISOString());
outputSfc.setNotModified(notModified);
@ -1181,7 +1181,7 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
ctx.logger.error('sendServerRequest error: url = %s;data = %j %s', uri, outputSfc, err.stack);
const retryHttpStatus = new MultiRange(tenCallbackBackoffOptions.httpStatus);
if (!isEncrypted && !docsCoServer.getIsShutdown() && (!err.statusCode || retryHttpStatus.has(err.statusCode.toString()))) {
let attempt = cmd.getAttempt() || 0;
const attempt = cmd.getAttempt() || 0;
if (attempt < tenCallbackBackoffOptions.retries) {
needRetry = true;
} else {
@ -1209,7 +1209,7 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
}
if (lastOpenDate) {
//todo error case
let time = new Date() - lastOpenDate;
const time = new Date() - lastOpenDate;
ctx.logger.debug('commandSfcCallback saveAfterEditingSessionClosed=%d', time);
if (clientStatsD) {
clientStatsD.timing('coauth.saveAfterEditingSessionClosed', time);
@ -1245,7 +1245,7 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
if (storeForgotten && !needRetry && !isEncrypted && (!isError || isErrorCorrupted)) {
try {
ctx.logger.warn("storeForgotten");
let forgottenName = tenForgottenFilesName + pathModule.extname(cmd.getOutputPath());
const forgottenName = tenForgottenFilesName + pathModule.extname(cmd.getOutputPath());
yield storage.copyObject(ctx, savePathDoc, docId + '/' + forgottenName, undefined, tenForgottenFiles);
} catch (err) {
ctx.logger.error('Error storeForgotten: %s', err.stack);
@ -1257,7 +1257,7 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
//to unlock wopi file
yield docsCoServer.unlockWopiDoc(ctx, docId, callbackUserIndex);
//cleanupRes can be false in case of simultaneous opening. it is OK
let cleanupRes = yield cleanupCacheIf(ctx, updateMask);
const cleanupRes = yield cleanupCacheIf(ctx, updateMask);
ctx.logger.debug('storeForgotten cleanupRes=%s', cleanupRes);
}
}
@ -1265,12 +1265,12 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
yield* docsCoServer.setForceSave(ctx, docId, forceSave, cmd, isSfcmSuccess && !isError, outputSfc?.getUrl());
}
if (needRetry) {
let attempt = cmd.getAttempt() || 0;
const attempt = cmd.getAttempt() || 0;
cmd.setAttempt(attempt + 1);
let queueData = new commonDefines.TaskQueueData();
const queueData = new commonDefines.TaskQueueData();
queueData.setCtx(ctx);
queueData.setCmd(cmd);
let timeout = retry.createTimeout(attempt, tenCallbackBackoffOptions.timeout);
const timeout = retry.createTimeout(attempt, tenCallbackBackoffOptions.timeout);
ctx.logger.debug('commandSfcCallback backoff timeout = %d', timeout);
yield* docsCoServer.addDelayed(queueData, timeout);
}
@ -1280,11 +1280,11 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
}
if (needUpdateVersionEvent && !needRetry) {
yield docsCoServer.publish(ctx, {type: commonDefines.c_oPublishType.updateVersion, ctx: ctx, docId: docId, success: isSfcSuccess});
yield docsCoServer.publish(ctx, {type: commonDefines.c_oPublishType.updateVersion, ctx, docId, success: isSfcSuccess});
}
if ((docsCoServer.getIsShutdown() && !isSfcm) || cmd.getRedisKey()) {
let keyRedis = cmd.getRedisKey() ? cmd.getRedisKey() : redisKeyShutdown;
const keyRedis = cmd.getRedisKey() ? cmd.getRedisKey() : redisKeyShutdown;
yield docsCoServer.editorStat.removeShutdown(keyRedis, docId);
}
ctx.logger.debug('End commandSfcCallback');
@ -1292,15 +1292,15 @@ const commandSfcCallback = co.wrap(function*(ctx, cmd, isSfcm, isEncrypted) {
});
function* processWopiPutFile(ctx, docId, wopiParams, savePathDoc, userLastChangeId, isModifiedByUser, isAutosave, isExitSave) {
let res = '{"error": 1}';
let metadata = yield storage.headObject(ctx, savePathDoc);
let streamObj = yield storage.createReadStream(ctx, savePathDoc);
let postRes = yield wopiClient.putFile(ctx, wopiParams, null, streamObj.readStream, metadata.ContentLength, userLastChangeId, isModifiedByUser, isAutosave, isExitSave);
const metadata = yield storage.headObject(ctx, savePathDoc);
const streamObj = yield storage.createReadStream(ctx, savePathDoc);
const postRes = yield wopiClient.putFile(ctx, wopiParams, null, streamObj.readStream, metadata.ContentLength, userLastChangeId, isModifiedByUser, isAutosave, isExitSave);
if (postRes) {
res = '{"error": 0}';
let body = wopiClient.parsePutFileResponse(ctx, postRes);
const body = wopiClient.parsePutFileResponse(ctx, postRes);
//collabora nexcloud connector
if (body?.LastModifiedTime) {
let lastModifiedTimeInfo = wopiClient.getWopiModifiedMarker(wopiParams, body.LastModifiedTime);
const lastModifiedTimeInfo = wopiClient.getWopiModifiedMarker(wopiParams, body.LastModifiedTime);
yield commandOpenStartPromise(ctx, docId, undefined, lastModifiedTimeInfo);
}
}
@ -1432,7 +1432,7 @@ exports.openDocument = function(ctx, conn, cmd, opt_upsertRes, opt_bIsRestore) {
exports.downloadAs = function(req, res) {
return co(function* () {
var docId = 'null';
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
var startDate = null;
if(clientStatsD) {
@ -1450,7 +1450,7 @@ exports.downloadAs = function(req, res) {
if (tenTokenEnableBrowser) {
var isValidJwt = false;
if (cmd.getTokenDownload()) {
let checkJwtRes = yield docsCoServer.checkJwt(ctx, cmd.getTokenDownload(), commonDefines.c_oAscSecretType.Browser);
const checkJwtRes = yield docsCoServer.checkJwt(ctx, cmd.getTokenDownload(), commonDefines.c_oAscSecretType.Browser);
if (checkJwtRes.decoded) {
isValidJwt = true;
cmd.setFormat(checkJwtRes.decoded.fileType);
@ -1460,9 +1460,9 @@ exports.downloadAs = function(req, res) {
ctx.logger.warn('Error downloadAs jwt: %s', checkJwtRes.description);
}
} else {
let checkJwtRes = yield docsCoServer.checkJwt(ctx, cmd.getTokenSession(), commonDefines.c_oAscSecretType.Session);
const checkJwtRes = yield docsCoServer.checkJwt(ctx, cmd.getTokenSession(), commonDefines.c_oAscSecretType.Session);
if (checkJwtRes.decoded) {
let decoded = checkJwtRes.decoded;
const decoded = checkJwtRes.decoded;
var doc = checkJwtRes.decoded.document;
if (!doc.permissions || (false !== doc.permissions.download || false !== doc.permissions.print)) {
isValidJwt = true;
@ -1522,7 +1522,7 @@ exports.downloadAs = function(req, res) {
exports.saveFile = function(req, res) {
return co(function*() {
let docId = 'null';
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
let startDate = null;
if (clientStatsD) {
@ -1530,8 +1530,8 @@ exports.saveFile = function(req, res) {
}
ctx.initFromRequest(req);
yield ctx.initTenantCache();
let strCmd = req.query['cmd'];
let cmd = new commonDefines.InputCommand(JSON.parse(strCmd));
const strCmd = req.query['cmd'];
const cmd = new commonDefines.InputCommand(JSON.parse(strCmd));
docId = cmd.getDocId();
ctx.setDocId(docId);
ctx.logger.debug('Start saveFile');
@ -1539,9 +1539,9 @@ exports.saveFile = function(req, res) {
if (tenTokenEnableBrowser) {
let isValidJwt = false;
let checkJwtRes = yield docsCoServer.checkJwt(ctx, cmd.getTokenSession(), commonDefines.c_oAscSecretType.Session);
const checkJwtRes = yield docsCoServer.checkJwt(ctx, cmd.getTokenSession(), commonDefines.c_oAscSecretType.Session);
if (checkJwtRes.decoded) {
let doc = checkJwtRes.decoded.document;
const doc = checkJwtRes.decoded.document;
var edit = checkJwtRes.decoded.editorConfig;
if (doc.ds_encrypted && !edit.ds_view && !edit.ds_isCloseCoAuthoring) {
isValidJwt = true;
@ -1563,7 +1563,7 @@ exports.saveFile = function(req, res) {
yield* addRandomKeyTaskCmd(ctx, cmd);
cmd.setOutputPath(constants.OUTPUT_NAME + pathModule.extname(cmd.getOutputPath()));
yield storage.putObject(ctx, docId + cmd.getSaveKey() + '/' + cmd.getOutputPath(), req.body, req.body.length);
let replyStr = yield commandSfcCallback(ctx, cmd, false, true);
const replyStr = yield commandSfcCallback(ctx, cmd, false, true);
if (replyStr) {
utils.fillResponseSimple(res, replyStr, 'application/json');
} else {
@ -1589,12 +1589,12 @@ function getPrintFileUrl(ctx, docId, baseUrl, filename) {
baseUrl = utils.checkBaseUrl(ctx, baseUrl);
let token = '';
if (tenTokenEnableBrowser) {
let payload = {document: {key: docId}};
const payload = {document: {key: docId}};
token = yield docsCoServer.signToken(ctx, payload, tenTokenSessionAlgorithm, tenTokenSessionExpires / 1000, commonDefines.c_oAscSecretType.Session);
}
//while save printed file Chrome's extension seems to rely on the resource name set in the URI https://stackoverflow.com/a/53593453
//replace '/' with %2f before encodeURIComponent becase nginx determine %2f as '/' and get wrong system path
let userFriendlyName = encodeURIComponent(filename.replace(/\//g, "%2f"));
const userFriendlyName = encodeURIComponent(filename.replace(/\//g, "%2f"));
let res = `${baseUrl}/printfile/${encodeURIComponent(docId)}/${userFriendlyName}?token=${encodeURIComponent(token)}`;
if (ctx.shardKey) {
res += `&${constants.SHARD_KEY_API_NAME}=${encodeURIComponent(ctx.shardKey)}`;
@ -1610,7 +1610,7 @@ exports.getPrintFileUrl = getPrintFileUrl;
exports.printFile = function(req, res) {
return co(function*() {
let docId = 'null';
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
let startDate = null;
if (clientStatsD) {
@ -1618,17 +1618,17 @@ exports.printFile = function(req, res) {
}
ctx.initFromRequest(req);
yield ctx.initTenantCache();
let filename = req.query['filename'];
let token = req.query['token'];
const filename = req.query['filename'];
const token = req.query['token'];
docId = req.params.docid;
ctx.setDocId(docId);
ctx.logger.info('Start printFile');
const tenTokenEnableBrowser = ctx.getCfg('services.CoAuthoring.token.enable.browser', cfgTokenEnableBrowser);
if (tenTokenEnableBrowser) {
let checkJwtRes = yield docsCoServer.checkJwt(ctx, token, commonDefines.c_oAscSecretType.Session);
const checkJwtRes = yield docsCoServer.checkJwt(ctx, token, commonDefines.c_oAscSecretType.Session);
if (checkJwtRes.decoded) {
let docIdBase = checkJwtRes.decoded.document.key;
const docIdBase = checkJwtRes.decoded.document.key;
if (!docId.startsWith(docIdBase)) {
ctx.logger.warn('Error printFile jwt: description = %s', 'access deny');
res.sendStatus(403);
@ -1641,7 +1641,7 @@ exports.printFile = function(req, res) {
}
}
ctx.setDocId(docId);
let streamObj = yield storage.createReadStream(ctx, `${docId}/${constants.OUTPUT_NAME}.pdf`);
const streamObj = yield storage.createReadStream(ctx, `${docId}/${constants.OUTPUT_NAME}.pdf`);
res.setHeader('Content-Disposition', utils.getContentDisposition(filename, null, constants.CONTENT_DISPOSITION_INLINE));
res.setHeader('Content-Length', streamObj.contentLength);
res.setHeader('Content-Type', 'application/pdf');
@ -1668,7 +1668,7 @@ exports.printFile = function(req, res) {
*/
exports.downloadFile = function(req, res) {
return co(function*() {
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
let stream = null;
try {
let startDate = null;
@ -1702,7 +1702,7 @@ exports.downloadFile = function(req, res) {
let isInJwtToken = false;
let errorDescription;
let headers, fromTemplate;
let authRes = yield docsCoServer.getRequestParams(ctx, req);
const authRes = yield docsCoServer.getRequestParams(ctx, req);
if (authRes.code === constants.NO_ERROR) {
const decoded = authRes.params;
if (decoded.changesUrl) {
@ -1720,7 +1720,7 @@ exports.downloadFile = function(req, res) {
fromTemplate = pathModule.extname(decoded.fileInfo.BaseFileName).substring(1);
} else {
({url, headers} = yield wopiUtils.getWopiFileUrl(ctx, decoded.fileInfo, decoded.userAuth));
let filterStatus = yield wopiClient.checkIpFilter(ctx, url);
const filterStatus = yield wopiClient.checkIpFilter(ctx, url);
if (0 === filterStatus) {
//todo false? (true because it passed checkIpFilter for wopi)
//todo use directIfIn
@ -1754,10 +1754,10 @@ exports.downloadFile = function(req, res) {
} else {
if (utils.canIncludeOutboxAuthorization(ctx, url)) {
const secret = yield tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Outbox);
authorization = utils.fillJwtForRequest(ctx, {url: url}, secret, false);
authorization = utils.fillJwtForRequest(ctx, {url}, secret, false);
}
let urlParsed = urlModule.parse(url);
let filterStatus = yield* utils.checkHostFilter(ctx, urlParsed.hostname);
const urlParsed = urlModule.parse(url);
const filterStatus = yield* utils.checkHostFilter(ctx, urlParsed.hostname);
if (0 !== filterStatus) {
ctx.logger.warn('Error downloadFile checkIpFilter error: url = %s', url);
res.sendStatus(filterStatus);
@ -1855,7 +1855,7 @@ exports.saveFromChanges = function(ctx, docId, statusInfo, optFormat, opt_userId
cmd.appendJsonParams(getOpenedAtJSONParams(row));
//todo lang and region are different
cmd.setLCID(opt_userLcid);
let userAuthStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback);
const userAuthStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback);
cmd.setWopiParams(wopiClient.parseWopiCallback(ctx, userAuthStr, row.callback));
addPasswordToCmd(ctx, cmd, row && row.password, row && row.change_id);
addOriginFormat(ctx, cmd, row);
@ -1898,11 +1898,11 @@ async function processWopiSaveAs(ctx, cmd) {
const { wopiSrc, access_token } = info.wopiParams.userAuth;
res = await wopiClient.putRelativeFile(ctx, wopiSrc, access_token, null, stream.readStream, stream.contentLength, suggestedExt, suggestedTarget, false);
}
return {res: res, wopiParams: info?.wopiParams};
return {res, wopiParams: info?.wopiParams};
}
exports.receiveTask = function(data, ack) {
return co(function* () {
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
var task = new commonDefines.TaskQueueData(JSON.parse(data));
if (task) {
@ -1921,9 +1921,9 @@ exports.receiveTask = function(data, ack) {
yield getOutputData(ctx, cmd, outputData, cmd.getDocId(), null, additionalOutput);
//wopi from TemplateSource
if (additionalOutput.row) {
let row = additionalOutput.row;
let userAuthStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback);
let wopiParams = wopiClient.parseWopiCallback(ctx, userAuthStr, row.callback);
const row = additionalOutput.row;
const userAuthStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback);
const wopiParams = wopiClient.parseWopiCallback(ctx, userAuthStr, row.callback);
if (wopiParams?.commonInfo?.fileInfo?.TemplateSource) {
ctx.logger.debug('receiveTask: save document opened from TemplateSource');
//todo
@ -1936,10 +1936,10 @@ exports.receiveTask = function(data, ack) {
}
}
} else if ('save' === command || 'savefromorigin' === command) {
let status = yield getOutputData(ctx, cmd, outputData, cmd.getDocId() + cmd.getSaveKey(), null, additionalOutput);
const status = yield getOutputData(ctx, cmd, outputData, cmd.getDocId() + cmd.getSaveKey(), null, additionalOutput);
if (commonDefines.FileStatus.Ok === status && (cmd.getSaveAsPath() || cmd.getIsSaveAs())) {
//todo in case of wopi no need to send url. send it to avoid stubs in sdk
let saveAsRes = yield processWopiSaveAs(ctx, cmd);
const saveAsRes = yield processWopiSaveAs(ctx, cmd);
if (!saveAsRes.res && saveAsRes.wopiParams) {
outputData.setStatus('err');
outputData.setData(constants.CONVERT);
@ -1959,7 +1959,7 @@ exports.receiveTask = function(data, ack) {
ctx.logger.debug('receiveTask publish: %s', JSON.stringify(outputData));
var output = new OutputDataWrap('documentOpen', outputData);
yield docsCoServer.publish(ctx, {
type: commonDefines.c_oPublishType.receiveTask, ctx: ctx, cmd: cmd, output: output,
type: commonDefines.c_oPublishType.receiveTask, ctx, cmd, output,
needUrlKey: additionalOutput.needUrlKey,
needUrlMethod: additionalOutput.needUrlMethod,
needUrlType: additionalOutput.needUrlType,

62
DocService/sources/changes2forgotten.js
View File

@ -58,17 +58,17 @@ var WAIT_TIMEOUT = 30000;
var LOOP_TIMEOUT = 1000;
var EXEC_TIMEOUT = WAIT_TIMEOUT + utils.getConvertionTimeout(undefined);
let addSqlParam = sqlBase.addSqlParameter;
const addSqlParam = sqlBase.addSqlParameter;
function updateDoc(ctx, docId, status, callback) {
return new Promise(function(resolve, reject) {
let values = [];
let p1 = addSqlParam(status, values);
let p2 = addSqlParam(callback, values);
let p3 = addSqlParam(ctx.tenant, values);
let p4 = addSqlParam(docId, values);
let sqlCommand = `UPDATE ${cfgTableResult} SET status=${p1},callback=${p2} WHERE tenant=${p3} AND id=${p4};`;
sqlBase.sqlQuery(ctx, sqlCommand, function(error, result) {
return new Promise((resolve, reject) => {
const values = [];
const p1 = addSqlParam(status, values);
const p2 = addSqlParam(callback, values);
const p3 = addSqlParam(ctx.tenant, values);
const p4 = addSqlParam(docId, values);
const sqlCommand = `UPDATE ${cfgTableResult} SET status=${p1},callback=${p2} WHERE tenant=${p3} AND id=${p4};`;
sqlBase.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {
@ -81,37 +81,37 @@ function updateDoc(ctx, docId, status, callback) {
function shutdown() {
return co(function*() {
var res = true;
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
let editorStat = editorStatStorage.EditorStat ? new editorStatStorage.EditorStat() : new editorStatStorage();
const editorStat = editorStatStorage.EditorStat ? new editorStatStorage.EditorStat() : new editorStatStorage();
ctx.logger.debug('shutdown start:' + EXEC_TIMEOUT);
//redisKeyShutdown is not a simple counter, so it doesn't get decremented by a build that started before Shutdown started
//reset redisKeyShutdown just in case the previous run didn't finish yield editorData.cleanupShutdown(redisKeyShutdown);
let queue = new queueService();
const queue = new queueService();
yield queue.initPromise(true, false, false, false, false, false);
let pubsub = new pubsubService();
const pubsub = new pubsubService();
yield pubsub.initPromise();
//inner ping to update presence
ctx.logger.debug('shutdown pubsub shutdown message');
yield pubsub.publish(JSON.stringify({type: commonDefines.c_oPublishType.shutdown, ctx: ctx, status: true}));
yield pubsub.publish(JSON.stringify({type: commonDefines.c_oPublishType.shutdown, ctx, status: true}));
ctx.logger.debug('shutdown start wait pubsub deliver');
yield utils.sleep(LOOP_TIMEOUT);
let documentsWithChanges = yield sqlBase.getDocumentsWithChanges(ctx);
const documentsWithChanges = yield sqlBase.getDocumentsWithChanges(ctx);
ctx.logger.debug('shutdown docs with changes count = %s', documentsWithChanges.length);
let docsWithEmptyForgotten = [];
let docsWithOutOfDateForgotten = [];
const docsWithEmptyForgotten = [];
const docsWithOutOfDateForgotten = [];
for (let i = 0; i < documentsWithChanges.length; ++i) {
let tenant = documentsWithChanges[i].tenant;
let docId = documentsWithChanges[i].id;
const tenant = documentsWithChanges[i].tenant;
const docId = documentsWithChanges[i].id;
ctx.setTenant(tenant);
let forgotten = yield storage.listObjects(ctx, docId, cfgForgottenFiles);
const forgotten = yield storage.listObjects(ctx, docId, cfgForgottenFiles);
if (forgotten.length > 0) {
let selectRes = yield taskResult.select(ctx, docId);
const selectRes = yield taskResult.select(ctx, docId);
if (selectRes.length > 0) {
let row = selectRes[0];
const row = selectRes[0];
if (commonDefines.FileStatus.SaveVersion !== row.status && commonDefines.FileStatus.UpdateVersion !== row.status){
docsWithOutOfDateForgotten.push([tenant, docId]);
}
@ -123,10 +123,10 @@ function shutdown() {
ctx.initDefault();
ctx.logger.debug('shutdown docs with changes and empty forgotten count = %s', docsWithEmptyForgotten.length);
ctx.logger.debug('shutdown docs with changes and out of date forgotten count = %s', docsWithOutOfDateForgotten.length);
let docsToConvert = docsWithEmptyForgotten.concat(docsWithOutOfDateForgotten);
const docsToConvert = docsWithEmptyForgotten.concat(docsWithOutOfDateForgotten);
for (let i = 0; i < docsToConvert.length; ++i) {
let tenant = docsToConvert[i][0];
let docId = docsToConvert[i][1];
const tenant = docsToConvert[i][0];
const docId = docsToConvert[i][1];
//todo refactor. group tenants?
ctx.setTenant(tenant);
yield ctx.initTenantCache();
@ -140,11 +140,11 @@ function shutdown() {
//sleep because of bugs in createSaveTimerPromise
yield utils.sleep(LOOP_TIMEOUT);
let startTime = new Date().getTime();
const startTime = new Date().getTime();
while (true) {
let remainingFiles = yield editorStat.getShutdownCount(redisKeyShutdown);
const remainingFiles = yield editorStat.getShutdownCount(redisKeyShutdown);
ctx.logger.debug('shutdown remaining files:%d', remainingFiles);
let curTime = new Date().getTime() - startTime;
const curTime = new Date().getTime() - startTime;
if (curTime >= EXEC_TIMEOUT || remainingFiles <= 0) {
if(curTime >= EXEC_TIMEOUT) {
ctx.logger.debug('shutdown timeout');
@ -155,10 +155,10 @@ function shutdown() {
}
let countInForgotten = 0;
for (let i = 0; i < docsToConvert.length; ++i) {
let tenant = docsToConvert[i][0];
let docId = docsToConvert[i][1];
const tenant = docsToConvert[i][0];
const docId = docsToConvert[i][1];
ctx.setTenant(tenant);
let forgotten = yield storage.listObjects(ctx, docId, cfgForgottenFiles);
const forgotten = yield storage.listObjects(ctx, docId, cfgForgottenFiles);
if (forgotten.length > 0) {
countInForgotten++;
} else {

134
DocService/sources/converterservice.js
View File

@ -61,14 +61,14 @@ function* getConvertStatus(ctx, docId, encryptedUserPassword, selectRes, opt_che
var status = new commonDefines.ConvertStatus(constants.NO_ERROR);
if (selectRes.length > 0) {
var row = selectRes[0];
let password = opt_checkPassword && sqlBase.DocumentPassword.prototype.getCurPassword(ctx, row.password);
const password = opt_checkPassword && sqlBase.DocumentPassword.prototype.getCurPassword(ctx, row.password);
switch (row.status) {
case commonDefines.FileStatus.Ok:
if (password) {
let isCorrectPassword;
if (encryptedUserPassword) {
let decryptedPassword = yield utils.decryptPassword(ctx, password);
let userPassword = yield utils.decryptPassword(ctx, encryptedUserPassword);
const decryptedPassword = yield utils.decryptPassword(ctx, password);
const userPassword = yield utils.decryptPassword(ctx, encryptedUserPassword);
isCorrectPassword = decryptedPassword === userPassword;
}
if (isCorrectPassword) {
@ -107,8 +107,8 @@ function* getConvertStatus(ctx, docId, encryptedUserPassword, selectRes, opt_che
}
function* getConvertPath(ctx, docId, fileTo, formatTo) {
if (constants.AVS_OFFICESTUDIO_FILE_OTHER_OOXML === formatTo || constants.AVS_OFFICESTUDIO_FILE_OTHER_ODF === formatTo) {
let list = yield storage.listObjects(ctx, docId);
let baseName = path.basename(fileTo, path.extname(fileTo));
const list = yield storage.listObjects(ctx, docId);
const baseName = path.basename(fileTo, path.extname(fileTo));
for (let i = 0; i < list.length; ++i) {
if (path.basename(list[i], path.extname(list[i])) === baseName) {
return list[i];
@ -133,7 +133,7 @@ function* convertByCmd(ctx, cmd, async, opt_fileTo, opt_taskExist, opt_priority,
let bCreate = false;
if (!opt_taskExist) {
let task = new taskResult.TaskResultData();
const task = new taskResult.TaskResultData();
task.tenant = ctx.tenant;
task.key = docId;
task.status = commonDefines.FileStatus.WaitQueue;
@ -222,18 +222,18 @@ async function convertFromChanges(ctx, docId, baseUrl, forceSave, externalChange
cmd.appendJsonParams(opt_jsonParams);
}
let commandSfctByCmdRes = await canvasService.commandSfctByCmd(ctx, cmd, opt_priority, opt_expiration, opt_queue, opt_initShardKey);
const commandSfctByCmdRes = await canvasService.commandSfctByCmd(ctx, cmd, opt_priority, opt_expiration, opt_queue, opt_initShardKey);
if (!commandSfctByCmdRes) {
return new commonDefines.ConvertStatus(constants.UNKNOWN);
}
var fileTo = constants.OUTPUT_NAME;
let outputExt = formatChecker.getStringFromFormat(cmd.getOutputFormat());
const outputExt = formatChecker.getStringFromFormat(cmd.getOutputFormat());
if (outputExt) {
fileTo += '.' + outputExt;
}
let status = await co(convertByCmd(ctx, cmd, true, fileTo, undefined, opt_priority, opt_expiration, opt_queue));
const status = await co(convertByCmd(ctx, cmd, true, fileTo, undefined, opt_priority, opt_expiration, opt_queue));
if (status.end) {
let fileToPath = await co(getConvertPath(ctx, docId, fileTo, cmd.getOutputFormat()));
const fileToPath = await co(getConvertPath(ctx, docId, fileTo, cmd.getOutputFormat()));
status.setExtName(path.extname(fileToPath));
status.setUrl(await co(getConvertUrl(ctx, baseUrl, fileToPath, cmd.getTitle())));
}
@ -245,13 +245,13 @@ function parseIntParam(val){
function convertRequest(req, res, isJson) {
return co(function* () {
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
ctx.initFromRequest(req);
yield ctx.initTenantCache();
ctx.logger.info('convertRequest start');
let params;
let authRes = yield docsCoServer.getRequestParams(ctx, req);
const authRes = yield docsCoServer.getRequestParams(ctx, req);
if(authRes.code === constants.NO_ERROR){
params = authRes.params;
} else {
@ -259,8 +259,8 @@ function convertRequest(req, res, isJson) {
utils.fillResponse(req, res, new commonDefines.ConvertStatus(authRes.code), isJson);
return;
}
let filetype = params.filetype || params.fileType || '';
let outputtype = params.outputtype || params.outputType || '';
const filetype = params.filetype || params.fileType || '';
const outputtype = params.outputtype || params.outputType || '';
ctx.setDocId(params.key);
if (params.key && !constants.DOC_ID_REGEX.test(params.key)) {
@ -294,7 +294,7 @@ function convertRequest(req, res, isJson) {
}
}
//todo use hash of params as id
let docId = 'conv_' + params.key + '_' + outputFormat;
const docId = 'conv_' + params.key + '_' + outputFormat;
var cmd = new commonDefines.InputCommand();
cmd.setCommand('conv');
cmd.setUrl(params.url);
@ -308,11 +308,11 @@ function convertRequest(req, res, isJson) {
cmd.setCodepage(commonDefines.c_oAscEncodingsMap[params.codePage] || commonDefines.c_oAscCodePageUtf8);
cmd.setDelimiter(parseIntParam(params.delimiter) || commonDefines.c_oAscCsvDelimiter.Comma);
if(undefined != params.delimiterChar)
cmd.setDelimiterChar(params.delimiterChar);
{cmd.setDelimiterChar(params.delimiterChar);}
if (params.region) {
cmd.setLCID(utilsDocService.localeToLCID(params.region));
}
let jsonParams = {};
const jsonParams = {};
if (params.documentLayout) {
jsonParams['documentLayout'] = params.documentLayout;
}
@ -331,7 +331,7 @@ function convertRequest(req, res, isJson) {
utils.fillResponse(req, res, new commonDefines.ConvertStatus(constants.CONVERT_PARAMS), isJson);
return;
}
let encryptedPassword = yield utils.encryptPassword(ctx, params.password);
const encryptedPassword = yield utils.encryptPassword(ctx, params.password);
cmd.setPassword(encryptedPassword);
}
if (authRes.isDecoded) {
@ -395,10 +395,10 @@ function convertRequest(req, res, isJson) {
async = false;
}
if (constants.AVS_OFFICESTUDIO_FILE_UNKNOWN !== cmd.getOutputFormat()) {
let fileTo = constants.OUTPUT_NAME + '.' + outputExt;
const fileTo = constants.OUTPUT_NAME + '.' + outputExt;
var status = yield* convertByCmd(ctx, cmd, async, fileTo, undefined, undefined, undefined, undefined, true);
if (status.end) {
let fileToPath = yield* getConvertPath(ctx, docId, fileTo, cmd.getOutputFormat());
const fileToPath = yield* getConvertPath(ctx, docId, fileTo, cmd.getOutputFormat());
status.setExtName(path.extname(fileToPath));
status.setUrl(yield* getConvertUrl(ctx, utils.getBaseUrlByRequest(ctx, req), fileToPath, cmd.getTitle()));
ctx.logger.debug('convertRequest: url = %s', status.url);
@ -426,28 +426,28 @@ function convertRequestXml(req, res) {
function builderRequest(req, res) {
return co(function* () {
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
ctx.initFromRequest(req);
yield ctx.initTenantCache();
ctx.logger.info('builderRequest start');
let authRes = yield docsCoServer.getRequestParams(ctx, req);
let params = authRes.params;
const authRes = yield docsCoServer.getRequestParams(ctx, req);
const params = authRes.params;
let docId = params.key;
ctx.setDocId(docId);
let error = authRes.code;
let urls;
let end = false;
let needCreateId = !docId;
let isInBody = req.body && Buffer.isBuffer(req.body) && req.body.length > 0;
const needCreateId = !docId;
const isInBody = req.body && Buffer.isBuffer(req.body) && req.body.length > 0;
if (error === constants.NO_ERROR && (params.key || params.url || isInBody)) {
if (needCreateId) {
let task = yield* taskResult.addRandomKeyTask(ctx, undefined, 'bld_', 8);
const task = yield* taskResult.addRandomKeyTask(ctx, undefined, 'bld_', 8);
docId = task.key;
ctx.setDocId(docId);
}
let cmd = new commonDefines.InputCommand();
const cmd = new commonDefines.InputCommand();
cmd.setCommand('builder');
cmd.setBuilderParams({argument: params.argument});
if (authRes.isDecoded) {
@ -461,7 +461,7 @@ function builderRequest(req, res) {
yield storageBase.putObject(ctx, docId + '/script.docbuilder', req.body, req.body.length);
}
if (needCreateId) {
let queueData = new commonDefines.TaskQueueData();
const queueData = new commonDefines.TaskQueueData();
queueData.setCtx(ctx);
queueData.setCmd(cmd);
yield* docsCoServer.addTask(queueData, constants.QUEUE_PRIORITY_LOW);
@ -471,7 +471,7 @@ function builderRequest(req, res) {
ctx.logger.warn('builderRequest set async=false. Pass query string parameter "%s" to correctly process request in sharded cluster', constants.SHARD_KEY_API_NAME);
async = false;
}
let status = yield* convertByCmd(ctx, cmd, async, undefined, undefined, constants.QUEUE_PRIORITY_LOW);
const status = yield* convertByCmd(ctx, cmd, async, undefined, undefined, constants.QUEUE_PRIORITY_LOW);
end = status.end;
error = status.err;
if (end) {
@ -494,7 +494,7 @@ function builderRequest(req, res) {
}
function convertTo(req, res) {
return co(function*() {
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
ctx.initFromRequest(req);
yield ctx.initTenantCache();
@ -504,7 +504,7 @@ function convertTo(req, res) {
format = req.params.format;
}
//todo https://github.com/LibreOffice/core/blob/9d3366f5b392418dc83bc0adbe3d215cff4b3605/desktop/source/lib/init.cxx#L3478
let password = req.body['Password'];
const password = req.body['Password'];
if (password) {
if (password.length > constants.PASSWORD_MAX_LENGTH) {
ctx.logger.warn('convert-to Password too long actual = %s; max = %s', password.length, constants.PASSWORD_MAX_LENGTH);
@ -513,7 +513,7 @@ function convertTo(req, res) {
}
}
//by analogy with Password
let passwordToOpen = req.body['PasswordToOpen'];
const passwordToOpen = req.body['PasswordToOpen'];
if (passwordToOpen) {
if (passwordToOpen.length > constants.PASSWORD_MAX_LENGTH) {
ctx.logger.warn('convert-to PasswordToOpen too long actual = %s; max = %s', passwordToOpen.length, constants.PASSWORD_MAX_LENGTH);
@ -521,13 +521,13 @@ function convertTo(req, res) {
return;
}
}
let pdfVer = req.body['PDFVer'];
const pdfVer = req.body['PDFVer'];
if (pdfVer && pdfVer.startsWith("PDF/A") && 'pdf' === format) {
format = 'pdfa';
}
let fullSheetPreview = req.body['FullSheetPreview'];
let lang = req.body['lang'];
let outputFormat = formatChecker.getFormatFromString(format);
const fullSheetPreview = req.body['FullSheetPreview'];
const lang = req.body['lang'];
const outputFormat = formatChecker.getFormatFromString(format);
if (constants.AVS_OFFICESTUDIO_FILE_UNKNOWN === outputFormat) {
ctx.logger.warn('convert-to unexpected format = %s', format);
res.sendStatus(400);
@ -537,22 +537,22 @@ function convertTo(req, res) {
if (req.files?.length > 0 && req.files[0].originalname && req.files[0].buffer) {
const file = req.files[0];
originalname = file.originalname;
let filetype = path.extname(file.originalname).substring(1);
const filetype = path.extname(file.originalname).substring(1);
if (filetype && !constants.EXTENTION_REGEX.test(filetype)) {
ctx.logger.warn('convertRequest unexpected filetype = %s', filetype);
res.sendStatus(400);
return;
}
let task = yield* taskResult.addRandomKeyTask(ctx, undefined, 'conv_', 8);
const task = yield* taskResult.addRandomKeyTask(ctx, undefined, 'conv_', 8);
docId = task.key;
ctx.setDocId(docId);
//todo stream
let buffer = file.buffer;
const buffer = file.buffer;
yield storageBase.putObject(ctx, docId + '/origin.' + filetype, buffer, buffer.length);
let cmd = new commonDefines.InputCommand();
const cmd = new commonDefines.InputCommand();
cmd.setCommand('conv');
cmd.setDocId(docId);
cmd.setFormat(filetype);
@ -577,33 +577,33 @@ function convertTo(req, res) {
}});
}
if (password) {
let encryptedPassword = yield utils.encryptPassword(ctx, password);
const encryptedPassword = yield utils.encryptPassword(ctx, password);
cmd.setSavePassword(encryptedPassword);
}
if (passwordToOpen) {
let encryptedPassword = yield utils.encryptPassword(ctx, passwordToOpen);
const encryptedPassword = yield utils.encryptPassword(ctx, passwordToOpen);
cmd.setPassword(encryptedPassword);
}
fileTo = constants.OUTPUT_NAME;
let outputExt = formatChecker.getStringFromFormat(outputFormat);
const outputExt = formatChecker.getStringFromFormat(outputFormat);
if (outputExt) {
fileTo += '.' + outputExt;
}
let queueData = new commonDefines.TaskQueueData();
const queueData = new commonDefines.TaskQueueData();
queueData.setCtx(ctx);
queueData.setCmd(cmd);
queueData.setToFile(fileTo);
queueData.setFromOrigin(true);
yield* docsCoServer.addTask(queueData, constants.QUEUE_PRIORITY_LOW);
let async = false;
const async = false;
status = yield* convertByCmd(ctx, cmd, async, fileTo);
}
if (status && status.end && constants.NO_ERROR === status.err) {
let filename = path.basename(originalname, path.extname(originalname)) + path.extname(fileTo);
let streamObj = yield storage.createReadStream(ctx, `${docId}/${fileTo}`);
const filename = path.basename(originalname, path.extname(originalname)) + path.extname(fileTo);
const streamObj = yield storage.createReadStream(ctx, `${docId}/${fileTo}`);
res.setHeader('Content-Disposition', utils.getContentDisposition(filename, null, constants.CONTENT_DISPOSITION_INLINE));
res.setHeader('Content-Length', streamObj.contentLength);
res.setHeader('Content-Type', mime.getType(filename));
@ -625,15 +625,15 @@ function convertAndEdit(ctx, wopiParams, filetypeFrom, filetypeTo) {
try {
ctx.logger.info('convert-and-edit start');
let task = yield* taskResult.addRandomKeyTask(ctx, undefined, 'conv_', 8);
let docId = task.key;
let outputFormat = formatChecker.getFormatFromString(filetypeTo);
const task = yield* taskResult.addRandomKeyTask(ctx, undefined, 'conv_', 8);
const docId = task.key;
const outputFormat = formatChecker.getFormatFromString(filetypeTo);
if (constants.AVS_OFFICESTUDIO_FILE_UNKNOWN === outputFormat) {
ctx.logger.debug('convert-and-edit unknown outputFormat %s', filetypeTo);
return;
}
let cmd = new commonDefines.InputCommand();
const cmd = new commonDefines.InputCommand();
cmd.setCommand('conv');
cmd.setDocId(docId);
cmd.setUrl('dummy-url');
@ -642,18 +642,18 @@ function convertAndEdit(ctx, wopiParams, filetypeFrom, filetypeTo) {
cmd.setOutputFormat(outputFormat);
let fileTo = constants.OUTPUT_NAME;
let outputExt = formatChecker.getStringFromFormat(outputFormat);
const outputExt = formatChecker.getStringFromFormat(outputFormat);
if (outputExt) {
fileTo += '.' + outputExt;
}
let queueData = new commonDefines.TaskQueueData();
const queueData = new commonDefines.TaskQueueData();
queueData.setCtx(ctx);
queueData.setCmd(cmd);
queueData.setToFile(fileTo);
yield* docsCoServer.addTask(queueData, constants.QUEUE_PRIORITY_LOW);
let async = true;
const async = true;
yield* convertByCmd(ctx, cmd, async, fileTo);
return docId;
} catch (err) {
@ -665,17 +665,17 @@ function convertAndEdit(ctx, wopiParams, filetypeFrom, filetypeTo) {
}
function getConverterHtmlHandler(req, res) {
return co(function*() {
let isJson = true;
let ctx = new operationContext.Context();
const isJson = true;
const ctx = new operationContext.Context();
try {
ctx.initFromRequest(req);
yield ctx.initTenantCache();
ctx.logger.info('convert-and-edit-handler start');
const tenTokenEnableBrowser = ctx.getCfg('services.CoAuthoring.token.enable.browser', cfgTokenEnableBrowser);
let wopiSrc = req.query['wopisrc'];
let access_token = req.query['access_token'];
let targetext = req.query['targetext'];
const wopiSrc = req.query['wopisrc'];
const access_token = req.query['access_token'];
const targetext = req.query['targetext'];
let docId = req.query['docid'];
ctx.setDocId(docId);
if (!(wopiSrc && access_token && access_token && targetext && docId) ||
@ -684,9 +684,9 @@ function getConverterHtmlHandler(req, res) {
utils.fillResponse(req, res, new commonDefines.ConvertStatus(constants.CONVERT_PARAMS), isJson);
return;
}
let token = req.query['token'];
const token = req.query['token'];
if (tenTokenEnableBrowser) {
let checkJwtRes = yield docsCoServer.checkJwt(ctx, token, commonDefines.c_oAscSecretType.Browser);
const checkJwtRes = yield docsCoServer.checkJwt(ctx, token, commonDefines.c_oAscSecretType.Browser);
if (checkJwtRes.decoded) {
docId = checkJwtRes.decoded.docId;
} else {
@ -697,14 +697,14 @@ function getConverterHtmlHandler(req, res) {
}
ctx.setDocId(docId);
let selectRes = yield taskResult.select(ctx, docId);
let status = yield* getConvertStatus(ctx, docId, undefined, selectRes);
const selectRes = yield taskResult.select(ctx, docId);
const status = yield* getConvertStatus(ctx, docId, undefined, selectRes);
if (status.end && constants.NO_ERROR === status.err) {
let fileTo = `${docId}/${constants.OUTPUT_NAME}.${targetext}`;
const fileTo = `${docId}/${constants.OUTPUT_NAME}.${targetext}`;
let metadata = yield storage.headObject(ctx, fileTo);
let streamObj = yield storage.createReadStream(ctx, fileTo);
let putRelativeRes = yield wopiClient.putRelativeFile(ctx, wopiSrc, access_token, null, streamObj.readStream, metadata.ContentLength, `.${targetext}`, undefined, true);
const metadata = yield storage.headObject(ctx, fileTo);
const streamObj = yield storage.createReadStream(ctx, fileTo);
const putRelativeRes = yield wopiClient.putRelativeFile(ctx, wopiSrc, access_token, null, streamObj.readStream, metadata.ContentLength, `.${targetext}`, undefined, true);
if (putRelativeRes) {
status.setUrl(putRelativeRes.HostEditUrl);
status.setExtName('.' + targetext);

24
DocService/sources/database.js
View File

@ -48,10 +48,10 @@ exports.insert = function (_collectionName, _newElement) {
return;
}
_db.open (function (err, db) {
_db.open ((err, db) => {
if (!err) {
// open collection. If it doesn't exist, it will be created
db.collection(_collectionName, function(err, collection) {
db.collection(_collectionName, (err, collection) => {
if (!err) {
collection.insert (_newElement);
} else {
@ -74,12 +74,12 @@ exports.remove = function (_collectionName, _removeElements) {
}
// Opening the database
_db.open (function (err, db) {
_db.open ((err, db) => {
if (!err) {
// open collection. If it doesn't exist, it will be created
db.collection(_collectionName, function(err, collection) {
db.collection(_collectionName, (err, collection) => {
if (!err) {
collection.remove (_removeElements, function(err, collection) {
collection.remove (_removeElements, (err, collection) => {
logger.info ("All elements remove");
});
} else {
@ -104,20 +104,20 @@ exports.load = function (_collectionName, callbackFunction) {
var result = [];
// opening database
_db.open (function (err, db) {
_db.open ((err, db) => {
// open collection. If it doesn't exist, it will be created
db.collection(_collectionName, function(err, collection) {
db.collection(_collectionName, (err, collection) => {
// Get all elements of a collection with find()
collection.find(function(err, cursor) {
cursor.each(function(err, item) {
collection.find((err, cursor) => {
cursor.each((err, item) => {
// Null denotes the last element
if (item != null) {
if (!result.hasOwnProperty (item.docid))
result[item.docid] = [item];
{result[item.docid] = [item];}
else
result[item.docid].push(item);
{result[item.docid].push(item);}
} else
callbackFunction (result);
{callbackFunction (result);}
});
db.close();

98
DocService/sources/databaseConnectors/baseConnector.js
View File

@ -85,8 +85,8 @@ function getChangesSize(changes) {
}
function insertChangesPromiseCompatibility(ctx, objChanges, docId, index, user) {
return new Promise(function(resolve, reject) {
_insertChangesCallback(ctx, 0, objChanges, docId, index, user, function(error, result) {
return new Promise((resolve, reject) => {
_insertChangesCallback(ctx, 0, objChanges, docId, index, user, (error, result) => {
if (error) {
reject(error);
} else {
@ -97,8 +97,8 @@ function insertChangesPromiseCompatibility(ctx, objChanges, docId, index, user)
}
function insertChangesPromiseFast(ctx, objChanges, docId, index, user) {
return new Promise(function(resolve, reject) {
dbInstance.insertChanges(ctx, cfgTableChanges, 0, objChanges, docId, index, user, function(error, result, isSupported) {
return new Promise((resolve, reject) => {
dbInstance.insertChanges(ctx, cfgTableChanges, 0, objChanges, docId, index, user, (error, result, isSupported) => {
isSupportFastInsert = isSupported;
if (error) {
if (!isSupportFastInsert) {
@ -129,7 +129,7 @@ function _insertChangesCallback(ctx, startIndex, objChanges, docId, index, user,
var sqlCommand = `INSERT INTO ${cfgTableChanges} VALUES`;
var i = startIndex, l = objChanges.length, lengthUtf8Current = sqlCommand.length, lengthUtf8Row = 0, values = [];
if (i === l)
return;
{return;}
const indexBytes = 4;
const timeBytes = 8;
@ -140,21 +140,21 @@ function _insertChangesCallback(ctx, startIndex, objChanges, docId, index, user,
if (lengthUtf8Row + lengthUtf8Current >= maxPacketSize && i > startIndex) {
sqlCommand += ';';
(function(tmpStart, tmpIndex) {
dbInstance.sqlQuery(ctx, sqlCommand, function() {
dbInstance.sqlQuery(ctx, sqlCommand, () => {
// do not remove lock, but we continue to add
_insertChangesCallback(ctx, tmpStart, objChanges, docId, tmpIndex, user, callback);
}, undefined, undefined, values);
})(i, index);
return;
}
let p0 = addSqlParameter(ctx.tenant, values);
let p1 = addSqlParameter(docId, values);
let p2 = addSqlParameter(index, values);
let p3 = addSqlParameter(user.id, values);
let p4 = addSqlParameter(user.idOriginal, values);
let p5 = addSqlParameter(user.username, values);
let p6 = addSqlParameter(objChanges[i].change, values);
let p7 = addSqlParameter(objChanges[i].time, values);
const p0 = addSqlParameter(ctx.tenant, values);
const p1 = addSqlParameter(docId, values);
const p2 = addSqlParameter(index, values);
const p3 = addSqlParameter(user.id, values);
const p4 = addSqlParameter(user.idOriginal, values);
const p5 = addSqlParameter(user.username, values);
const p6 = addSqlParameter(objChanges[i].change, values);
const p7 = addSqlParameter(objChanges[i].time, values);
if (i > startIndex) {
sqlCommand += ',';
}
@ -168,10 +168,10 @@ function _insertChangesCallback(ctx, startIndex, objChanges, docId, index, user,
function deleteChangesCallback(ctx, docId, deleteIndex, callback) {
let sqlCommand, values = [];
let p1 = addSqlParameter(ctx.tenant, values);
let p2 = addSqlParameter(docId, values);
const p1 = addSqlParameter(ctx.tenant, values);
const p2 = addSqlParameter(docId, values);
if (null !== deleteIndex) {
let sqlParam2 = addSqlParameter(deleteIndex, values);
const sqlParam2 = addSqlParameter(deleteIndex, values);
sqlCommand = `DELETE FROM ${cfgTableChanges} WHERE tenant=${p1} AND id=${p2} AND change_id >= ${sqlParam2};`;
} else {
sqlCommand = `DELETE FROM ${cfgTableChanges} WHERE tenant=${p1} AND id=${p2};`;
@ -180,8 +180,8 @@ function deleteChangesCallback(ctx, docId, deleteIndex, callback) {
}
function deleteChangesPromise(ctx, docId, deleteIndex) {
return new Promise(function(resolve, reject) {
deleteChangesCallback(ctx, docId, deleteIndex, function(error, result) {
return new Promise((resolve, reject) => {
deleteChangesCallback(ctx, docId, deleteIndex, (error, result) => {
if (error) {
reject(error);
} else {
@ -192,24 +192,24 @@ function deleteChangesPromise(ctx, docId, deleteIndex) {
}
function deleteChanges(ctx, docId, deleteIndex) {
lockCriticalSection(docId, function () {_deleteChanges(ctx, docId, deleteIndex);});
lockCriticalSection(docId, () => {_deleteChanges(ctx, docId, deleteIndex);});
}
function _deleteChanges (ctx, docId, deleteIndex) {
deleteChangesCallback(ctx, docId, deleteIndex, function () {unLockCriticalSection(docId);});
deleteChangesCallback(ctx, docId, deleteIndex, () => {unLockCriticalSection(docId);});
}
function getChangesIndex(ctx, docId, callback) {
let values = [];
let p1 = addSqlParameter(ctx.tenant, values);
let p2 = addSqlParameter(docId, values);
const values = [];
const p1 = addSqlParameter(ctx.tenant, values);
const p2 = addSqlParameter(docId, values);
var sqlCommand = `SELECT MAX(change_id) as change_id FROM ${cfgTableChanges} WHERE tenant=${p1} AND id=${p2};`;
dbInstance.sqlQuery(ctx, sqlCommand, callback, undefined, undefined, values);
}
function getChangesIndexPromise(ctx, docId) {
return new Promise(function(resolve, reject) {
getChangesIndex(ctx, docId, function(error, result) {
return new Promise((resolve, reject) => {
getChangesIndex(ctx, docId, (error, result) => {
if (error) {
reject(error);
} else {
@ -220,10 +220,10 @@ function getChangesIndexPromise(ctx, docId) {
}
function getChangesPromise(ctx, docId, optStartIndex, optEndIndex, opt_time) {
let limiter = group.key(`${ctx.tenant}\t${docId}\tchanges`);
const limiter = group.key(`${ctx.tenant}\t${docId}\tchanges`);
return limiter.schedule(() => {
return new Promise(function(resolve, reject) {
let values = [];
return new Promise((resolve, reject) => {
const values = [];
let sqlParam = addSqlParameter(ctx.tenant, values);
let sqlWhere = `tenant=${sqlParam}`;
sqlParam = addSqlParameter(docId, values);
@ -246,13 +246,13 @@ function getChangesPromise(ctx, docId, optStartIndex, optEndIndex, opt_time) {
sqlWhere += ' ORDER BY change_id ASC';
var sqlCommand = `SELECT * FROM ${cfgTableChanges} WHERE ${sqlWhere};`;
dbInstance.sqlQuery(ctx, sqlCommand, function(error, result) {
dbInstance.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {
if (reservoirMaximum > 0) {
let size = Math.min(getChangesSize(result), reservoirMaximum);
let cur = limiter.incrementReservoir(-size).then((cur) => {
const size = Math.min(getChangesSize(result), reservoirMaximum);
const cur = limiter.incrementReservoir(-size).then((cur) => {
ctx.logger.debug("getChangesPromise bottleneck reservoir cur=%s", cur);
resolve(result);
});
@ -266,9 +266,9 @@ function getChangesPromise(ctx, docId, optStartIndex, optEndIndex, opt_time) {
}
function getDocumentsWithChanges(ctx) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
const sqlCommand = `SELECT * FROM ${cfgTableResult} WHERE EXISTS(SELECT id FROM ${cfgTableChanges} WHERE tenant=${cfgTableResult}.tenant AND id = ${cfgTableResult}.id LIMIT 1);`;
dbInstance.sqlQuery(ctx, sqlCommand, function(error, result) {
dbInstance.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {
@ -280,7 +280,7 @@ function getDocumentsWithChanges(ctx) {
function getExpired(ctx, maxCount, expireSeconds) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
const values = [];
const expireDate = new Date();
utils.addSeconds(expireDate, -expireSeconds);
@ -288,7 +288,7 @@ function getExpired(ctx, maxCount, expireSeconds) {
const count = addSqlParameter(maxCount, values);
const sqlCommand = `SELECT * FROM ${cfgTableResult} WHERE last_open_date <= ${date}` +
` AND NOT EXISTS(SELECT tenant, id FROM ${cfgTableChanges} WHERE ${cfgTableChanges}.tenant = ${cfgTableResult}.tenant AND ${cfgTableChanges}.id = ${cfgTableResult}.id LIMIT 1) LIMIT ${count};`;
dbInstance.sqlQuery(ctx, sqlCommand, function(error, result) {
dbInstance.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {
@ -298,17 +298,17 @@ function getExpired(ctx, maxCount, expireSeconds) {
});
}
function getCountWithStatus(ctx, status, expireMs) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
const values = [];
const expireDate = new Date(Date.now() - expireMs);
const sqlStatus = addSqlParameter(status, values);
const sqlDate = addSqlParameter(expireDate, values);
const sqlCommand = `SELECT COUNT(id) AS count FROM ${cfgTableResult} WHERE status=${sqlStatus} AND last_open_date>${sqlDate};`;
dbInstance.sqlQuery(ctx, sqlCommand, function(error, result) {
dbInstance.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {
let res = Number(result[0].count)
const res = Number(result[0].count)
resolve(!isNaN(res) ? res : 0);
}
}, false, false, values);
@ -336,16 +336,16 @@ function unLockCriticalSection(id) {
var arrCallbacks = g_oCriticalSection[id];
arrCallbacks.shift();
if (0 < arrCallbacks.length)
arrCallbacks[0]();
{arrCallbacks[0]();}
else
delete g_oCriticalSection[id];
{delete g_oCriticalSection[id];}
}
function healthCheck(ctx) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
//SELECT 1; usefull for H2, MySQL, Microsoft SQL Server, PostgreSQL, SQLite
//http://stackoverflow.com/questions/3668506/efficient-sql-test-query-or-validation-query-that-will-work-across-all-or-most
dbInstance.sqlQuery(ctx, 'SELECT 1;', function(error, result) {
dbInstance.sqlQuery(ctx, 'SELECT 1;', (error, result) => {
if (error) {
reject(error);
} else {
@ -356,9 +356,9 @@ function healthCheck(ctx) {
}
function getEmptyCallbacks(ctx) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
const sqlCommand = `SELECT DISTINCT t1.tenant, t1.id FROM ${cfgTableChanges} t1 LEFT JOIN ${cfgTableResult} t2 ON t2.tenant = t1.tenant AND t2.id = t1.id WHERE t2.callback = '';`;
dbInstance.sqlQuery(ctx, sqlCommand, function(error, result) {
dbInstance.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {
@ -369,11 +369,11 @@ function getEmptyCallbacks(ctx) {
}
function getTableColumns(ctx, tableName) {
return new Promise(function(resolve, reject) {
let values = [];
let sqlParam = addSqlParameter(tableName, values);
return new Promise((resolve, reject) => {
const values = [];
const sqlParam = addSqlParameter(tableName, values);
const sqlCommand = `SELECT column_name as "column_name" FROM information_schema.COLUMNS WHERE TABLE_NAME = ${sqlParam};`;
dbInstance.sqlQuery(ctx, sqlCommand, function(error, result) {
dbInstance.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {

42
DocService/sources/databaseConnectors/connectorUtilities.js
View File

@ -51,7 +51,7 @@ UserCallback.prototype.toSQLInsert = function(){
UserCallback.prototype.getCallbackByUserIndex = function(ctx, callbacksStr, opt_userIndex) {
ctx.logger.debug("getCallbackByUserIndex: userIndex = %s callbacks = %s", opt_userIndex, callbacksStr);
if (!callbacksStr || !callbacksStr.startsWith(UserCallback.prototype.delimiter)) {
let index = callbacksStr.indexOf(UserCallback.prototype.delimiter);
const index = callbacksStr.indexOf(UserCallback.prototype.delimiter);
if (-1 === index) {
//old format
return callbacksStr;
@ -60,10 +60,10 @@ UserCallback.prototype.getCallbackByUserIndex = function(ctx, callbacksStr, opt_
callbacksStr = callbacksStr.substring(index);
}
}
let callbacks = callbacksStr.split(UserCallback.prototype.delimiter);
const callbacks = callbacksStr.split(UserCallback.prototype.delimiter);
let callbackUrl = "";
for (let i = 1; i < callbacks.length; ++i) {
let callback = JSON.parse(callbacks[i]);
const callback = JSON.parse(callbacks[i]);
callbackUrl = callback.callback;
if (callback.userIndex === opt_userIndex) {
break;
@ -74,7 +74,7 @@ UserCallback.prototype.getCallbackByUserIndex = function(ctx, callbacksStr, opt_
UserCallback.prototype.getCallbacks = function(ctx, callbacksStr) {
ctx.logger.debug("getCallbacks: callbacks = %s", callbacksStr);
if (!callbacksStr || !callbacksStr.startsWith(UserCallback.prototype.delimiter)) {
let index = callbacksStr.indexOf(UserCallback.prototype.delimiter);
const index = callbacksStr.indexOf(UserCallback.prototype.delimiter);
if (-1 === index) {
//old format
return [callbacksStr];
@ -83,10 +83,10 @@ UserCallback.prototype.getCallbacks = function(ctx, callbacksStr) {
callbacksStr = callbacksStr.substring(index);
}
}
let callbacks = callbacksStr.split(UserCallback.prototype.delimiter);
let res = [];
const callbacks = callbacksStr.split(UserCallback.prototype.delimiter);
const res = [];
for (let i = 1; i < callbacks.length; ++i) {
let callback = JSON.parse(callbacks[i]);
const callback = JSON.parse(callbacks[i]);
res.push(callback.callback);
}
return res;
@ -116,13 +116,13 @@ DocumentPassword.prototype.isInitial = function(){
return !this.change;
};
DocumentPassword.prototype.getDocPassword = function(ctx, docPasswordStr) {
let res = {initial: undefined, current: undefined, change: undefined};
const res = {initial: undefined, current: undefined, change: undefined};
if (docPasswordStr) {
ctx.logger.debug("getDocPassword: passwords = %s", docPasswordStr);
let passwords = docPasswordStr.split(UserCallback.prototype.delimiter);
const passwords = docPasswordStr.split(UserCallback.prototype.delimiter);
for (let i = 1; i < passwords.length; ++i) {
let password = new DocumentPassword();
const password = new DocumentPassword();
password.fromString(passwords[i]);
if (password.isInitial()) {
res.initial = password.password;
@ -135,11 +135,11 @@ DocumentPassword.prototype.getDocPassword = function(ctx, docPasswordStr) {
return res;
};
DocumentPassword.prototype.getCurPassword = function(ctx, docPasswordStr) {
let docPassword = this.getDocPassword(ctx, docPasswordStr);
const docPassword = this.getDocPassword(ctx, docPasswordStr);
return docPassword.current;
};
DocumentPassword.prototype.hasPasswordChanges = function(ctx, docPasswordStr) {
let docPassword = this.getDocPassword(ctx, docPasswordStr);
const docPassword = this.getDocPassword(ctx, docPasswordStr);
return docPassword.initial !== docPassword.current;
};
@ -149,7 +149,7 @@ function DocumentAdditional() {
DocumentAdditional.prototype.delimiter = constants.CHAR_DELIMITER;
DocumentAdditional.prototype.toSQLInsert = function() {
if (this.data.length) {
let vals = this.data.map((currentValue) => {
const vals = this.data.map((currentValue) => {
return JSON.stringify(currentValue);
});
return this.delimiter + vals.join(this.delimiter);
@ -161,19 +161,19 @@ DocumentAdditional.prototype.fromString = function(str) {
if (!str) {
return;
}
let vals = str.split(this.delimiter).slice(1);
const vals = str.split(this.delimiter).slice(1);
this.data = vals.map((currentValue) => {
return JSON.parse(currentValue);
});
};
DocumentAdditional.prototype.setOpenedAt = function(time, timezoneOffset, headingsColor) {
let additional = new DocumentAdditional();
const additional = new DocumentAdditional();
additional.data.push({time, timezoneOffset, headingsColor});
return additional.toSQLInsert();
};
DocumentAdditional.prototype.getOpenedAt = function(str) {
let res;
let val = new DocumentAdditional();
const val = new DocumentAdditional();
val.fromString(str);
val.data.forEach((elem) => {
if (undefined !== elem.timezoneOffset) {
@ -184,7 +184,7 @@ DocumentAdditional.prototype.getOpenedAt = function(str) {
};
DocumentAdditional.prototype.getDocumentLayout = function(str) {
let res;
let val = new DocumentAdditional();
const val = new DocumentAdditional();
val.fromString(str);
val.data.forEach((elem) => {
if (undefined !== elem.timezoneOffset) {
@ -195,13 +195,13 @@ DocumentAdditional.prototype.getDocumentLayout = function(str) {
}
DocumentAdditional.prototype.setShardKey = function(shardKey) {
let additional = new DocumentAdditional();
const additional = new DocumentAdditional();
additional.data.push({shardKey});
return additional.toSQLInsert();
};
DocumentAdditional.prototype.getShardKey = function(str) {
let res;
let val = new DocumentAdditional();
const val = new DocumentAdditional();
val.fromString(str);
val.data.forEach((elem) => {
if (elem.shardKey) {
@ -212,13 +212,13 @@ DocumentAdditional.prototype.getShardKey = function(str) {
};
DocumentAdditional.prototype.setWopiSrc = function(wopiSrc) {
let additional = new DocumentAdditional();
const additional = new DocumentAdditional();
additional.data.push({wopiSrc});
return additional.toSQLInsert();
};
DocumentAdditional.prototype.getWopiSrc = function(str) {
let res;
let val = new DocumentAdditional();
const val = new DocumentAdditional();
val.fromString(str);
val.data.forEach((elem) => {
if (elem.wopiSrc) {

26
DocService/sources/databaseConnectors/damengConnector.js
View File

@ -60,20 +60,20 @@ const poolConfig = {
};
function readLob(lob) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
let blobData = Buffer.alloc(0);
let totalLength = 0;
lob.on('data', function(chunk) {
lob.on('data', (chunk) => {
totalLength += chunk.length;
blobData = Buffer.concat([blobData, chunk], totalLength);
});
lob.on('error', function(err) {
lob.on('error', (err) => {
reject(err);
});
lob.on('end', function() {
lob.on('end', () => {
resolve(blobData);
});
});
@ -86,7 +86,7 @@ async function formatResult(result) {
const row = result.rows[i];
const out = {};
for (let j = 0; j < result.metaData.length; ++j) {
let columnName = result.metaData[j].name;
const columnName = result.metaData[j].name;
if (row[j]?.on) {
const buf = await readLob(row[j]);
out[columnName] = buf.toString('utf8');
@ -147,7 +147,7 @@ function closePool() {
}
function addSqlParameter(val, values) {
values.push({ val: val });
values.push({ val });
return `:${values.length}`;
}
@ -156,20 +156,20 @@ function concatParams(val1, val2) {
}
async function getTableColumns(ctx, tableName) {
let values = [];
let sqlParam = addSqlParameter(tableName.toUpperCase(), values);
const values = [];
const sqlParam = addSqlParameter(tableName.toUpperCase(), values);
const result = await executeQuery(ctx, `SELECT column_name FROM DBA_TAB_COLUMNS WHERE table_name = ${sqlParam};`, values);
return result.map(row => { return { column_name: row.column_name.toLowerCase() }});
}
async function upsert(ctx, task) {
task.completeDefaults();
let dateNow = new Date();
let values = [];
const dateNow = new Date();
const values = [];
let cbInsert = task.callback;
if (task.callback) {
let userCallback = new connectorUtilities.UserCallback();
const userCallback = new connectorUtilities.UserCallback();
userCallback.fromValues(task.userIndex, task.callback);
cbInsert = userCallback.toSQLInsert();
}
@ -191,12 +191,12 @@ async function upsert(ctx, task) {
sqlCommand += `WHEN MATCHED THEN UPDATE SET last_open_date = ${p9}`;
if (task.callback) {
let p10 = addSqlParameter(JSON.stringify(task.callback), values);
const p10 = addSqlParameter(JSON.stringify(task.callback), values);
sqlCommand += `, callback = CONCAT(callback , '${connectorUtilities.UserCallback.prototype.delimiter}{"userIndex":' , (user_index + 1) , ',"callback":', ${p10}, '}')`;
}
if (task.baseurl) {
let p11 = addSqlParameter(task.baseurl, values);
const p11 = addSqlParameter(task.baseurl, values);
sqlCommand += `, baseurl = ${p11}`;
}

6
DocService/sources/databaseConnectors/mssqlConnector.js
View File

@ -199,8 +199,8 @@ function concatParams(...parameters) {
}
function getTableColumns(ctx, tableName) {
let values = [];
let sqlParam = addSqlParameter(tableName, values);
const values = [];
const sqlParam = addSqlParameter(tableName, values);
const sqlCommand = `SELECT column_name FROM information_schema.COLUMNS WHERE TABLE_NAME = ${sqlParam} AND TABLE_SCHEMA = 'dbo';`;
return executeQuery(ctx, sqlCommand, values);
}
@ -277,7 +277,7 @@ async function upsert(ctx, task) {
updateColumns += ', target.user_index = target.user_index + 1';
let sqlMerge = `MERGE INTO ${cfgTableResult} AS target `
const sqlMerge = `MERGE INTO ${cfgTableResult} AS target `
+ `USING(VALUES(${insertValues})) AS source(${sourceColumns}) `
+ `ON(${condition}) `
+ `WHEN MATCHED THEN UPDATE SET ${updateColumns} `

4
DocService/sources/databaseConnectors/mysqlConnector.js
View File

@ -158,12 +158,12 @@ async function upsert(ctx, task) {
let updateStatement = `last_open_date = ${addSqlParameter(dateNow, values)}`;
if (task.callback) {
let callbackPlaceholder = addSqlParameter(JSON.stringify(task.callback), values);
const callbackPlaceholder = addSqlParameter(JSON.stringify(task.callback), values);
updateStatement += `, callback = CONCAT(callback , '${connectorUtilities.UserCallback.prototype.delimiter}{"userIndex":' , (user_index + 1) , ',"callback":', ${callbackPlaceholder}, '}')`;
}
if (task.baseurl) {
let baseUrlPlaceholder = addSqlParameter(task.baseurl, values);
const baseUrlPlaceholder = addSqlParameter(task.baseurl, values);
updateStatement += `, baseurl = ${baseUrlPlaceholder}`;
}

6
DocService/sources/databaseConnectors/oracleConnector.js
View File

@ -171,8 +171,8 @@ function concatParams(firstParameter, secondParameter) {
}
function getTableColumns(ctx, tableName) {
let values = [];
let sqlParam = addSqlParameter(tableName.toUpperCase(), values);
const values = [];
const sqlParam = addSqlParameter(tableName.toUpperCase(), values);
return executeQuery(ctx, `SELECT LOWER(column_name) AS column_name FROM user_tab_columns WHERE table_name = ${sqlParam}`, values);
}
@ -259,7 +259,7 @@ async function upsert(ctx, task) {
];
const returned = addSqlParameter({ type: oracledb.NUMBER, dir: oracledb.BIND_OUT }, insertValues);
let sqlInsertTry = `INSERT INTO ${cfgTableResult} (tenant, id, status, status_info, last_open_date, user_index, change_id, callback, baseurl) `
const sqlInsertTry = `INSERT INTO ${cfgTableResult} (tenant, id, status, status_info, last_open_date, user_index, change_id, callback, baseurl) `
+ `VALUES(${insertValuesPlaceholder.join(', ')}) RETURNING user_index INTO ${returned}`;
try {

64
DocService/sources/databaseConnectors/postgreConnector.js
View File

@ -43,7 +43,7 @@ const cfgTableResult = config.get('services.CoAuthoring.sql.tableResult');
var pgPoolExtraOptions = config.util.cloneDeep(configSql.get('pgPoolExtraOptions'));
const cfgEditor = config.get('services.CoAuthoring.editor');
let connectionConfig = {
const connectionConfig = {
host: configSql.get('dbHost'),
port: parseInt(configSql.get('dbPort')),
user: configSql.get('dbUser'),
@ -63,10 +63,10 @@ pool.on('error', (err, client) => {
})
//todo datetime timezone
pg.defaults.parseInputDatesAsUTC = true;
types.setTypeParser(1114, function(stringValue) {
types.setTypeParser(1114, (stringValue) => {
return new Date(stringValue + '+0000');
});
types.setTypeParser(1184, function(stringValue) {
types.setTypeParser(1184, (stringValue) => {
return new Date(stringValue + '+0000');
});
@ -116,35 +116,35 @@ var isSupportOnConflict = true;
function getUpsertString(task, values) {
task.completeDefaults();
let dateNow = new Date();
const dateNow = new Date();
let cbInsert = task.callback;
if (isSupportOnConflict && task.callback) {
let userCallback = new connectorUtilities.UserCallback();
const userCallback = new connectorUtilities.UserCallback();
userCallback.fromValues(task.userIndex, task.callback);
cbInsert = userCallback.toSQLInsert();
}
let p0 = addSqlParameter(task.tenant, values);
let p1 = addSqlParameter(task.key, values);
let p2 = addSqlParameter(task.status, values);
let p3 = addSqlParameter(task.statusInfo, values);
let p4 = addSqlParameter(dateNow, values);
let p5 = addSqlParameter(task.userIndex, values);
let p6 = addSqlParameter(task.changeId, values);
let p7 = addSqlParameter(cbInsert, values);
let p8 = addSqlParameter(task.baseurl, values);
const p0 = addSqlParameter(task.tenant, values);
const p1 = addSqlParameter(task.key, values);
const p2 = addSqlParameter(task.status, values);
const p3 = addSqlParameter(task.statusInfo, values);
const p4 = addSqlParameter(dateNow, values);
const p5 = addSqlParameter(task.userIndex, values);
const p6 = addSqlParameter(task.changeId, values);
const p7 = addSqlParameter(cbInsert, values);
const p8 = addSqlParameter(task.baseurl, values);
if (isSupportOnConflict) {
let p9 = addSqlParameter(dateNow, values);
const p9 = addSqlParameter(dateNow, values);
//http://stackoverflow.com/questions/34762732/how-to-find-out-if-an-upsert-was-an-update-with-postgresql-9-5-upsert
let sqlCommand = `INSERT INTO ${cfgTableResult} (tenant, id, status, status_info, last_open_date, user_index, change_id, callback, baseurl)`;
sqlCommand += ` VALUES (${p0}, ${p1}, ${p2}, ${p3}, ${p4}, ${p5}, ${p6}, ${p7}, ${p8})`;
sqlCommand += ` ON CONFLICT (tenant, id) DO UPDATE SET last_open_date = ${p9}`;
if (task.callback) {
let p10 = addSqlParameter(JSON.stringify(task.callback), values);
const p10 = addSqlParameter(JSON.stringify(task.callback), values);
sqlCommand += `, callback = ${cfgTableResult}.callback || '${connectorUtilities.UserCallback.prototype.delimiter}{"userIndex":' `;
sqlCommand += ` || (${cfgTableResult}.user_index + 1)::text || ',"callback":' || ${p10}::text || '}'`;
}
if (task.baseurl) {
let p11 = addSqlParameter(task.baseurl, values);
const p11 = addSqlParameter(task.baseurl, values);
sqlCommand += `, baseurl = ${p11}`;
}
sqlCommand += `, user_index = ${cfgTableResult}.user_index + 1 RETURNING user_index as userindex;`;
@ -155,10 +155,10 @@ function getUpsertString(task, values) {
}
function upsert(ctx, task) {
return new Promise(function(resolve, reject) {
let values = [];
return new Promise((resolve, reject) => {
const values = [];
var sqlCommand = getUpsertString(task, values);
sqlQuery(ctx, sqlCommand, function(error, result) {
sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
if (isSupportOnConflict && '42601' === error.code) {
//SYNTAX ERROR
@ -187,25 +187,25 @@ function insertChanges(ctx, tableChanges, startIndex, objChanges, docId, index,
return;
}
let isSupported = true;
let tenant = [];
let id = [];
let changeId = [];
let userId = [];
let userIdOriginal = [];
let username = [];
let change = [];
let time = [];
const tenant = [];
const id = [];
const changeId = [];
const userId = [];
const userIdOriginal = [];
const username = [];
const change = [];
const time = [];
//Postgres 9.4 multi-argument unnest
let sqlCommand = `INSERT INTO ${tableChanges} (tenant, id, change_id, user_id, user_id_original, user_name, change_data, change_date) `;
let changesType = cfgEditor['binaryChanges'] ? 'bytea' : 'text';
const changesType = cfgEditor['binaryChanges'] ? 'bytea' : 'text';
sqlCommand += `SELECT * FROM UNNEST ($1::text[], $2::text[], $3::int[], $4::text[], $5::text[], $6::text[], $7::${changesType}[], $8::timestamp[]);`;
let values = [tenant, id, changeId, userId, userIdOriginal, username, change, time];
const values = [tenant, id, changeId, userId, userIdOriginal, username, change, time];
let curLength = sqlCommand.length;
for (; i < objChanges.length; ++i) {
//4 is max utf8 bytes per symbol
curLength += 4 * (docId.length + user.id.length + user.idOriginal.length + user.username.length + objChanges[i].change.length) + 4 + 8;
if (curLength >= maxPacketSize && i > startIndex) {
sqlQuery(ctx, sqlCommand, function(error, output) {
sqlQuery(ctx, sqlCommand, (error, output) => {
if (error && '42883' == error.code) {
isSupported = false;
ctx.logger.warn('postgresql does not support UNNEST');
@ -227,7 +227,7 @@ function insertChanges(ctx, tableChanges, startIndex, objChanges, docId, index,
change.push(objChanges[i].change);
time.push(objChanges[i].time);
}
sqlQuery(ctx, sqlCommand, function(error, output) {
sqlQuery(ctx, sqlCommand, (error, output) => {
if (error && '42883' == error.code) {
isSupported = false;
ctx.logger.warn('postgresql does not support UNNEST');

112
DocService/sources/editorDataMemory.js
View File

@ -67,19 +67,19 @@ EditorCommon.prototype._getDocumentData = function(ctx, docId) {
return options;
};
EditorCommon.prototype._checkAndLock = function(ctx, name, docId, fencingToken, ttl) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
const now = Date.now();
let res = true;
if (data[name] && now < data[name].expireAt && fencingToken !== data[name].fencingToken) {
res = false;
} else {
const expireAt = now + ttl * 1000;
data[name] = {fencingToken: fencingToken, expireAt: expireAt};
data[name] = {fencingToken, expireAt};
}
return res;
};
EditorCommon.prototype._checkAndUnlock = function(ctx, name, docId, fencingToken) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
const now = Date.now();
let res;
if (data[name] && now < data[name].expireAt) {
@ -107,10 +107,10 @@ EditorData.prototype.addPresence = async function(ctx, docId, userId, userInfo)
EditorData.prototype.updatePresence = async function(ctx, docId, userId) {};
EditorData.prototype.removePresence = async function(ctx, docId, userId) {};
EditorData.prototype.getPresence = async function(ctx, docId, connections) {
let hvals = [];
const hvals = [];
if (connections) {
for (let i = 0; i < connections.length; ++i) {
let conn = connections[i];
const conn = connections[i];
if (conn.docId === docId && ctx.tenant === tenantManager.getTenantByConnection(ctx, conn)) {
hvals.push(utils.getConnectionInfoStr(conn));
}
@ -138,19 +138,19 @@ EditorData.prototype.getDocumentPresenceExpired = async function(now) {
EditorData.prototype.removePresenceDocument = async function(ctx, docId) {};
EditorData.prototype.addLocks = async function(ctx, docId, locks) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
if (!data.locks) {
data.locks = {};
}
Object.assign(data.locks, locks);
};
EditorData.prototype.addLocksNX = async function(ctx, docId, locks) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
if (!data.locks) {
data.locks = {};
}
let lockConflict = {};
for (let lockId in locks) {
const lockConflict = {};
for (const lockId in locks) {
if (undefined === data.locks[lockId]) {
data.locks[lockId] = locks[lockId];
} else {
@ -160,58 +160,58 @@ EditorData.prototype.addLocksNX = async function(ctx, docId, locks) {
return {lockConflict, allLocks: data.locks};
};
EditorData.prototype.removeLocks = async function(ctx, docId, locks) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
if (data.locks) {
for (let lockId in locks) {
for (const lockId in locks) {
delete data.locks[lockId];
}
}
};
EditorData.prototype.removeAllLocks = async function(ctx, docId) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
data.locks = undefined;
};
EditorData.prototype.getLocks = async function(ctx, docId) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
return data.locks || {};
};
EditorData.prototype.addMessage = async function(ctx, docId, msg) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
if (!data.messages) {
data.messages = [];
}
data.messages.push(msg);
};
EditorData.prototype.removeMessages = async function(ctx, docId) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
data.messages = undefined;
};
EditorData.prototype.getMessages = async function(ctx, docId) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
return data.messages || [];
};
EditorData.prototype.setSaved = async function(ctx, docId, status) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
data.saved = status;
};
EditorData.prototype.getdelSaved = async function(ctx, docId) {
let data = this._getDocumentData(ctx, docId);
let res = data.saved;
const data = this._getDocumentData(ctx, docId);
const res = data.saved;
data.saved = null;
return res;
};
EditorData.prototype.setForceSave = async function(ctx, docId, time, index, baseUrl, changeInfo, convertInfo) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
data.forceSave = {time, index, baseUrl, changeInfo, started: false, ended: false, convertInfo};
};
EditorData.prototype.getForceSave = async function(ctx, docId) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
return data.forceSave || null;
};
EditorData.prototype.checkAndStartForceSave = async function(ctx, docId) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
let res;
if (data.forceSave && !data.forceSave.started) {
data.forceSave.started = true;
@ -221,7 +221,7 @@ EditorData.prototype.checkAndStartForceSave = async function(ctx, docId) {
return res;
};
EditorData.prototype.checkAndSetForceSave = async function(ctx, docId, time, index, started, ended, convertInfo) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
let res;
if (data.forceSave && time === data.forceSave.time && index === data.forceSave.index) {
data.forceSave.started = started;
@ -232,16 +232,16 @@ EditorData.prototype.checkAndSetForceSave = async function(ctx, docId, time, ind
return res;
};
EditorData.prototype.removeForceSave = async function(ctx, docId) {
let data = this._getDocumentData(ctx, docId);
const data = this._getDocumentData(ctx, docId);
data.forceSave = undefined;
};
EditorData.prototype.cleanDocumentOnExit = async function(ctx, docId) {
let tenantData = this.data[ctx.tenant];
const tenantData = this.data[ctx.tenant];
if (tenantData) {
delete tenantData[docId];
}
let tenantTimer = this.forceSaveTimer[ctx.tenant];
const tenantTimer = this.forceSaveTimer[ctx.tenant];
if (tenantTimer) {
delete tenantTimer[docId];
}
@ -257,11 +257,11 @@ EditorData.prototype.addForceSaveTimerNX = async function(ctx, docId, expireAt)
}
};
EditorData.prototype.getForceSaveTimer = async function(now) {
let res = [];
for (let tenant in this.forceSaveTimer) {
const res = [];
for (const tenant in this.forceSaveTimer) {
if (this.forceSaveTimer.hasOwnProperty(tenant)) {
let tenantTimer = this.forceSaveTimer[tenant];
for (let docId in tenantTimer) {
const tenantTimer = this.forceSaveTimer[tenant];
for (const docId in tenantTimer) {
if (tenantTimer.hasOwnProperty(docId)) {
if (tenantTimer[docId] < now) {
res.push([tenant, docId]);
@ -291,19 +291,19 @@ EditorStat.prototype.addPresenceUniqueUser = async function(ctx, userId, expireA
if (!tenantUser) {
this.uniqueUser[ctx.tenant] = tenantUser = {};
}
tenantUser[userId] = {expireAt: expireAt, userInfo: userInfo};
tenantUser[userId] = {expireAt, userInfo};
};
EditorStat.prototype.getPresenceUniqueUser = async function(ctx, nowUTC) {
let res = [];
const res = [];
let tenantUser = this.uniqueUser[ctx.tenant];
if (!tenantUser) {
this.uniqueUser[ctx.tenant] = tenantUser = {};
}
for (let userId in tenantUser) {
for (const userId in tenantUser) {
if (tenantUser.hasOwnProperty(userId)) {
if (tenantUser[userId].expireAt > nowUTC) {
let elem = tenantUser[userId];
let newElem = {userid: userId, expire: new Date(elem.expireAt * 1000)};
const elem = tenantUser[userId];
const newElem = {userid: userId, expire: new Date(elem.expireAt * 1000)};
Object.assign(newElem, elem.userInfo);
res.push(newElem);
} else {
@ -319,24 +319,24 @@ EditorStat.prototype.addPresenceUniqueUsersOfMonth = async function(ctx, userId,
this.uniqueUsersOfMonth[ctx.tenant] = tenantUser = {};
}
if(!tenantUser[period]) {
let expireAt = Date.now() + cfgExpMonthUniqueUsers;
tenantUser[period] = {expireAt: expireAt, data: {}};
const expireAt = Date.now() + cfgExpMonthUniqueUsers;
tenantUser[period] = {expireAt, data: {}};
}
tenantUser[period].data[userId] = userInfo;
};
EditorStat.prototype.getPresenceUniqueUsersOfMonth = async function(ctx) {
let res = {};
let nowUTC = Date.now();
const res = {};
const nowUTC = Date.now();
let tenantUser = this.uniqueUsersOfMonth[ctx.tenant];
if (!tenantUser) {
this.uniqueUsersOfMonth[ctx.tenant] = tenantUser = {};
}
for (let periodId in tenantUser) {
for (const periodId in tenantUser) {
if (tenantUser.hasOwnProperty(periodId)) {
if (tenantUser[periodId].expireAt <= nowUTC) {
delete tenantUser[periodId];
} else {
let date = new Date(parseInt(periodId)).toISOString();
const date = new Date(parseInt(periodId)).toISOString();
res[date] = tenantUser[periodId].data;
}
}
@ -349,19 +349,19 @@ EditorStat.prototype.addPresenceUniqueViewUser = async function(ctx, userId, exp
if (!tenantUser) {
this.uniqueViewUser[ctx.tenant] = tenantUser = {};
}
tenantUser[userId] = {expireAt: expireAt, userInfo: userInfo};
tenantUser[userId] = {expireAt, userInfo};
};
EditorStat.prototype.getPresenceUniqueViewUser = async function(ctx, nowUTC) {
let res = [];
const res = [];
let tenantUser = this.uniqueViewUser[ctx.tenant];
if (!tenantUser) {
this.uniqueViewUser[ctx.tenant] = tenantUser = {};
}
for (let userId in tenantUser) {
for (const userId in tenantUser) {
if (tenantUser.hasOwnProperty(userId)) {
if (tenantUser[userId].expireAt > nowUTC) {
let elem = tenantUser[userId];
let newElem = {userid: userId, expire: new Date(elem.expireAt * 1000)};
const elem = tenantUser[userId];
const newElem = {userid: userId, expire: new Date(elem.expireAt * 1000)};
Object.assign(newElem, elem.userInfo);
res.push(newElem);
} else {
@ -377,24 +377,24 @@ EditorStat.prototype.addPresenceUniqueViewUsersOfMonth = async function(ctx, use
this.uniqueViewUsersOfMonth[ctx.tenant] = tenantUser = {};
}
if(!tenantUser[period]) {
let expireAt = Date.now() + cfgExpMonthUniqueUsers;
tenantUser[period] = {expireAt: expireAt, data: {}};
const expireAt = Date.now() + cfgExpMonthUniqueUsers;
tenantUser[period] = {expireAt, data: {}};
}
tenantUser[period].data[userId] = userInfo;
};
EditorStat.prototype.getPresenceUniqueViewUsersOfMonth = async function(ctx) {
let res = {};
let nowUTC = Date.now();
const res = {};
const nowUTC = Date.now();
let tenantUser = this.uniqueViewUsersOfMonth[ctx.tenant];
if (!tenantUser) {
this.uniqueViewUsersOfMonth[ctx.tenant] = tenantUser = {};
}
for (let periodId in tenantUser) {
for (const periodId in tenantUser) {
if (tenantUser.hasOwnProperty(periodId)) {
if (tenantUser[periodId].expireAt <= nowUTC) {
delete tenantUser[periodId];
} else {
let date = new Date(parseInt(periodId)).toISOString();
const date = new Date(parseInt(periodId)).toISOString();
res[date] = tenantUser[periodId].data;
}
}
@ -426,7 +426,7 @@ EditorStat.prototype.getEditorConnectionsCount = async function(ctx, connections
let count = 0;
if (connections) {
for (let i = 0; i < connections.length; ++i) {
let conn = connections[i];
const conn = connections[i];
if (!(conn.isCloseCoAuthoring || (conn.user && conn.user.view)) && ctx.tenant === tenantManager.getTenantByConnection(ctx, conn)) {
count++;
}
@ -440,7 +440,7 @@ EditorStat.prototype.getViewerConnectionsCount = async function(ctx, connections
let count = 0;
if (connections) {
for (let i = 0; i < connections.length; ++i) {
let conn = connections[i];
const conn = connections[i];
if (conn.isCloseCoAuthoring || (conn.user && conn.user.view) && ctx.tenant === tenantManager.getTenantByConnection(ctx, conn)) {
count++;
}
@ -454,7 +454,7 @@ EditorStat.prototype.getLiveViewerConnectionsCount = async function(ctx, connect
let count = 0;
if (connections) {
for (let i = 0; i < connections.length; ++i) {
let conn = connections[i];
const conn = connections[i];
if (utils.isLiveViewer(conn) && ctx.tenant === tenantManager.getTenantByConnection(ctx, conn)) {
count++;
}
@ -477,7 +477,7 @@ EditorStat.prototype.removeShutdown = async function(key, docId) {
EditorStat.prototype.getShutdownCount = async function(key) {
let count = 0;
if (this.shutdown[key]) {
for (let docId in this.shutdown[key]) {
for (const docId in this.shutdown[key]) {
if (this.shutdown[key].hasOwnProperty(docId)) {
count++;
}

10
DocService/sources/fileuploaderservice.js
View File

@ -51,7 +51,7 @@ const cfgTokenEnableBrowser = config.get('services.CoAuthoring.token.enable.brow
const PATTERN_ENCRYPTED = 'ENCRYPTED;';
function* checkJwtUpload(ctx, errorName, token){
let checkJwtRes = yield docsCoServer.checkJwt(ctx, token, commonDefines.c_oAscSecretType.Session);
const checkJwtRes = yield docsCoServer.checkJwt(ctx, token, commonDefines.c_oAscSecretType.Session);
return checkJwtUploadTransformRes(ctx, errorName, checkJwtRes);
}
function checkJwtUploadTransformRes(ctx, errorName, checkJwtRes){
@ -79,8 +79,8 @@ exports.uploadImageFile = function(req, res) {
return co(function* () {
let httpStatus = 200;
var docId = 'null';
let output = {};
let ctx = new operationContext.Context();
const output = {};
const ctx = new operationContext.Context();
try {
ctx.initFromRequest(req);
yield ctx.initTenantCache();
@ -98,7 +98,7 @@ exports.uploadImageFile = function(req, res) {
//todo remove compatibility with previous versions
checkJwtRes = yield docsCoServer.checkJwt(ctx, req.query['token'], commonDefines.c_oAscSecretType.Session);
}
let transformedRes = checkJwtUploadTransformRes(ctx, 'uploadImageFile', checkJwtRes);
const transformedRes = checkJwtUploadTransformRes(ctx, 'uploadImageFile', checkJwtRes);
if (!transformedRes.err) {
docId = transformedRes.docId || docId;
encrypted = transformedRes.encrypted;
@ -118,7 +118,7 @@ exports.uploadImageFile = function(req, res) {
formatStr = buffer.toString('utf8', PATTERN_ENCRYPTED.length, buffer.indexOf(';', PATTERN_ENCRYPTED.length));
}
var supportedFormats = tenTypesUpload || 'jpg';
let formatLimit = formatStr && -1 !== supportedFormats.indexOf(formatStr);
const formatLimit = formatStr && -1 !== supportedFormats.indexOf(formatStr);
if (formatLimit) {
if (format === constants.AVS_OFFICESTUDIO_FILE_IMAGE_TIFF) {
buffer = yield utilsDocService.convertImageToPng(ctx, buffer);

42
DocService/sources/gc.js
View File

@ -52,16 +52,16 @@ var cfgExpFilesRemovedAtOnce = config.get('services.CoAuthoring.expire.filesremo
var cfgForceSaveStep = config.get('services.CoAuthoring.autoAssembly.step');
function getCronStep(cronTime){
let cronJob = new cron.CronJob(cronTime, function(){});
let dates = cronJob.nextDates(2);
const cronJob = new cron.CronJob(cronTime, (() =>{}));
const dates = cronJob.nextDates(2);
return dates[1] - dates[0];
}
let expFilesStep = getCronStep(cfgExpFilesCron);
let expDocumentsStep = getCronStep(cfgExpDocumentsCron);
const expFilesStep = getCronStep(cfgExpFilesCron);
const expDocumentsStep = getCronStep(cfgExpDocumentsCron);
var checkFileExpire = function(expireSeconds) {
return co(function* () {
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
let currentExpFilesStep = expFilesStep;
try {
ctx.logger.info('checkFileExpire start');
@ -82,10 +82,10 @@ var checkFileExpire = function(expireSeconds) {
let currentTenant = null;
for (var i = 0; i < expired.length; ++i) {
let tenant = expired[i].tenant;
let docId = expired[i].id;
let shardKey = sqlBase.DocumentAdditional.prototype.getShardKey(expired[i].additional);
let wopiSrc = sqlBase.DocumentAdditional.prototype.getWopiSrc(expired[i].additional);
const tenant = expired[i].tenant;
const docId = expired[i].id;
const shardKey = sqlBase.DocumentAdditional.prototype.getShardKey(expired[i].additional);
const wopiSrc = sqlBase.DocumentAdditional.prototype.getWopiSrc(expired[i].additional);
if (currentTenant !== tenant) {
ctx.init(tenant, docId, ctx.userId, shardKey, wopiSrc);
@ -99,7 +99,7 @@ var checkFileExpire = function(expireSeconds) {
//todo tenant
//check that no one is in the document
let editorsCount = yield docsCoServer.getEditorsCountPromise(ctx, docId);
const editorsCount = yield docsCoServer.getEditorsCountPromise(ctx, docId);
if(0 === editorsCount){
if (yield canvasService.cleanupCache(ctx, docId)) {
currentRemovedCount++;
@ -125,14 +125,14 @@ var checkDocumentExpire = function() {
var removedCount = 0;
var startSaveCount = 0;
let currentExpDocumentsStep = expDocumentsStep;
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
ctx.logger.info('checkDocumentExpire start');
yield ctx.initTenantCache();
const currentDocumentsCron = ctx.getCfg('services.CoAuthoring.expire.documentsCron', cfgExpDocumentsCron);
currentExpDocumentsStep = getCronStep(currentDocumentsCron);
var now = (new Date()).getTime();
let expiredKeys = yield docsCoServer.editorData.getDocumentPresenceExpired(now);
const expiredKeys = yield docsCoServer.editorData.getDocumentPresenceExpired(now);
if (expiredKeys.length > 0) {
queue = new queueService();
yield queue.initPromise(true, false, false, false, false, false);
@ -141,8 +141,8 @@ var checkDocumentExpire = function() {
let currentTenant = null;
for (var i = 0; i < expiredKeys.length; ++i) {
let tenant = expiredKeys[i][0];
let docId = expiredKeys[i][1];
const tenant = expiredKeys[i][0];
const docId = expiredKeys[i][1];
if (docId) {
if (currentTenant !== tenant) {
ctx.init(tenant, docId, ctx.userId);
@ -181,18 +181,18 @@ var checkDocumentExpire = function() {
}
});
};
let forceSaveTimeout = function() {
const forceSaveTimeout = function() {
return co(function* () {
let queue = null;
let pubsub = null;
let currentForceSaveStep = cfgForceSaveStep;
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
ctx.logger.info('forceSaveTimeout start');
yield ctx.initTenantCache();
currentForceSaveStep = ctx.getCfg('services.CoAuthoring.autoAssembly.step', cfgForceSaveStep);
let now = (new Date()).getTime();
let expiredKeys = yield docsCoServer.editorData.getForceSaveTimer(now);
const now = (new Date()).getTime();
const expiredKeys = yield docsCoServer.editorData.getForceSaveTimer(now);
if (expiredKeys.length > 0) {
queue = new queueService();
yield queue.initPromise(true, false, false, false, false, false);
@ -202,12 +202,12 @@ let forceSaveTimeout = function() {
expiredKeys.sort((a, b) => a[0].localeCompare(b[0]));
let actions = [];
const actions = [];
let currentTenant = null;
for (let i = 0; i < expiredKeys.length; ++i) {
let tenant = expiredKeys[i][0];
let docId = expiredKeys[i][1];
const tenant = expiredKeys[i][0];
const docId = expiredKeys[i][1];
if (docId) {
if (currentTenant !== tenant) {
ctx.init(tenant, docId, ctx.userId);

26
DocService/sources/pubsubRabbitMQ.js
View File

@ -50,7 +50,7 @@ function initRabbit(pubsub, callback) {
return co(function* () {
var e = null;
try {
var conn = yield rabbitMQCore.connetPromise(function() {
var conn = yield rabbitMQCore.connetPromise(() => {
clear(pubsub);
if (!pubsub.isClose) {
setTimeout(() => {
@ -66,7 +66,7 @@ function initRabbit(pubsub, callback) {
pubsub.channelReceive = yield rabbitMQCore.createChannelPromise(conn);
var queue = yield rabbitMQCore.assertQueuePromise(pubsub.channelReceive, cfgRabbitQueuePubsub.name, cfgRabbitQueuePubsub.options);
pubsub.channelReceive.bindQueue(queue, cfgRabbitExchangePubSub.name, '');
yield rabbitMQCore.consumePromise(pubsub.channelReceive, queue, function (message) {
yield rabbitMQCore.consumePromise(pubsub.channelReceive, queue, (message) => {
if(null != pubsub.channelReceive){
if (message) {
pubsub.emit('message', message.content.toString());
@ -88,7 +88,7 @@ function initActive(pubsub, callback) {
return co(function*() {
var e = null;
try {
var conn = yield activeMQCore.connetPromise(function() {
var conn = yield activeMQCore.connetPromise(() => {
clear(pubsub);
if (!pubsub.isClose) {
setTimeout(() => {
@ -98,7 +98,7 @@ function initActive(pubsub, callback) {
});
pubsub.connection = conn;
//https://github.com/amqp/rhea/issues/251#issuecomment-535076570
let optionsPubSubSender = {
const optionsPubSubSender = {
target: {
address: cfgActiveTopicPubSub,
capabilities: ['topic']
@ -106,7 +106,7 @@ function initActive(pubsub, callback) {
};
pubsub.channelPublish = yield activeMQCore.openSenderPromise(conn, optionsPubSubSender);
let optionsPubSubReceiver = {
const optionsPubSubReceiver = {
source: {
address: cfgActiveTopicPubSub,
capabilities: ['topic']
@ -114,10 +114,10 @@ function initActive(pubsub, callback) {
credit_window: 0,
autoaccept: false
};
let receiver = yield activeMQCore.openReceiverPromise(conn, optionsPubSubReceiver);
const receiver = yield activeMQCore.openReceiverPromise(conn, optionsPubSubReceiver);
//todo ?consumer.dispatchAsync=false&consumer.prefetchSize=1
receiver.add_credit(1);
receiver.on("message", function(context) {
receiver.on("message", (context) => {
if (context) {
pubsub.emit('message', context.message.body);
}
@ -150,9 +150,9 @@ function repeat(pubsub) {
}
function publishRabbit(pubsub, data) {
return new Promise(function (resolve, reject) {
return new Promise((resolve, reject) => {
//Channels act like stream.Writable when you call publish or sendToQueue: they return either true, meaning “keep sending”, or false, meaning “please wait for a ‘drain’ event”.
let keepSending = pubsub.channelPublish.publish(pubsub.exchangePublish, '', data);
const keepSending = pubsub.channelPublish.publish(pubsub.exchangePublish, '', data);
if (!keepSending) {
//todo (node:4308) MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 drain listeners added to [Sender]. Use emitter.setMaxListeners() to increase limit
pubsub.channelPublish.once('drain', resolve);
@ -163,9 +163,9 @@ function publishRabbit(pubsub, data) {
}
function publishActive(pubsub, data) {
return new Promise(function (resolve, reject) {
return new Promise((resolve, reject) => {
//Returns true if the sender has available credits for sending a message. Otherwise it returns false.
let sendable = pubsub.channelPublish.sendable();
const sendable = pubsub.channelPublish.sendable();
if (!sendable) {
//todo (node:4308) MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 sendable listeners added to [Sender]. Use emitter.setMaxListeners() to increase limit
pubsub.channelPublish.once('sendable', () => {
@ -233,8 +233,8 @@ PubsubRabbitMQ.prototype.init = function (callback) {
};
PubsubRabbitMQ.prototype.initPromise = function() {
var t = this;
return new Promise(function(resolve, reject) {
init(t, function(err) {
return new Promise((resolve, reject) => {
init(t, (err) => {
if (err) {
reject(err);
} else {

10
DocService/sources/routes/config.js
View File

@ -40,16 +40,16 @@ const runtimeConfigManager = require('../../../Common/sources/runtimeConfigManag
const router = express.Router();
const rawFileParser = bodyParser.raw(
{inflate: true, limit: config.get('services.CoAuthoring.server.limits_tempfile_upload'), type: function() {return true;}});
{inflate: true, limit: config.get('services.CoAuthoring.server.limits_tempfile_upload'), type() {return true;}});
router.get('/', async (req, res) => {
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
let result = '{}';
try {
ctx.initFromRequest(req);
await ctx.initTenantCache();
ctx.logger.debug('config get start');
let cfg = ctx.getFullCfg();
const cfg = ctx.getFullCfg();
result = JSON.stringify(cfg);
} catch (error) {
ctx.logger.error('config get error: %s', error.stack);
@ -62,12 +62,12 @@ router.get('/', async (req, res) => {
});
router.post('/', rawFileParser, async (req, res) => {
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
ctx.initFromRequest(req);
await ctx.initTenantCache();
let newConfig = JSON.parse(req.body);
const newConfig = JSON.parse(req.body);
if (tenantManager.isMultitenantMode(ctx) && !tenantManager.isDefaultTenant(ctx)) {
await tenantManager.setTenantConfig(ctx, newConfig);

4
DocService/sources/routes/static.js
View File

@ -56,7 +56,7 @@ function initCacheRouter(cfgStorage, routs) {
const { storageFolderName, fs: { folderPath, secretString: secret } } = cfgStorage;
routs.forEach((rout) => {
if (!rout) return;
if (!rout) {return;}
const rootPath = path.join(folderPath, rout);
@ -149,7 +149,7 @@ function createCacheMiddleware(prefix, rootPath, cfgStorage, secret, rout) {
};
}
for (let i in cfgStaticContent) {
for (const i in cfgStaticContent) {
if (cfgStaticContent.hasOwnProperty(i)) {
router.use(i, express.static(cfgStaticContent[i]['path'], cfgStaticContent[i]['options']));
}

4
DocService/sources/shutdown.js
View File

@ -62,7 +62,7 @@ exports.shutdown = function(ctx, editorStat, status) {
yield pubsub.initPromise();
//inner ping to update presence
ctx.logger.debug('shutdown pubsub shutdown message');
yield pubsub.publish(JSON.stringify({type: commonDefines.c_oPublishType.shutdown, ctx: ctx, status: status}));
yield pubsub.publish(JSON.stringify({type: commonDefines.c_oPublishType.shutdown, ctx, status}));
//wait while pubsub deliver and start conversion
ctx.logger.debug('shutdown start wait pubsub deliver');
var startTime = new Date().getTime();
@ -78,7 +78,7 @@ exports.shutdown = function(ctx, editorStat, status) {
break;
}
var remainingFiles = yield editorStat.getShutdownCount(redisKeyShutdown);
let inSavingStatus = yield sqlBase.getCountWithStatus(ctx, commonDefines.FileStatus.SaveVersion, EXEC_TIMEOUT);
const inSavingStatus = yield sqlBase.getCountWithStatus(ctx, commonDefines.FileStatus.SaveVersion, EXEC_TIMEOUT);
ctx.logger.debug('shutdown remaining files editorStat:%d, db:%d', remainingFiles, inSavingStatus);
if (!isStartWait && (remainingFiles + inSavingStatus) <= 0) {
break;

118
DocService/sources/taskresult.js
View File

@ -41,8 +41,8 @@ var config = require('config');
const cfgTableResult = config.get('services.CoAuthoring.sql.tableResult');
let addSqlParam = sqlBase.addSqlParameter;
let concatParams = sqlBase.concatParams;
const addSqlParam = sqlBase.addSqlParameter;
const concatParams = sqlBase.concatParams;
var RANDOM_KEY_MAX = 10000;
@ -113,12 +113,12 @@ async function selectWithCache(ctx, docId) {
return ctx.taskResultCache;
}
function select(ctx, docId) {
return new Promise(function(resolve, reject) {
let values = [];
let p1 = addSqlParam(ctx.tenant, values);
let p2 = addSqlParam(docId, values);
let sqlCommand = `SELECT * FROM ${cfgTableResult} WHERE tenant=${p1} AND id=${p2};`;
sqlBase.sqlQuery(ctx, sqlCommand, function(error, result) {
return new Promise((resolve, reject) => {
const values = [];
const p1 = addSqlParam(ctx.tenant, values);
const p2 = addSqlParam(docId, values);
const sqlCommand = `SELECT * FROM ${cfgTableResult} WHERE tenant=${p1} AND id=${p2};`;
sqlBase.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {
@ -130,64 +130,64 @@ function select(ctx, docId) {
function toUpdateArray(task, updateTime, isMask, values, setPassword) {
var res = [];
if (null != task.status) {
let sqlParam = addSqlParam(task.status, values);
const sqlParam = addSqlParam(task.status, values);
res.push(`status=${sqlParam}`);
}
if (null != task.statusInfo) {
let sqlParam = addSqlParam(task.statusInfo, values);
const sqlParam = addSqlParam(task.statusInfo, values);
res.push(`status_info=${sqlParam}` );
}
if (updateTime) {
let sqlParam = addSqlParam(new Date(), values);
const sqlParam = addSqlParam(new Date(), values);
res.push(`last_open_date=${sqlParam}`);
}
if (null != task.indexUser) {
let sqlParam = addSqlParam(task.indexUser, values);
const sqlParam = addSqlParam(task.indexUser, values);
res.push(`user_index=${sqlParam}`);
}
if (null != task.changeId) {
let sqlParam = addSqlParam(task.changeId, values);
const sqlParam = addSqlParam(task.changeId, values);
res.push(`change_id=${sqlParam}`);
}
if (null != task.callback && !isMask) {
var userCallback = new sqlBase.UserCallback();
userCallback.fromValues(task.indexUser, task.callback);
let sqlParam = addSqlParam(userCallback.toSQLInsert(), values);
const sqlParam = addSqlParam(userCallback.toSQLInsert(), values);
res.push(`callback=${concatParams('callback', sqlParam)}`);
}
if (null != task.baseurl) {
let sqlParam = addSqlParam(task.baseurl, values);
const sqlParam = addSqlParam(task.baseurl, values);
res.push(`baseurl=${sqlParam}`);
}
if (setPassword) {
let sqlParam = addSqlParam(task.password, values);
const sqlParam = addSqlParam(task.password, values);
res.push(`password=${sqlParam}`);
} else if (null != task.password || setPassword) {
var documentPassword = new sqlBase.DocumentPassword();
documentPassword.fromValues(task.password, task.innerPasswordChange);
let sqlParam = addSqlParam(documentPassword.toSQLInsert(), values);
const sqlParam = addSqlParam(documentPassword.toSQLInsert(), values);
res.push(`password=${concatParams('password', sqlParam)}`);
}
if (null != task.additional) {
let sqlParam = addSqlParam(task.additional, values);
const sqlParam = addSqlParam(task.additional, values);
res.push(`additional=${concatParams('additional', sqlParam)}`);
}
return res;
}
function update(ctx, task, setPassword) {
return new Promise(function(resolve, reject) {
let values = [];
let updateElems = toUpdateArray(task, true, false, values, setPassword);
let sqlSet = updateElems.join(', ');
let p1 = addSqlParam(task.tenant, values);
let p2 = addSqlParam(task.key, values);
let sqlCommand = `UPDATE ${cfgTableResult} SET ${sqlSet} WHERE tenant=${p1} AND id=${p2};`;
sqlBase.sqlQuery(ctx, sqlCommand, function(error, result) {
return new Promise((resolve, reject) => {
const values = [];
const updateElems = toUpdateArray(task, true, false, values, setPassword);
const sqlSet = updateElems.join(', ');
const p1 = addSqlParam(task.tenant, values);
const p2 = addSqlParam(task.key, values);
const sqlCommand = `UPDATE ${cfgTableResult} SET ${sqlSet} WHERE tenant=${p1} AND id=${p2};`;
sqlBase.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {
@ -198,16 +198,16 @@ function update(ctx, task, setPassword) {
}
function updateIf(ctx, task, mask) {
return new Promise(function(resolve, reject) {
let values = [];
let commandArg = toUpdateArray(task, true, false, values, false);
let commandArgMask = toUpdateArray(mask, false, true, values, false);
return new Promise((resolve, reject) => {
const values = [];
const commandArg = toUpdateArray(task, true, false, values, false);
const commandArgMask = toUpdateArray(mask, false, true, values, false);
commandArgMask.push('tenant=' + addSqlParam(mask.tenant, values));
commandArgMask.push('id=' + addSqlParam(mask.key, values));
let sqlSet = commandArg.join(', ');
let sqlWhere = commandArgMask.join(' AND ');
let sqlCommand = `UPDATE ${cfgTableResult} SET ${sqlSet} WHERE ${sqlWhere};`;
sqlBase.sqlQuery(ctx, sqlCommand, function(error, result) {
const sqlSet = commandArg.join(', ');
const sqlWhere = commandArgMask.join(' AND ');
const sqlCommand = `UPDATE ${cfgTableResult} SET ${sqlSet} WHERE ${sqlWhere};`;
sqlBase.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {
@ -217,10 +217,10 @@ function updateIf(ctx, task, mask) {
});
}
function restoreInitialPassword(ctx, docId) {
return select(ctx, docId).then(function(selectRes) {
return select(ctx, docId).then((selectRes) => {
if (selectRes.length > 0) {
var row = selectRes[0];
let docPassword = sqlBase.DocumentPassword.prototype.getDocPassword(ctx, row.password);
const docPassword = sqlBase.DocumentPassword.prototype.getDocPassword(ctx, row.password);
var updateTask = new TaskResultData();
updateTask.tenant = ctx.tenant;
updateTask.key = docId;
@ -238,7 +238,7 @@ function restoreInitialPassword(ctx, docId) {
}
function addRandomKey(ctx, task, key, opt_prefix, opt_size) {
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
task.tenant = ctx.tenant;
if (undefined !== opt_prefix && undefined !== opt_size) {
task.key = opt_prefix + crypto.randomBytes(opt_size).toString("hex");
@ -246,19 +246,19 @@ function addRandomKey(ctx, task, key, opt_prefix, opt_size) {
task.key = key + '_' + Math.round(Math.random() * RANDOM_KEY_MAX);
}
task.completeDefaults();
let values = [];
let p0 = addSqlParam(task.tenant, values);
let p1 = addSqlParam(task.key, values);
let p2 = addSqlParam(task.status, values);
let p3 = addSqlParam(task.statusInfo, values);
let p4 = addSqlParam(new Date(), values);
let p5 = addSqlParam(task.userIndex, values);
let p6 = addSqlParam(task.changeId, values);
let p7 = addSqlParam(task.callback, values);
let p8 = addSqlParam(task.baseurl, values);
let sqlCommand = `INSERT INTO ${cfgTableResult} (tenant, id, status, status_info, last_open_date, user_index, change_id, callback, baseurl)` +
const values = [];
const p0 = addSqlParam(task.tenant, values);
const p1 = addSqlParam(task.key, values);
const p2 = addSqlParam(task.status, values);
const p3 = addSqlParam(task.statusInfo, values);
const p4 = addSqlParam(new Date(), values);
const p5 = addSqlParam(task.userIndex, values);
const p6 = addSqlParam(task.changeId, values);
const p7 = addSqlParam(task.callback, values);
const p8 = addSqlParam(task.baseurl, values);
const sqlCommand = `INSERT INTO ${cfgTableResult} (tenant, id, status, status_info, last_open_date, user_index, change_id, callback, baseurl)` +
` VALUES (${p0}, ${p1}, ${p2}, ${p3}, ${p4}, ${p5}, ${p6}, ${p7}, ${p8});`;
sqlBase.sqlQuery(ctx, sqlCommand, function(error, result) {
sqlBase.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {
@ -294,12 +294,12 @@ function* addRandomKeyTask(ctx, key, opt_prefix, opt_size) {
}
function remove(ctx, docId) {
return new Promise(function(resolve, reject) {
let values = [];
let p1 = addSqlParam(ctx.tenant, values);
let p2 = addSqlParam(docId, values);
return new Promise((resolve, reject) => {
const values = [];
const p1 = addSqlParam(ctx.tenant, values);
const p2 = addSqlParam(docId, values);
const sqlCommand = `DELETE FROM ${cfgTableResult} WHERE tenant=${p1} AND id=${p2};`;
sqlBase.sqlQuery(ctx, sqlCommand, function(error, result) {
sqlBase.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {
@ -309,14 +309,14 @@ function remove(ctx, docId) {
});
}
function removeIf(ctx, mask) {
return new Promise(function(resolve, reject) {
let values = [];
let commandArgMask = toUpdateArray(mask, false, true, values, false);
return new Promise((resolve, reject) => {
const values = [];
const commandArgMask = toUpdateArray(mask, false, true, values, false);
commandArgMask.push('tenant=' + addSqlParam(mask.tenant, values));
commandArgMask.push('id=' + addSqlParam(mask.key, values));
let sqlWhere = commandArgMask.join(' AND ');
const sqlWhere = commandArgMask.join(' AND ');
const sqlCommand = `DELETE FROM ${cfgTableResult} WHERE ${sqlWhere};`;
sqlBase.sqlQuery(ctx, sqlCommand, function(error, result) {
sqlBase.sqlQuery(ctx, sqlCommand, (error, result) => {
if (error) {
reject(error);
} else {

8
DocService/sources/utilsDocService.js
View File

@ -56,8 +56,8 @@ async function fixImageExifRotation(ctx, buffer) {
}
//todo move to DocService dir common
try {
let parser = exifParser.create(buffer);
let exif = parser.parse();
const parser = exifParser.create(buffer);
const exif = parser.parse();
if (exif.tags?.Orientation > 1) {
ctx.logger.debug('fixImageExifRotation remove exif and rotate:%j', exif);
buffer = convertImageTo(ctx, buffer, Jimp.AUTO);
@ -73,7 +73,7 @@ async function convertImageToPng(ctx, buffer) {
async function convertImageTo(ctx, buffer, mime) {
try {
ctx.logger.debug('convertImageTo %s', mime);
let image = await Jimp.read(buffer);
const image = await Jimp.read(buffer);
//remove exif
image.bitmap.exifBuffer = undefined;
//set jpeg and png quality
@ -92,7 +92,7 @@ async function convertImageTo(ctx, buffer, mime) {
* @returns {number | undefined}
*/
function localeToLCID(lang) {
let elem = locale[lang && lang.toLowerCase()];
const elem = locale[lang && lang.toLowerCase()];
return elem && elem.id;
}

310
DocService/sources/wopiClient.js
View File

@ -103,11 +103,11 @@ if (!mimeDB["application/vnd.visio2013"]) {
mimeDB["application/vnd.visio2013"] = {extensions: ["vsdx", "vstx", "vssx", "vsdm", "vstm", "vssm"]};
}
let mimeTypesByExt = (function() {
let mimeTypesByExt = {};
for (let mimeType in mimeDB) {
const mimeTypesByExt = (function() {
const mimeTypesByExt = {};
for (const mimeType in mimeDB) {
if (mimeDB.hasOwnProperty(mimeType)) {
let val = mimeDB[mimeType];
const val = mimeDB[mimeType];
if (val.extensions) {
val.extensions.forEach((value) => {
if (!mimeTypesByExt[value]) {
@ -129,7 +129,7 @@ async function getTemplatesFolderExts(ctx){
templatesFolderExtsCache = dirContent
.filter(dirObject => dirObject.isFile())
.reduce((result, item, index, array) => {
let ext = path.extname(item.name).substring(1);
const ext = path.extname(item.name).substring(1);
result[ext] = ext;
return result;
}, {});
@ -140,7 +140,7 @@ async function getTemplatesFolderExts(ctx){
function discovery(req, res) {
return co(function*() {
const xml = xmlbuilder2.create({version: '1.0', encoding: 'utf-8'});
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
ctx.initFromRequest(req);
yield ctx.initTenantCache();
@ -170,18 +170,18 @@ function discovery(req, res) {
const tenWopiExponentOld = ctx.getCfg('wopi.exponentOld', cfgWopiExponentOld);
const tenWopiHost = ctx.getCfg('wopi.host', cfgWopiHost);
let baseUrl = tenWopiHost || utils.getBaseUrlByRequest(ctx, req);
let names = ['Word','Excel','PowerPoint','Pdf'];
let favIconUrls = [tenWopiFavIconUrlWord, tenWopiFavIconUrlCell, tenWopiFavIconUrlSlide, tenWopiFavIconUrlPdf];
let exts = [
const baseUrl = tenWopiHost || utils.getBaseUrlByRequest(ctx, req);
const names = ['Word','Excel','PowerPoint','Pdf'];
const favIconUrls = [tenWopiFavIconUrlWord, tenWopiFavIconUrlCell, tenWopiFavIconUrlSlide, tenWopiFavIconUrlPdf];
const exts = [
{targetext: 'docx', view: tenWopiWordView, edit: tenWopiWordEdit},
{targetext: 'xlsx', view: tenWopiCellView, edit: tenWopiCellEdit},
{targetext: 'pptx', view: tenWopiSlideView, edit: tenWopiSlideEdit},
{targetext: null, view: tenWopiPdfView, edit: tenWopiPdfEdit}
];
let documentTypes = [`word`, `cell`, `slide`, `pdf`];
const documentTypes = [`word`, `cell`, `slide`, `pdf`];
//todo check sdkjs-ooxml addon
let addVisio = (tenWopiDiagramView.length > 0 || tenWopiDiagramEdit.length > 0)
const addVisio = (tenWopiDiagramView.length > 0 || tenWopiDiagramEdit.length > 0)
&& (constants.PACKAGE_TYPE_OS !== license.packageType || process.env?.NODE_ENV?.startsWith("development-"));
if (addVisio) {
names.push('Visio');
@ -190,39 +190,39 @@ function discovery(req, res) {
documentTypes.push(`diagram`);
}
let templatesFolderExtsCache = yield getTemplatesFolderExts(ctx);
let formsExts = tenWopiForms.reduce((result, item, index, array) => {
const templatesFolderExtsCache = yield getTemplatesFolderExts(ctx);
const formsExts = tenWopiForms.reduce((result, item, index, array) => {
result[item] = item;
return result;
}, {});
let templateStart = `${baseUrl}/hosting/wopi`;
const templateStart = `${baseUrl}/hosting/wopi`;
let templateEnd = `&lt;rs=DC_LLCC&amp;&gt;&lt;dchat=DISABLE_CHAT&amp;&gt;&lt;embed=EMBEDDED&amp;&gt;`;
templateEnd += `&lt;fs=FULLSCREEN&amp;&gt;&lt;hid=HOST_SESSION_ID&amp;&gt;&lt;rec=RECORDING&amp;&gt;`;
templateEnd += `&lt;sc=SESSION_CONTEXT&amp;&gt;&lt;thm=THEME_ID&amp;&gt;&lt;ui=UI_LLCC&amp;&gt;`;
templateEnd += `&lt;wopisrc=WOPI_SOURCE&amp;&gt;&amp;`;
let xmlZone = xml.ele('wopi-discovery').ele('net-zone', { name: tenWopiWopiZone });
const xmlZone = xml.ele('wopi-discovery').ele('net-zone', { name: tenWopiWopiZone });
//start section for MS WOPI connectors
for(let i = 0; i < names.length; ++i) {
let name = names[i];
const name = names[i];
let favIconUrl = favIconUrls[i];
if (!(favIconUrl.startsWith('http://') || favIconUrl.startsWith('https://'))) {
favIconUrl = baseUrl + favIconUrl;
}
let ext = exts[i];
let urlTemplateView = `${templateStart}/${documentTypes[i]}/view?${templateEnd}`;
let urlTemplateEmbedView = `${templateStart}/${documentTypes[i]}/view?embed=1&amp;${templateEnd}`;
let urlTemplateMobileView = `${templateStart}/${documentTypes[i]}/view?mobile=1&amp;${templateEnd}`;
let urlTemplateEdit = `${templateStart}/${documentTypes[i]}/edit?${templateEnd}`;
let urlTemplateMobileEdit = `${templateStart}/${documentTypes[i]}/edit?mobile=1&amp;${templateEnd}`;
let urlTemplateFormSubmit = `${templateStart}/${documentTypes[i]}/edit?formsubmit=1&amp;${templateEnd}`;
let xmlApp = xmlZone.ele('app', {name: name, favIconUrl: favIconUrl});
const ext = exts[i];
const urlTemplateView = `${templateStart}/${documentTypes[i]}/view?${templateEnd}`;
const urlTemplateEmbedView = `${templateStart}/${documentTypes[i]}/view?embed=1&amp;${templateEnd}`;
const urlTemplateMobileView = `${templateStart}/${documentTypes[i]}/view?mobile=1&amp;${templateEnd}`;
const urlTemplateEdit = `${templateStart}/${documentTypes[i]}/edit?${templateEnd}`;
const urlTemplateMobileEdit = `${templateStart}/${documentTypes[i]}/edit?mobile=1&amp;${templateEnd}`;
const urlTemplateFormSubmit = `${templateStart}/${documentTypes[i]}/edit?formsubmit=1&amp;${templateEnd}`;
const xmlApp = xmlZone.ele('app', {name, favIconUrl});
for (let j = 0; j < ext.view.length; ++j) {
xmlApp.ele('action', {name: 'view', ext: ext.view[j], default: 'true', urlsrc: urlTemplateView}).up();
xmlApp.ele('action', {name: 'embedview', ext: ext.view[j], urlsrc: urlTemplateEmbedView}).up();
xmlApp.ele('action', {name: 'mobileView', ext: ext.view[j], urlsrc: urlTemplateMobileView}).up();
if (ext.targetext) {
let urlConvert = `${templateStart}/convert-and-edit/${ext.view[j]}/${ext.targetext}?${templateEnd}`;
const urlConvert = `${templateStart}/convert-and-edit/${ext.view[j]}/${ext.targetext}?${templateEnd}`;
xmlApp.ele('action', {name: 'convert', ext: ext.view[j], targetext: ext.targetext, requires: 'update', urlsrc: urlConvert}).up();
}
}
@ -246,16 +246,16 @@ function discovery(req, res) {
//end section for MS WOPI connectors
//start section for collabora nexcloud connectors
for(let i = 0; i < exts.length; ++i) {
let ext = exts[i];
let urlTemplateView = `${templateStart}/${documentTypes[i]}/view?${templateEnd}`;
let urlTemplateEmbedView = `${templateStart}/${documentTypes[i]}/view?embed=1&amp;${templateEnd}`;
let urlTemplateMobileView = `${templateStart}/${documentTypes[i]}/view?mobile=1&amp;${templateEnd}`;
let urlTemplateEdit = `${templateStart}/${documentTypes[i]}/edit?${templateEnd}`;
let urlTemplateMobileEdit = `${templateStart}/${documentTypes[i]}/edit?mobile=1&amp;${templateEnd}`;
let urlTemplateFormSubmit = `${templateStart}/${documentTypes[i]}/edit?formsubmit=1&amp;${templateEnd}`;
let mimeTypesDuplicate = new Set();//to remove duplicates for each editor(allow html for word and excel)
const ext = exts[i];
const urlTemplateView = `${templateStart}/${documentTypes[i]}/view?${templateEnd}`;
const urlTemplateEmbedView = `${templateStart}/${documentTypes[i]}/view?embed=1&amp;${templateEnd}`;
const urlTemplateMobileView = `${templateStart}/${documentTypes[i]}/view?mobile=1&amp;${templateEnd}`;
const urlTemplateEdit = `${templateStart}/${documentTypes[i]}/edit?${templateEnd}`;
const urlTemplateMobileEdit = `${templateStart}/${documentTypes[i]}/edit?mobile=1&amp;${templateEnd}`;
const urlTemplateFormSubmit = `${templateStart}/${documentTypes[i]}/edit?formsubmit=1&amp;${templateEnd}`;
const mimeTypesDuplicate = new Set();//to remove duplicates for each editor(allow html for word and excel)
for (let j = 0; j < ext.view.length; ++j) {
let mimeTypes = mimeTypesByExt[ext.view[j]];
const mimeTypes = mimeTypesByExt[ext.view[j]];
if (mimeTypes) {
mimeTypes.forEach((value) => {
if (mimeTypesDuplicate.has(value)) {
@ -263,12 +263,12 @@ function discovery(req, res) {
} else {
mimeTypesDuplicate.add(value);
}
let xmlApp = xmlZone.ele('app', {name: value});
const xmlApp = xmlZone.ele('app', {name: value});
xmlApp.ele('action', {name: 'view', ext: '', default: 'true', urlsrc: urlTemplateView}).up();
xmlApp.ele('action', {name: 'embedview', ext: '', urlsrc: urlTemplateEmbedView}).up();
xmlApp.ele('action', {name: 'mobileView', ext: '', urlsrc: urlTemplateMobileView}).up();
if (ext.targetext) {
let urlConvert = `${templateStart}/convert-and-edit/${ext.view[j]}/${ext.targetext}?${templateEnd}`;
const urlConvert = `${templateStart}/convert-and-edit/${ext.view[j]}/${ext.targetext}?${templateEnd}`;
xmlApp.ele('action', {name: 'convert', ext: '', targetext: ext.targetext, requires: 'update', urlsrc: urlConvert}).up();
}
xmlApp.up();
@ -277,7 +277,7 @@ function discovery(req, res) {
}
mimeTypesDuplicate.clear();
for (let j = 0; j < ext.edit.length; ++j) {
let mimeTypes = mimeTypesByExt[ext.edit[j]];
const mimeTypes = mimeTypesByExt[ext.edit[j]];
if (mimeTypes) {
mimeTypes.forEach((value) => {
if (mimeTypesDuplicate.has(value)) {
@ -285,7 +285,7 @@ function discovery(req, res) {
} else {
mimeTypesDuplicate.add(value);
}
let xmlApp = xmlZone.ele('app', {name: value});
const xmlApp = xmlZone.ele('app', {name: value});
if (formsExts[ext.edit[j]]) {
xmlApp.ele('action', {name: 'edit', ext: '', default: 'true', requires: 'locks,update', urlsrc: urlTemplateEdit}).up();
xmlApp.ele('action', {name: 'formsubmit', ext: '', requires: 'locks,update', urlsrc: urlTemplateFormSubmit}).up();
@ -301,17 +301,17 @@ function discovery(req, res) {
}
}
}
let xmlApp = xmlZone.ele('app', {name: 'Capabilities'});
const xmlApp = xmlZone.ele('app', {name: 'Capabilities'});
xmlApp.ele('action', {ext: '', name: 'getinfo', requires: 'locks,update', urlsrc: `${baseUrl}/hosting/capabilities`}).up();
xmlApp.up();
//end section for collabora nexcloud connectors
let xmlDiscovery = xmlZone.up();
const xmlDiscovery = xmlZone.up();
if (tenWopiPublicKeyOld && tenWopiPublicKey) {
let exponent = numberToBase64(tenWopiExponent);
let exponentOld = numberToBase64(tenWopiExponentOld);
const exponent = numberToBase64(tenWopiExponent);
const exponentOld = numberToBase64(tenWopiExponentOld);
xmlDiscovery.ele('proof-key', {
oldvalue: tenWopiPublicKeyOld, oldmodulus: tenWopiModulusOld, oldexponent: exponentOld,
value: tenWopiPublicKey, modulus: tenWopiModulus, exponent: exponent
value: tenWopiPublicKey, modulus: tenWopiModulus, exponent
}).up();
}
xmlDiscovery.up();
@ -326,11 +326,11 @@ function discovery(req, res) {
}
function collaboraCapabilities(req, res) {
return co(function*() {
let output = {
const output = {
"convert-to": {"available": true, "endpoint":"/lool/convert-to"}, "hasMobileSupport": true, "hasProxyPrefix": false, "hasTemplateSaveAs": false,
"hasTemplateSource": true, "productVersion": commonDefines.buildVersion
};
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
ctx.initFromRequest(req);
yield ctx.initTenantCache();
@ -351,7 +351,7 @@ function isWopiUnlockMarker(url) {
}
function isWopiModifiedMarker(url) {
if (isWopiCallback(url)) {
let obj = JSON.parse(url);
const obj = JSON.parse(url);
return obj.fileInfo && obj.fileInfo.LastModifiedTime
}
}
@ -378,8 +378,8 @@ function setIsShutdown(val) {
}
function getLastModifiedTimeFromCallbacks(callbacks) {
for (let i = callbacks.length; i >= 0; --i) {
let callback = callbacks[i];
let lastModifiedTime = isWopiModifiedMarker(callback);
const callback = callbacks[i];
const lastModifiedTime = isWopiModifiedMarker(callback);
if (lastModifiedTime) {
return lastModifiedTime;
}
@ -398,13 +398,13 @@ function parseWopiCallback(ctx, userAuthStr, opt_url) {
let commonInfo = null;
let lastModifiedTime = null;
if (opt_url) {
let commonInfoStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, opt_url, 1);
const commonInfoStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, opt_url, 1);
if (isWopiCallback(commonInfoStr)) {
commonInfo = JSON.parse(commonInfoStr);
if (commonInfo.fileInfo) {
lastModifiedTime = commonInfo.fileInfo.LastModifiedTime;
if (lastModifiedTime) {
let callbacks = sqlBase.UserCallback.prototype.getCallbacks(ctx, opt_url);
const callbacks = sqlBase.UserCallback.prototype.getCallbacks(ctx, opt_url);
lastModifiedTime = getLastModifiedTimeFromCallbacks(callbacks);
}
} else {
@ -412,34 +412,34 @@ function parseWopiCallback(ctx, userAuthStr, opt_url) {
}
}
}
wopiParams = {commonInfo: commonInfo, userAuth: userAuth, LastModifiedTime: lastModifiedTime};
wopiParams = {commonInfo, userAuth, LastModifiedTime: lastModifiedTime};
ctx.logger.debug('parseWopiCallback wopiParams:%j', wopiParams);
}
return wopiParams;
}
function checkAndInvalidateCache(ctx, docId, fileInfo) {
return co(function*() {
let res = {success: true, lockId: undefined};
let selectRes = yield taskResult.select(ctx, docId);
const res = {success: true, lockId: undefined};
const selectRes = yield taskResult.select(ctx, docId);
if (selectRes.length > 0) {
let row = selectRes[0];
const row = selectRes[0];
if (row.callback) {
let commonInfoStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback, 1);
const commonInfoStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback, 1);
if (isWopiCallback(commonInfoStr)) {
let commonInfo = JSON.parse(commonInfoStr);
const commonInfo = JSON.parse(commonInfoStr);
res.lockId = commonInfo.lockId;
ctx.logger.debug('wopiEditor lockId from DB lockId=%s', res.lockId);
let unlockMarkStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback);
const unlockMarkStr = sqlBase.UserCallback.prototype.getCallbackByUserIndex(ctx, row.callback);
ctx.logger.debug('wopiEditor commonInfoStr=%s', commonInfoStr);
ctx.logger.debug('wopiEditor unlockMarkStr=%s', unlockMarkStr);
let hasUnlockMarker = isWopiUnlockMarker(unlockMarkStr);
let isUpdateVersion = commonDefines.FileStatus.UpdateVersion === row.status;
const hasUnlockMarker = isWopiUnlockMarker(unlockMarkStr);
const isUpdateVersion = commonDefines.FileStatus.UpdateVersion === row.status;
ctx.logger.debug('wopiEditor hasUnlockMarker=%s isUpdateVersion=%s', hasUnlockMarker, isUpdateVersion);
if (hasUnlockMarker || isUpdateVersion) {
let fileInfoVersion = fileInfo.Version;
let cacheVersion = commonInfo.fileInfo.Version;
let fileInfoModified = fileInfo.LastModifiedTime;
let cacheModified = commonInfo.fileInfo.LastModifiedTime;
const fileInfoVersion = fileInfo.Version;
const cacheVersion = commonInfo.fileInfo.Version;
const fileInfoModified = fileInfo.LastModifiedTime;
const cacheModified = commonInfo.fileInfo.LastModifiedTime;
ctx.logger.debug('wopiEditor version fileInfo=%s; cache=%s', fileInfoVersion, cacheVersion);
ctx.logger.debug('wopiEditor LastModifiedTime fileInfo=%s; cache=%s', fileInfoModified, cacheModified);
if (fileInfoVersion !== cacheVersion || (fileInfoModified !== cacheModified)) {
@ -448,7 +448,7 @@ function checkAndInvalidateCache(ctx, docId, fileInfo) {
mask.key = docId;
mask.last_open_date = row.last_open_date;
//cleanupRes can be false in case of simultaneous opening. it is OK
let cleanupRes = yield canvasService.cleanupCacheIf(ctx, mask);
const cleanupRes = yield canvasService.cleanupCacheIf(ctx, mask);
ctx.logger.debug('wopiEditor cleanupRes=%s', cleanupRes);
res.lockId = undefined;
}
@ -502,11 +502,11 @@ async function checkAndReplaceEmptyFile(ctx, fileInfo, wopiSrc, access_token, ac
const templateFileInfo = templateFilesSizeCache[filePath];
const templateFileStream = createReadStream(filePath);
let postRes = await putFile(ctx, wopiParams, undefined, templateFileStream, templateFileInfo.size, fileInfo.UserId, false, false, false);
const postRes = await putFile(ctx, wopiParams, undefined, templateFileStream, templateFileInfo.size, fileInfo.UserId, false, false, false);
if (postRes) {
//update Size
fileInfo.Size = templateFileInfo.size;
let body = parsePutFileResponse(ctx, postRes);
const body = parsePutFileResponse(ctx, postRes);
//collabora nexcloud connector
if (body?.LastModifiedTime) {
//update LastModifiedTime
@ -516,7 +516,7 @@ async function checkAndReplaceEmptyFile(ctx, fileInfo, wopiSrc, access_token, ac
}
}
function createDocId(ctx, wopiSrc, mode, fileInfo) {
let fileId = wopiSrc.substring(wopiSrc.lastIndexOf('/') + 1);
const fileId = wopiSrc.substring(wopiSrc.lastIndexOf('/') + 1);
let docId = undefined;
if ('view' !== mode) {
docId = `${fileId}`;
@ -539,20 +539,20 @@ async function preOpen(ctx, lockId, docId, fileInfo, userAuth, baseUrl, fileType
if (undefined === lockId) {
//Use deterministic(not random) lockId to fix issues with forgotten openings due to integrator failures
lockId = docId;
let commonInfo = JSON.stringify({lockId: lockId, fileInfo: fileInfo});
const commonInfo = JSON.stringify({lockId, fileInfo});
await canvasService.commandOpenStartPromise(ctx, docId, baseUrl, commonInfo, fileType);
}
//Lock
if ('view' !== userAuth.mode) {
let lockRes = await lock(ctx, 'LOCK', lockId, fileInfo, userAuth);
const lockRes = await lock(ctx, 'LOCK', lockId, fileInfo, userAuth);
return !!lockRes;
}
return true;
}
function getEditorHtml(req, res) {
return co(function*() {
let params = {key: undefined, apiQuery: '', fileInfo: {}, userAuth: {}, queryParams: req.query, token: undefined, documentType: undefined, docs_api_config: {}};
let ctx = new operationContext.Context();
const params = {key: undefined, apiQuery: '', fileInfo: {}, userAuth: {}, queryParams: req.query, token: undefined, documentType: undefined, docs_api_config: {}};
const ctx = new operationContext.Context();
try {
ctx.initFromRequest(req);
yield ctx.initTenantCache();
@ -561,8 +561,8 @@ function getEditorHtml(req, res) {
const tenTokenOutboxExpires = ctx.getCfg('services.CoAuthoring.token.outbox.expires', cfgTokenOutboxExpires);
const tenWopiFileInfoBlockList = ctx.getCfg('wopi.fileInfoBlockList', cfgWopiFileInfoBlockList);
let wopiSrc = req.query['wopisrc'];
let fileId = wopiSrc.substring(wopiSrc.lastIndexOf('/') + 1);
const wopiSrc = req.query['wopisrc'];
const fileId = wopiSrc.substring(wopiSrc.lastIndexOf('/') + 1);
ctx.setDocId(fileId);
ctx.logger.info('wopiEditor start');
@ -572,19 +572,19 @@ function getEditorHtml(req, res) {
params.apiQuery = `?${constants.SHARD_KEY_WOPI_NAME}=${encodeURIComponent(wopiSrc)}`;
params.documentType = req.params.documentType;
let mode = req.params.mode;
let sc = req.query['sc'];
let hostSessionId = req.query['hid'];
let lang = req.query['lang'];
let ui = req.query['ui'];
let access_token = req.body['access_token'] || "";
let access_token_ttl = parseInt(req.body['access_token_ttl']) || 0;
let docs_api_config = req.body['docs_api_config'];
const sc = req.query['sc'];
const hostSessionId = req.query['hid'];
const lang = req.query['lang'];
const ui = req.query['ui'];
const access_token = req.body['access_token'] || "";
const access_token_ttl = parseInt(req.body['access_token_ttl']) || 0;
const docs_api_config = req.body['docs_api_config'];
if (docs_api_config) {
params.docs_api_config = JSON.parse(docs_api_config);
}
let fileInfo = params.fileInfo = yield checkFileInfo(ctx, wopiSrc, access_token, sc);
const fileInfo = params.fileInfo = yield checkFileInfo(ctx, wopiSrc, access_token, sc);
if (!fileInfo) {
params.fileInfo = {};
return;
@ -599,23 +599,23 @@ function getEditorHtml(req, res) {
mode = 'view';
}
//docId
let docId = createDocId(ctx, wopiSrc, mode, fileInfo);
const docId = createDocId(ctx, wopiSrc, mode, fileInfo);
ctx.setDocId(fileId);
ctx.logger.debug(`wopiEditor`);
params.key = docId;
let userAuth = params.userAuth = {
wopiSrc: wopiSrc, access_token: access_token, access_token_ttl: access_token_ttl,
hostSessionId: hostSessionId, userSessionId: docId, mode: mode
const userAuth = params.userAuth = {
wopiSrc, access_token, access_token_ttl,
hostSessionId, userSessionId: docId, mode
};
//check and invalidate cache
let checkRes = yield checkAndInvalidateCache(ctx, docId, fileInfo);
const checkRes = yield checkAndInvalidateCache(ctx, docId, fileInfo);
if (!checkRes.success) {
params.fileInfo = {};
return;
}
if (!shutdownFlag) {
let preOpenRes = yield preOpen(ctx, checkRes.lockId, docId, fileInfo, userAuth, utils.getBaseUrlByRequest(ctx, req), fileType);
const preOpenRes = yield preOpen(ctx, checkRes.lockId, docId, fileInfo, userAuth, utils.getBaseUrlByRequest(ctx, req), fileType);
if (!preOpenRes) {
params.fileInfo = {};
return;
@ -627,8 +627,8 @@ function getEditorHtml(req, res) {
});
if (tenTokenEnableBrowser) {
let options = {algorithm: tenTokenOutboxAlgorithm, expiresIn: tenTokenOutboxExpires};
let secret = yield tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Browser);
const options = {algorithm: tenTokenOutboxAlgorithm, expiresIn: tenTokenOutboxExpires};
const secret = yield tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Browser);
params.token = jwt.sign(params, secret, options);
}
} catch (err) {
@ -648,8 +648,8 @@ function getEditorHtml(req, res) {
}
function getConverterHtml(req, res) {
return co(function*() {
let params = {statusHandler: undefined};
let ctx = new operationContext.Context();
const params = {statusHandler: undefined};
const ctx = new operationContext.Context();
try {
ctx.initFromRequest(req);
yield ctx.initTenantCache();
@ -658,40 +658,40 @@ function getConverterHtml(req, res) {
const tenTokenOutboxExpires = ctx.getCfg('services.CoAuthoring.token.outbox.expires', cfgTokenOutboxExpires);
const tenWopiHost = ctx.getCfg('wopi.host', cfgWopiHost);
let wopiSrc = req.query['wopisrc'];
let fileId = wopiSrc.substring(wopiSrc.lastIndexOf('/') + 1);
const wopiSrc = req.query['wopisrc'];
const fileId = wopiSrc.substring(wopiSrc.lastIndexOf('/') + 1);
ctx.setDocId(fileId);
ctx.logger.info('convert-and-edit start');
let access_token = req.body['access_token'] || "";
let access_token_ttl = parseInt(req.body['access_token_ttl']) || 0;
let ext = req.params.ext;
let targetext = req.params.targetext;
const access_token = req.body['access_token'] || "";
const access_token_ttl = parseInt(req.body['access_token_ttl']) || 0;
const ext = req.params.ext;
const targetext = req.params.targetext;
if (!(wopiSrc && access_token && access_token_ttl && ext && targetext)) {
ctx.logger.debug('convert-and-edit invalid params: WOPISrc=%s; access_token=%s; access_token_ttl=%s; ext=%s; targetext=%s', wopiSrc, access_token, access_token_ttl, ext, targetext);
return;
}
let fileInfo = yield checkFileInfo(ctx, wopiSrc, access_token);
const fileInfo = yield checkFileInfo(ctx, wopiSrc, access_token);
if (!fileInfo) {
ctx.logger.info('convert-and-edit checkFileInfo error');
return;
}
let wopiParams = getWopiParams(undefined, fileInfo, wopiSrc, access_token, access_token_ttl);
const wopiParams = getWopiParams(undefined, fileInfo, wopiSrc, access_token, access_token_ttl);
let docId = yield converterService.convertAndEdit(ctx, wopiParams, ext, targetext);
const docId = yield converterService.convertAndEdit(ctx, wopiParams, ext, targetext);
if (docId) {
let baseUrl = tenWopiHost || utils.getBaseUrlByRequest(ctx, req);
const baseUrl = tenWopiHost || utils.getBaseUrlByRequest(ctx, req);
params.statusHandler = `${baseUrl}/hosting/wopi/convert-and-edit-handler`;
params.statusHandler += `?${constants.SHARD_KEY_WOPI_NAME}=${encodeURIComponent(wopiSrc)}&access_token=${encodeURIComponent(access_token)}`;
params.statusHandler += `&targetext=${encodeURIComponent(targetext)}&docId=${encodeURIComponent(docId)}`;
if (tenTokenEnableBrowser) {
let tokenData = {docId: docId};
let options = {algorithm: tenTokenOutboxAlgorithm, expiresIn: tenTokenOutboxExpires};
let secret = yield tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Browser);
let token = jwt.sign(tokenData, secret, options);
const tokenData = {docId};
const options = {algorithm: tenTokenOutboxAlgorithm, expiresIn: tenTokenOutboxExpires};
const secret = yield tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Browser);
const token = jwt.sign(tokenData, secret, options);
params.statusHandler += `&token=${encodeURIComponent(token)}`;
}
@ -720,10 +720,10 @@ function putFile(ctx, wopiParams, data, dataStream, dataSize, userLastChangeId,
if (!wopiParams.userAuth || !wopiParams.commonInfo) {
return postRes;
}
let fileInfo = wopiParams.commonInfo.fileInfo;
let userAuth = wopiParams.userAuth;
let uri = `${userAuth.wopiSrc}/contents?access_token=${encodeURIComponent(userAuth.access_token)}`;
let filterStatus = yield checkIpFilter(ctx, uri);
const fileInfo = wopiParams.commonInfo.fileInfo;
const userAuth = wopiParams.userAuth;
const uri = `${userAuth.wopiSrc}/contents?access_token=${encodeURIComponent(userAuth.access_token)}`;
const filterStatus = yield checkIpFilter(ctx, uri);
if (0 !== filterStatus) {
return postRes;
}
@ -731,9 +731,9 @@ function putFile(ctx, wopiParams, data, dataStream, dataSize, userLastChangeId,
//collabora nexcloud connector sets only UserCanWrite=true
const canEdit = (fileInfo.UserCanOnlyComment || fileInfo.UserCanWrite || fileInfo.UserCanReview);
if (fileInfo && (fileInfo.SupportsUpdate || canEdit)) {
let commonInfo = wopiParams.commonInfo;
const commonInfo = wopiParams.commonInfo;
//todo add all the users who contributed changes to the document in this PutFile request to X-WOPI-Editors
let headers = {'X-WOPI-Override': 'PUT', 'X-WOPI-Lock': commonInfo.lockId, 'X-WOPI-Editors': userLastChangeId};
const headers = {'X-WOPI-Override': 'PUT', 'X-WOPI-Lock': commonInfo.lockId, 'X-WOPI-Editors': userLastChangeId};
yield wopiUtils.fillStandardHeaders(ctx, headers, uri, userAuth.access_token);
headers['X-LOOL-WOPI-IsModifiedByUser'] = isModifiedByUser;
headers['X-LOOL-WOPI-IsAutosave'] = isAutosave;
@ -746,7 +746,7 @@ function putFile(ctx, wopiParams, data, dataStream, dataSize, userLastChangeId,
ctx.logger.debug('wopi PutFile request uri=%s headers=%j', uri, headers);
//isInJwtToken is true because it passed checkIpFilter for wopi
let isInJwtToken = true;
const isInJwtToken = true;
postRes = yield utils.postRequestPromise(ctx, uri, data, dataStream, dataSize, tenCallbackRequestTimeout, undefined, isInJwtToken, headers);
ctx.logger.debug('wopi PutFile response headers=%j', postRes.response.headers);
ctx.logger.debug('wopi PutFile response body:%s', postRes.body);
@ -768,13 +768,13 @@ function putRelativeFile(ctx, wopiSrc, access_token, data, dataStream, dataSize,
ctx.logger.info('wopi putRelativeFile start');
const tenCallbackRequestTimeout = ctx.getCfg('services.CoAuthoring.server.callbackRequestTimeout', cfgCallbackRequestTimeout);
let uri = `${wopiSrc}?access_token=${encodeURIComponent(access_token)}`;
let filterStatus = yield checkIpFilter(ctx, uri);
const uri = `${wopiSrc}?access_token=${encodeURIComponent(access_token)}`;
const filterStatus = yield checkIpFilter(ctx, uri);
if (0 !== filterStatus) {
return res;
}
let headers = {'X-WOPI-Override': 'PUT_RELATIVE', 'X-WOPI-SuggestedTarget': utf7.encode(suggestedTarget || suggestedExt)};
const headers = {'X-WOPI-Override': 'PUT_RELATIVE', 'X-WOPI-SuggestedTarget': utf7.encode(suggestedTarget || suggestedExt)};
if (isFileConversion) {
headers['X-WOPI-FileConversion'] = isFileConversion;
}
@ -783,8 +783,8 @@ function putRelativeFile(ctx, wopiSrc, access_token, data, dataStream, dataSize,
ctx.logger.debug('wopi putRelativeFile request uri=%s headers=%j', uri, headers);
//isInJwtToken is true because it passed checkIpFilter for wopi
let isInJwtToken = true;
let postRes = yield utils.postRequestPromise(ctx, uri, data, dataStream, dataSize, tenCallbackRequestTimeout, undefined, isInJwtToken, headers);
const isInJwtToken = true;
const postRes = yield utils.postRequestPromise(ctx, uri, data, dataStream, dataSize, tenCallbackRequestTimeout, undefined, isInJwtToken, headers);
ctx.logger.debug('wopi putRelativeFile response headers=%j', postRes.response.headers);
ctx.logger.debug('wopi putRelativeFile response body:%s', postRes.body);
res = JSON.parse(postRes.body);
@ -854,7 +854,7 @@ async function refreshFile(ctx, wopiParams, baseUrl) {
let res = {};
try {
ctx.logger.info('wopi RefreshFile start');
let userAuth = wopiParams.userAuth;
const userAuth = wopiParams.userAuth;
if (!userAuth) {
return;
}
@ -870,16 +870,16 @@ async function refreshFile(ctx, wopiParams, baseUrl) {
res.fileInfo = fileInfo;
res.queryParams = undefined;
if (tenTokenEnableBrowser) {
let options = {algorithm: tenTokenOutboxAlgorithm, expiresIn: tenTokenOutboxExpires};
let secret = await tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Browser);
const options = {algorithm: tenTokenOutboxAlgorithm, expiresIn: tenTokenOutboxExpires};
const secret = await tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Browser);
res.token = jwt.sign(res, secret, options);
}
let checkRes = await checkAndInvalidateCache(ctx, docId, fileInfo);
const checkRes = await checkAndInvalidateCache(ctx, docId, fileInfo);
if (!checkRes.success) {
res = {};
return;
}
let preOpenRes = await preOpen(ctx, checkRes.lockId, docId, fileInfo, userAuth, baseUrl, fileType);
const preOpenRes = await preOpen(ctx, checkRes.lockId, docId, fileInfo, userAuth, baseUrl, fileType);
if (!preOpenRes) {
res = {};
}
@ -897,20 +897,20 @@ function checkFileInfo(ctx, wopiSrc, access_token, opt_sc) {
ctx.logger.info('wopi checkFileInfo start');
const tenDownloadTimeout = ctx.getCfg('FileConverter.converter.downloadTimeout', cfgDownloadTimeout);
let uri = `${wopiSrc}?access_token=${encodeURIComponent(access_token)}`;
let filterStatus = yield checkIpFilter(ctx, uri);
const uri = `${wopiSrc}?access_token=${encodeURIComponent(access_token)}`;
const filterStatus = yield checkIpFilter(ctx, uri);
if (0 !== filterStatus) {
return fileInfo;
}
let headers = {};
const headers = {};
if (opt_sc) {
headers['X-WOPI-SessionContext'] = opt_sc;
}
yield wopiUtils.fillStandardHeaders(ctx, headers, uri, access_token);
ctx.logger.debug('wopi checkFileInfo request uri=%s headers=%j', uri, headers);
//isInJwtToken is true because it passed checkIpFilter for wopi
let isInJwtToken = true;
let getRes = yield utils.downloadUrlPromise(ctx, uri, tenDownloadTimeout, undefined, undefined, isInJwtToken, headers);
const isInJwtToken = true;
const getRes = yield utils.downloadUrlPromise(ctx, uri, tenDownloadTimeout, undefined, undefined, isInJwtToken, headers);
ctx.logger.debug(`wopi checkFileInfo headers=%j body=%s`, getRes.response.headers, getRes.body);
fileInfo = JSON.parse(getRes.body);
} catch (err) {
@ -932,20 +932,20 @@ function lock(ctx, command, lockId, fileInfo, userAuth) {
if (!userAuth) {
return false;
}
let wopiSrc = userAuth.wopiSrc;
let access_token = userAuth.access_token;
let uri = `${wopiSrc}?access_token=${encodeURIComponent(access_token)}`;
let filterStatus = yield checkIpFilter(ctx, uri);
const wopiSrc = userAuth.wopiSrc;
const access_token = userAuth.access_token;
const uri = `${wopiSrc}?access_token=${encodeURIComponent(access_token)}`;
const filterStatus = yield checkIpFilter(ctx, uri);
if (0 !== filterStatus) {
return false;
}
let headers = {"X-WOPI-Override": command, "X-WOPI-Lock": lockId};
const headers = {"X-WOPI-Override": command, "X-WOPI-Lock": lockId};
yield wopiUtils.fillStandardHeaders(ctx, headers, uri, access_token);
ctx.logger.debug('wopi %s request uri=%s headers=%j', command, uri, headers);
//isInJwtToken is true because it passed checkIpFilter for wopi
let isInJwtToken = true;
let postRes = yield utils.postRequestPromise(ctx, uri, undefined, undefined, undefined, tenCallbackRequestTimeout, undefined, isInJwtToken, headers);
const isInJwtToken = true;
const postRes = yield utils.postRequestPromise(ctx, uri, undefined, undefined, undefined, tenCallbackRequestTimeout, undefined, isInJwtToken, headers);
ctx.logger.debug('wopi %s response headers=%j', command, postRes.response.headers);
} else {
ctx.logger.info('wopi %s SupportsLocks = false', command);
@ -968,23 +968,23 @@ async function unlock(ctx, wopiParams) {
if (!wopiParams.userAuth || !wopiParams.commonInfo) {
return;
}
let fileInfo = wopiParams.commonInfo.fileInfo;
const fileInfo = wopiParams.commonInfo.fileInfo;
if (fileInfo && fileInfo.SupportsLocks) {
let wopiSrc = wopiParams.userAuth.wopiSrc;
let lockId = wopiParams.commonInfo.lockId;
let access_token = wopiParams.userAuth.access_token;
let uri = `${wopiSrc}?access_token=${encodeURIComponent(access_token)}`;
let filterStatus = await checkIpFilter(ctx, uri);
const wopiSrc = wopiParams.userAuth.wopiSrc;
const lockId = wopiParams.commonInfo.lockId;
const access_token = wopiParams.userAuth.access_token;
const uri = `${wopiSrc}?access_token=${encodeURIComponent(access_token)}`;
const filterStatus = await checkIpFilter(ctx, uri);
if (0 !== filterStatus) {
return;
}
let headers = {"X-WOPI-Override": "UNLOCK", "X-WOPI-Lock": lockId};
const headers = {"X-WOPI-Override": "UNLOCK", "X-WOPI-Lock": lockId};
await wopiUtils.fillStandardHeaders(ctx, headers, uri, access_token);
ctx.logger.debug('wopi Unlock request uri=%s headers=%j', uri, headers);
//isInJwtToken is true because it passed checkIpFilter for wopi
let isInJwtToken = true;
let postRes = await utils.postRequestPromise(ctx, uri, undefined, undefined, undefined, tenCallbackRequestTimeout, undefined, isInJwtToken, headers);
const isInJwtToken = true;
const postRes = await utils.postRequestPromise(ctx, uri, undefined, undefined, undefined, tenCallbackRequestTimeout, undefined, isInJwtToken, headers);
ctx.logger.debug('wopi Unlock response headers=%j', postRes.response.headers);
} else {
ctx.logger.info('wopi SupportsLocks = false');
@ -1012,8 +1012,8 @@ function numberToBase64(val) {
function checkIpFilter(ctx, uri){
return co(function* () {
let urlParsed = new URL(uri);
let filterStatus = yield* utils.checkHostFilter(ctx, urlParsed.hostname);
const urlParsed = new URL(uri);
const filterStatus = yield* utils.checkHostFilter(ctx, urlParsed.hostname);
if (0 !== filterStatus) {
ctx.logger.warn('wopi checkIpFilter error: url = %s', uri);
}
@ -1021,12 +1021,12 @@ function checkIpFilter(ctx, uri){
});
}
function getWopiParams(lockId, fileInfo, wopiSrc, access_token, access_token_ttl) {
let commonInfo = {lockId: lockId, fileInfo: fileInfo};
let userAuth = {
wopiSrc: wopiSrc, access_token: access_token, access_token_ttl: access_token_ttl,
const commonInfo = {lockId, fileInfo};
const userAuth = {
wopiSrc, access_token, access_token_ttl,
hostSessionId: null, userSessionId: null, mode: null
};
return {commonInfo: commonInfo, userAuth: userAuth, LastModifiedTime: null};
return {commonInfo, userAuth, LastModifiedTime: null};
}
async function dummyCheckFileInfo(req, res) {
@ -1046,14 +1046,14 @@ async function dummyCheckFileInfo(req, res) {
});
} else {
let fileInfo;
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
ctx.initFromRequest(req);
try {
await ctx.initTenantCache();
const tenWopiDummySampleFilePath = ctx.getCfg('wopi.dummy.sampleFilePath', cfgWopiDummySampleFilePath);
let access_token = req.query['access_token'];
const access_token = req.query['access_token'];
ctx.logger.debug('dummyCheckFileInfo access_token:%s', access_token);
let sampleFileStat = await stat(tenWopiDummySampleFilePath);
const sampleFileStat = await stat(tenWopiDummySampleFilePath);
fileInfo = JSON.parse(Buffer.from(access_token, 'base64').toString('ascii'));
fileInfo.BaseFileName = path.basename(tenWopiDummySampleFilePath);
@ -1071,13 +1071,13 @@ async function dummyCheckFileInfo(req, res) {
}
async function dummyGetFile(req, res) {
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
ctx.initFromRequest(req);
try {
await ctx.initTenantCache();
const tenWopiDummySampleFilePath = ctx.getCfg('wopi.dummy.sampleFilePath', cfgWopiDummySampleFilePath);
let sampleFileStat = await stat(tenWopiDummySampleFilePath);
const sampleFileStat = await stat(tenWopiDummySampleFilePath);
res.setHeader('Content-Length', sampleFileStat.size);
res.setHeader('Content-Type', mime.getType(tenWopiDummySampleFilePath));

10
DocService/sources/wopiUtils.js
View File

@ -58,7 +58,7 @@ function generateProofBuffer(url, accessToken, timeStamp) {
const urlBytes = Buffer.from(url.toUpperCase(), 'utf8');
let offset = 0;
let buffer = Buffer.alloc(4 + accessTokenBytes.length + 4 + urlBytes.length + 4 + 8);
const buffer = Buffer.alloc(4 + accessTokenBytes.length + 4 + urlBytes.length + 4 + 8);
buffer.writeUInt32BE(accessTokenBytes.length, offset);
offset += 4;
accessTokenBytes.copy(buffer, offset, 0, accessTokenBytes.length);
@ -83,8 +83,8 @@ function generateProofBuffer(url, accessToken, timeStamp) {
* @returns {string} - The base64-encoded signature
*/
async function generateProofSign(url, accessToken, timeStamp, privateKey) {
let data = generateProofBuffer(url, accessToken, timeStamp);
let sign = await cryptoSign('RSA-SHA256', data, privateKey);
const data = generateProofBuffer(url, accessToken, timeStamp);
const sign = await cryptoSign('RSA-SHA256', data, privateKey);
return sign.toString('base64');
}
@ -97,7 +97,7 @@ async function generateProofSign(url, accessToken, timeStamp, privateKey) {
* @param {string} access_token - The access token
*/
async function fillStandardHeaders(ctx, headers, url, access_token) {
let timeStamp = utils.getDateTimeTicks(new Date());
const timeStamp = utils.getDateTimeTicks(new Date());
const tenWopiPrivateKey = ctx.getCfg('wopi.privateKey', cfgWopiPrivateKey);
const tenWopiPrivateKeyOld = ctx.getCfg('wopi.privateKeyOld', cfgWopiPrivateKeyOld);
if (tenWopiPrivateKey && tenWopiPrivateKeyOld) {
@ -124,7 +124,7 @@ async function fillStandardHeaders(ctx, headers, url, access_token) {
async function getWopiFileUrl(ctx, fileInfo, userAuth) {
const tenMaxDownloadBytes = ctx.getCfg('FileConverter.converter.maxDownloadBytes', cfgMaxDownloadBytes);
let url;
let headers = {'X-WOPI-MaxExpectedSize': tenMaxDownloadBytes};
const headers = {'X-WOPI-MaxExpectedSize': tenMaxDownloadBytes};
if (fileInfo?.FileUrl) {
//Requests to the FileUrl can not be signed using proof keys. The FileUrl is used exactly as provided by the host, so it does not necessarily include the access token, which is required to construct the expected proof.
url = fileInfo.FileUrl;

192
FileConverter/sources/converter.js
View File

@ -137,7 +137,7 @@ function TaskQueueDataConvert(ctx, task) {
this.timestamp = new Date();
}
TaskQueueDataConvert.prototype = {
serialize: function(ctx, fsPath) {
serialize(ctx, fsPath) {
let xml = '\ufeff<?xml version="1.0" encoding="utf-8"?>';
xml += '<TaskQueueDataConvert xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"';
xml += ' xmlns:xsd="http://www.w3.org/2001/XMLSchema">';
@ -174,18 +174,18 @@ TaskQueueDataConvert.prototype = {
xml += '</TaskQueueDataConvert>';
fs.writeFileSync(fsPath, xml, {encoding: 'utf8'});
},
serializeHidden: function(ctx) {
serializeHidden(ctx) {
var t = this;
return co(function* () {
let xml;
if (t.password || t.savePassword) {
xml = '<TaskQueueDataConvert>';
if(t.password) {
let password = yield utils.decryptPassword(ctx, t.password);
const password = yield utils.decryptPassword(ctx, t.password);
xml += t.serializeXmlProp('m_sPassword', password);
}
if(t.savePassword) {
let savePassword = yield utils.decryptPassword(ctx, t.savePassword);
const savePassword = yield utils.decryptPassword(ctx, t.savePassword);
xml += t.serializeXmlProp('m_sSavePassword', savePassword);
}
xml += '</TaskQueueDataConvert>';
@ -193,11 +193,11 @@ TaskQueueDataConvert.prototype = {
return xml;
});
},
serializeOptions: function (ctx, isInJwtToken, oformAsPdf) {
serializeOptions (ctx, isInJwtToken, oformAsPdf) {
const tenRequesFilteringAgent = ctx.getCfg('services.CoAuthoring.request-filtering-agent', cfgRequesFilteringAgent);
const tenExternalRequestDirectIfIn = ctx.getCfg('externalRequest.directIfIn', cfgExternalRequestDirectIfIn);
const tenExternalRequestAction = ctx.getCfg('externalRequest.action', cfgExternalRequestAction);
let allowList = tenExternalRequestDirectIfIn.allowList;
const allowList = tenExternalRequestDirectIfIn.allowList;
let allowNetworkRequest = tenExternalRequestAction.allow;
let allowPrivateIP = !tenExternalRequestAction.blockPrivateIP && tenRequesFilteringAgent.allowPrivateIPAddress;
let proxyUrl = tenExternalRequestAction.proxyUrl;
@ -221,12 +221,12 @@ TaskQueueDataConvert.prototype = {
xml += this.serializeXmlProp('proxy', proxyUrl);
}
if (proxyUser) {
let user = proxyUser.username;
let pass = proxyUser.password;
const user = proxyUser.username;
const pass = proxyUser.password;
xml += this.serializeXmlProp('proxyUser', `${user}:${pass}`);
}
let proxyHeadersStr= [];
for (let name in proxyHeaders) {
const proxyHeadersStr= [];
for (const name in proxyHeaders) {
proxyHeadersStr.push(`${name}:${proxyHeaders[name]}`);
}
if (proxyHeadersStr.length > 0) {
@ -238,7 +238,7 @@ TaskQueueDataConvert.prototype = {
xml += '</options>';
return xml;
},
serializeMailMerge: function(data) {
serializeMailMerge(data) {
var xml = '<m_oMailMergeSend>';
xml += this.serializeXmlProp('from', data.getFrom());
xml += this.serializeXmlProp('to', data.getTo());
@ -254,7 +254,7 @@ TaskQueueDataConvert.prototype = {
xml += '</m_oMailMergeSend>';
return xml;
},
serializeThumbnail: function(data) {
serializeThumbnail(data) {
var xml = '<m_oThumbnail>';
xml += this.serializeXmlProp('format', data.getFormat());
xml += this.serializeXmlProp('aspect', data.getAspect());
@ -264,18 +264,18 @@ TaskQueueDataConvert.prototype = {
xml += '</m_oThumbnail>';
return xml;
},
serializeTextParams: function(data) {
serializeTextParams(data) {
var xml = '<m_oTextParams>';
xml += this.serializeXmlProp('m_nTextAssociationType', data.getAssociation());
xml += '</m_oTextParams>';
return xml;
},
serializeLimit: function(ctx) {
serializeLimit(ctx) {
if (!inputLimitsXmlCache) {
var xml = '<m_oInputLimits>';
const tenInputLimits = ctx.getCfg('FileConverter.converter.inputLimits', cfgInputLimits);
for (let i = 0; i < tenInputLimits.length; ++i) {
let limit = tenInputLimits[i];
const limit = tenInputLimits[i];
if (limit.type && limit.zip) {
xml += '<m_oInputLimit';
xml += this.serializeXmlAttr('type', limit.type);
@ -297,7 +297,7 @@ TaskQueueDataConvert.prototype = {
}
return inputLimitsXmlCache;
},
serializeXmlProp: function(name, value) {
serializeXmlProp(name, value) {
var xml = '';
//todo check empty and undefined (password?)
if (null != value) {
@ -309,7 +309,7 @@ TaskQueueDataConvert.prototype = {
}
return xml;
},
serializeXmlAttr: function(name, value) {
serializeXmlAttr(name, value) {
var xml = '';
if (null != value) {
xml += ' ' + name + '=\"';
@ -339,8 +339,8 @@ function getTempDir() {
}
function* isUselessConvertion(ctx, task, cmd) {
if (task.getFromChanges() && 'sfc' === cmd.getCommand()) {
let selectRes = yield taskResult.select(ctx, cmd.getDocId());
let row = selectRes.length > 0 ? selectRes[0] : null;
const selectRes = yield taskResult.select(ctx, cmd.getDocId());
const row = selectRes.length > 0 ? selectRes[0] : null;
if (utils.isUselesSfc(row, cmd)) {
ctx.logger.warn('isUselessConvertion return true. row=%j', row);
return constants.CONVERT_PARAMS;
@ -349,14 +349,14 @@ function* isUselessConvertion(ctx, task, cmd) {
return constants.NO_ERROR;
}
async function changeFormatToExtendedPdf(ctx, dataConvert, cmd) {
let originFormat = cmd.getOriginFormat();
let isOriginFormatWithForms = constants.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF === originFormat ||
const originFormat = cmd.getOriginFormat();
const isOriginFormatWithForms = constants.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF === originFormat ||
constants.AVS_OFFICESTUDIO_FILE_DOCUMENT_OFORM === originFormat ||
constants.AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCXF === originFormat;
let isFormatToPdf = constants.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF === dataConvert.formatTo ||
const isFormatToPdf = constants.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF === dataConvert.formatTo ||
constants.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDFA === dataConvert.formatTo;
if (isFormatToPdf && isOriginFormatWithForms) {
let format = await formatChecker.getDocumentFormatByFile(dataConvert.fileFrom);
const format = await formatChecker.getDocumentFormatByFile(dataConvert.fileFrom);
if (constants.AVS_OFFICESTUDIO_FILE_CANVAS_WORD === format) {
ctx.logger.debug('change format to extended pdf');
dataConvert.formatTo = constants.AVS_OFFICESTUDIO_FILE_DOCUMENT_OFORM_PDF;
@ -378,12 +378,12 @@ function* replaceEmptyFile(ctx, fileFrom, ext, _lcid) {
}
}
}
let fileTemplatePath = path.join(tenNewFileTemplate, locale, 'new.');
const fileTemplatePath = path.join(tenNewFileTemplate, locale, 'new.');
if (fs.existsSync(fileTemplatePath + ext)) {
ctx.logger.debug('replaceEmptyFile format=%s locale=%s', ext, locale);
fs.copyFileSync(fileTemplatePath + ext, fileFrom);
} else {
let format = formatChecker.getFormatFromString(ext);
const format = formatChecker.getFormatFromString(ext);
let editorFormat;
if (formatChecker.isDocumentFormat(format)) {
editorFormat = 'docx';
@ -415,10 +415,10 @@ function* downloadFile(ctx, uri, fileFrom, withAuthorization, isInJwtToken, opt_
try {
let authorization;
if (utils.canIncludeOutboxAuthorization(ctx, uri) && withAuthorization) {
let secret = yield tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Outbox);
const secret = yield tenantManager.getTenantSecret(ctx, commonDefines.c_oAscSecretType.Outbox);
authorization = utils.fillJwtForRequest(ctx, {url: uri}, secret, false);
}
let getRes = yield utils.downloadUrlPromise(ctx, uri, tenDownloadTimeout, tenMaxDownloadBytes, authorization, isInJwtToken, opt_headers);
const getRes = yield utils.downloadUrlPromise(ctx, uri, tenDownloadTimeout, tenMaxDownloadBytes, authorization, isInJwtToken, opt_headers);
data = getRes.body;
sha256 = getRes.sha256;
res = constants.NO_ERROR;
@ -452,7 +452,7 @@ function* downloadFileFromStorage(ctx, strPath, dir, opt_specialDir) {
//create dirs
var dirsToCreate = [];
var dirStruct = {};
list.forEach(function(file) {
list.forEach((file) => {
var curDirPath = dir;
var curDirStruct = dirStruct;
var parts = storage.getRelativePath(strPath, file).split('/');
@ -486,7 +486,7 @@ function* processDownloadFromStorage(ctx, dataConvert, cmd, task, tempDirs, auth
let concatTemplate;
if (task.getFromOrigin() || task.getFromSettings()) {
if (task.getFromChanges()) {
let changesDir = path.join(tempDirs.source, constants.CHANGES_NAME);
const changesDir = path.join(tempDirs.source, constants.CHANGES_NAME);
fs.mkdirSync(changesDir);
let filesCount = 0;
if (cmd.getSaveKey()) {
@ -506,7 +506,7 @@ function* processDownloadFromStorage(ctx, dataConvert, cmd, task, tempDirs, auth
if (cmd.getSaveKey()) {
yield* downloadFileFromStorage(ctx, cmd.getDocId() + cmd.getSaveKey(), tempDirs.source);
}
let format = cmd.getFormat() || 'bin';
const format = cmd.getFormat() || 'bin';
dataConvert.fileFrom = path.join(tempDirs.source, 'Editor.' + format);
concatDir = tempDirs.source;
}
@ -514,7 +514,7 @@ function* processDownloadFromStorage(ctx, dataConvert, cmd, task, tempDirs, auth
return constants.CONVERT_PARAMS;
}
//mail merge
let mailMergeSend = cmd.getMailMergeSend();
const mailMergeSend = cmd.getMailMergeSend();
if (mailMergeSend) {
yield* downloadFileFromStorage(ctx, cmd.getDocId() + mailMergeSend.getJsonKey(), tempDirs.source);
concatDir = tempDirs.source;
@ -522,7 +522,7 @@ function* processDownloadFromStorage(ctx, dataConvert, cmd, task, tempDirs, auth
if (concatDir) {
yield* concatFiles(concatDir, concatTemplate);
if (concatTemplate) {
let filenames = fs.readdirSync(concatDir);
const filenames = fs.readdirSync(concatDir);
filenames.forEach(file => {
if (file.match(new RegExp(`${concatTemplate}\\d+\\.`))) {
fs.rmSync(path.join(concatDir, file));
@ -542,7 +542,7 @@ function* processDownloadFromStorage(ctx, dataConvert, cmd, task, tempDirs, auth
dataConvert.fileFrom = path.join(tempDirs.source, 'origin.pdf');
}
if (fs.existsSync(dataConvert.fileFrom)) {
let fileFromNew = path.join(path.dirname(dataConvert.fileFrom), "Editor.bin");
const fileFromNew = path.join(path.dirname(dataConvert.fileFrom), "Editor.bin");
fs.renameSync(dataConvert.fileFrom, fileFromNew);
dataConvert.fileFrom = fileFromNew;
}
@ -551,7 +551,7 @@ function* processDownloadFromStorage(ctx, dataConvert, cmd, task, tempDirs, auth
yield changeFormatToExtendedPdf(ctx, dataConvert, cmd);
if (task.getFromChanges() && !(task.getFromOrigin() || task.getFromSettings())) {
let sha256 = yield utils.checksumFile('sha256', dataConvert.fileFrom)
const sha256 = yield utils.checksumFile('sha256', dataConvert.fileFrom)
if(tenEditor['binaryChanges']) {
res = yield* processChangesBin(ctx, tempDirs, task, cmd, authorProps, sha256);
} else {
@ -564,23 +564,23 @@ function* processDownloadFromStorage(ctx, dataConvert, cmd, task, tempDirs, auth
function* concatFiles(source, template) {
template = template || "Editor";
//concatenate EditorN.ext parts in Editor.ext
let list = yield utils.listObjects(source, true);
const list = yield utils.listObjects(source, true);
list.sort(utils.compareStringByLength);
let writeStreams = {};
const writeStreams = {};
for (let i = 0; i < list.length; ++i) {
let file = list[i];
const file = list[i];
if (file.match(new RegExp(`${template}\\d+\\.`))) {
let target = file.replace(new RegExp(`(${template})\\d+(\\..*)`), '$1$2');
const target = file.replace(new RegExp(`(${template})\\d+(\\..*)`), '$1$2');
let writeStream = writeStreams[target];
if (!writeStream) {
writeStream = yield utils.promiseCreateWriteStream(target);
writeStreams[target] = writeStream;
}
let readStream = yield utils.promiseCreateReadStream(file);
const readStream = yield utils.promiseCreateReadStream(file);
yield utils.pipeStreams(readStream, writeStream, false);
}
}
for (let i in writeStreams) {
for (const i in writeStreams) {
if (writeStreams.hasOwnProperty(i)) {
writeStreams[i].end();
}
@ -590,24 +590,24 @@ function* processChangesBin(ctx, tempDirs, task, cmd, authorProps, sha256) {
const tenStreamWriterBufferSize = ctx.getCfg('FileConverter.converter.streamWriterBufferSize', cfgStreamWriterBufferSize);
const tenMaxRequestChanges = ctx.getCfg('services.CoAuthoring.server.maxRequestChanges', cfgMaxRequestChanges);
let res = constants.NO_ERROR;
let changesDir = path.join(tempDirs.source, constants.CHANGES_NAME);
const changesDir = path.join(tempDirs.source, constants.CHANGES_NAME);
fs.mkdirSync(changesDir);
let indexFile = 0;
let changesAuthor = null;
let changesAuthorUnique = null;
let changesIndex = null;
let changesHistory = {
const changesHistory = {
serverVersion: commonDefines.buildVersion,
changes: []
};
let forceSave = cmd.getForceSave();
const forceSave = cmd.getForceSave();
let forceSaveTime;
let forceSaveIndex = Number.MAX_VALUE;
if (forceSave && undefined !== forceSave.getTime() && undefined !== forceSave.getIndex()) {
forceSaveTime = forceSave.getTime();
forceSaveIndex = forceSave.getIndex();
}
let extChangeInfo = cmd.getExternalChangeInfo();
const extChangeInfo = cmd.getExternalChangeInfo();
let extChanges;
if (extChangeInfo) {
extChanges = [{
@ -640,14 +640,14 @@ function* processChangesBin(ctx, tempDirs, task, cmd, authorProps, sha256) {
}
extChanges = undefined;
for (let i = 0; i < changes.length; ++i) {
let change = changes[i];
const change = changes[i];
if (null === changesAuthor || changesAuthor !== change.user_id_original) {
if (null !== changesAuthor) {
yield* streamEndBin(streamObj);
streamObj = yield* streamCreateBin(ctx, changesDir, indexFile++);
yield* streamWriteBin(streamObj, Buffer.from(utils.getChangesFileHeader(), 'utf-8'));
}
let strDate = baseConnector.getDateTime(change.change_date);
const strDate = baseConnector.getDateTime(change.change_date);
changesHistory.changes.push({"documentSha256": sha256, 'created': strDate, 'user': {'id': change.user_id_original, 'name': change.user_name}});
}
changesAuthor = change.user_id_original;
@ -686,14 +686,14 @@ function* processChangesBin(ctx, tempDirs, task, cmd, authorProps, sha256) {
}
function* streamCreateBin(ctx, changesDir, indexFile, opt_options) {
let fileName = constants.CHANGES_NAME + indexFile + '.bin';
let filePath = path.join(changesDir, fileName);
let writeStream = yield utils.promiseCreateWriteStream(filePath, opt_options);
writeStream.on('error', function(err) {
const fileName = constants.CHANGES_NAME + indexFile + '.bin';
const filePath = path.join(changesDir, fileName);
const writeStream = yield utils.promiseCreateWriteStream(filePath, opt_options);
writeStream.on('error', (err) => {
//todo integrate error handle in main thread (probable: set flag here and check it in main thread)
ctx.logger.error('WriteStreamError %s', err.stack);
});
return {writeStream: writeStream, filePath: filePath, isNoChangesInFile: true};
return {writeStream, filePath, isNoChangesInFile: true};
}
function* streamWriteBin(streamObj, buf) {
@ -710,24 +710,24 @@ function* processChangesBase64(ctx, tempDirs, task, cmd, authorProps, sha256) {
const tenStreamWriterBufferSize = ctx.getCfg('FileConverter.converter.streamWriterBufferSize', cfgStreamWriterBufferSize);
const tenMaxRequestChanges = ctx.getCfg('services.CoAuthoring.server.maxRequestChanges', cfgMaxRequestChanges);
let res = constants.NO_ERROR;
let changesDir = path.join(tempDirs.source, constants.CHANGES_NAME);
const changesDir = path.join(tempDirs.source, constants.CHANGES_NAME);
fs.mkdirSync(changesDir);
let indexFile = 0;
let changesAuthor = null;
let changesAuthorUnique = null;
let changesIndex = null;
let changesHistory = {
const changesHistory = {
serverVersion: commonDefines.buildVersion,
changes: []
};
let forceSave = cmd.getForceSave();
const forceSave = cmd.getForceSave();
let forceSaveTime;
let forceSaveIndex = Number.MAX_VALUE;
if (forceSave && undefined !== forceSave.getTime() && undefined !== forceSave.getIndex()) {
forceSaveTime = forceSave.getTime();
forceSaveIndex = forceSave.getIndex();
}
let extChangeInfo = cmd.getExternalChangeInfo();
const extChangeInfo = cmd.getExternalChangeInfo();
let extChanges;
if (extChangeInfo) {
extChanges = [{
@ -759,13 +759,13 @@ function* processChangesBase64(ctx, tempDirs, task, cmd, authorProps, sha256) {
}
extChanges = undefined;
for (let i = 0; i < changes.length; ++i) {
let change = changes[i];
const change = changes[i];
if (null === changesAuthor || changesAuthor !== change.user_id_original) {
if (null !== changesAuthor) {
yield* streamEnd(streamObj, ']');
streamObj = yield* streamCreate(ctx, changesDir, indexFile++);
}
let strDate = baseConnector.getDateTime(change.change_date);
const strDate = baseConnector.getDateTime(change.change_date);
changesHistory.changes.push({"documentSha256": sha256, 'created': strDate, 'user': {'id': change.user_id_original, 'name': change.user_name}});
yield* streamWrite(streamObj, '[');
} else {
@ -807,14 +807,14 @@ function* processChangesBase64(ctx, tempDirs, task, cmd, authorProps, sha256) {
}
function* streamCreate(ctx, changesDir, indexFile, opt_options) {
let fileName = constants.CHANGES_NAME + indexFile + '.json';
let filePath = path.join(changesDir, fileName);
let writeStream = yield utils.promiseCreateWriteStream(filePath, opt_options);
writeStream.on('error', function(err) {
const fileName = constants.CHANGES_NAME + indexFile + '.json';
const filePath = path.join(changesDir, fileName);
const writeStream = yield utils.promiseCreateWriteStream(filePath, opt_options);
writeStream.on('error', (err) => {
//todo integrate error handle in main thread (probable: set flag here and check it in main thread)
ctx.logger.error('WriteStreamError %s', err.stack);
});
return {writeStream: writeStream, filePath: filePath, isNoChangesInFile: true};
return {writeStream, filePath, isNoChangesInFile: true};
}
function* streamWrite(streamObj, text) {
@ -841,15 +841,15 @@ function* processUploadToStorage(ctx, dir, storagePath, calcChecksum, opt_specia
}
}
function* processUploadToStorageChunk(ctx, list, dir, storagePath, calcChecksum, opt_specialDirDst) {
let promises = list.reduce(function(r, curValue) {
let localValue = storagePath + '/' + curValue.substring(dir.length + 1);
const promises = list.reduce((r, curValue) => {
const localValue = storagePath + '/' + curValue.substring(dir.length + 1);
let checksum;
if (calcChecksum) {
checksum = utils.checksumFile('sha256', curValue).then(result => {
ctx.logger.debug('processUploadToStorageChunk path=%s; sha256=%s', localValue, result);
});
}
let upload = storage.uploadObject(ctx, localValue, curValue, opt_specialDirDst);
const upload = storage.uploadObject(ctx, localValue, curValue, opt_specialDirDst);
r.push(checksum, upload);
return r;
}, []);
@ -868,12 +868,12 @@ function* processUploadToStorageErrorFile(ctx, dataConvert, tempDirs, childRes,
output += `stderr:${childRes.stderr}\n`;
}
output += `ExitCode (code=${exitCode};signal=${exitSignal};error:${error})`;
let outputPath = path.join(tempDirs.temp, 'console.txt');
const outputPath = path.join(tempDirs.temp, 'console.txt');
fs.writeFileSync(outputPath, output, {encoding: 'utf8'});
//ignore result dir with temp dir inside(see m_sTempDir param) to reduce the amount of data transferred
let ignorePrefix = path.normalize(tempDirs.result);
let format = path.extname(dataConvert.fileFrom).substring(1) || "unknown";
const ignorePrefix = path.normalize(tempDirs.result);
const format = path.extname(dataConvert.fileFrom).substring(1) || "unknown";
yield* processUploadToStorage(ctx, tempDirs.temp, format + '/' + dataConvert.key , false, tenErrorFiles, ignorePrefix);
ctx.logger.debug('processUploadToStorage error complete(id=%s)', dataConvert.key);
@ -926,14 +926,14 @@ function* postProcess(ctx, cmd, dataConvert, tempDirs, childRes, error, isTimeou
}
if (-1 !== exitCodesUpload.indexOf(error)) {
if (-1 !== exitCodesCopyOrigin.indexOf(error)) {
let originPath = path.join(path.dirname(dataConvert.fileTo), "origin" + path.extname(dataConvert.fileFrom));
const originPath = path.join(path.dirname(dataConvert.fileTo), "origin" + path.extname(dataConvert.fileFrom));
if (!fs.existsSync(dataConvert.fileTo)) {
fs.copyFileSync(dataConvert.fileFrom, originPath);
ctx.logger.debug('copyOrigin complete');
}
}
//todo clarify calcChecksum conditions
let calcChecksum = (0 === (constants.AVS_OFFICESTUDIO_FILE_CANVAS & cmd.getOutputFormat()));
const calcChecksum = (0 === (constants.AVS_OFFICESTUDIO_FILE_CANVAS & cmd.getOutputFormat()));
yield* processUploadToStorage(ctx, tempDirs.result, dataConvert.key, calcChecksum);
ctx.logger.debug('processUploadToStorage complete');
}
@ -983,10 +983,10 @@ function* spawnProcess(ctx, builderParams, tempDirs, dataConvert, authorProps, g
let processPath;
if (!builderParams) {
processPath = tenX2tPath;
let paramsFile = path.join(tempDirs.temp, 'params.xml');
const paramsFile = path.join(tempDirs.temp, 'params.xml');
dataConvert.serialize(ctx, paramsFile);
childArgs.push(paramsFile);
let hiddenXml = yield dataConvert.serializeHidden(ctx);
const hiddenXml = yield dataConvert.serializeHidden(ctx);
if (hiddenXml) {
childArgs.push(hiddenXml);
}
@ -1005,16 +1005,16 @@ function* spawnProcess(ctx, builderParams, tempDirs, dataConvert, authorProps, g
try {
const tenSpawnOptions = ctx.getCfg('FileConverter.converter.spawnOptions', cfgSpawnOptions);
//copy to avoid modification of global cfgSpawnOptions
let spawnOptions = Object.assign({}, tenSpawnOptions);;
const spawnOptions = Object.assign({}, tenSpawnOptions);;
spawnOptions.env = Object.assign({}, process.env, spawnOptions.env);
if (authorProps.lastModifiedBy && authorProps.modified) {
spawnOptions.env['LAST_MODIFIED_BY'] = authorProps.lastModifiedBy;
spawnOptions.env['MODIFIED'] = authorProps.modified;
}
let spawnAsyncPromise = spawnAsync(processPath, childArgs, spawnOptions);
const spawnAsyncPromise = spawnAsync(processPath, childArgs, spawnOptions);
childRes = spawnAsyncPromise.child;
let waitMS = Math.max(0, task.getVisibilityTimeout() * 1000 - (new Date().getTime() - getTaskTime.getTime()));
timeoutId = setTimeout(function() {
const waitMS = Math.max(0, task.getVisibilityTimeout() * 1000 - (new Date().getTime() - getTaskTime.getTime()));
timeoutId = setTimeout(() => {
isTimeout = true;
timeoutId = undefined;
//close stdio streams to enable emit 'close' event even if HtmlFileInternal is hung-up
@ -1035,7 +1035,7 @@ function* spawnProcess(ctx, builderParams, tempDirs, dataConvert, authorProps, g
if (undefined !== timeoutId) {
clearTimeout(timeoutId);
}
return {childRes: childRes, isTimeout: isTimeout};
return {childRes, isTimeout};
}
function* ExecuteTask(ctx, task) {
@ -1054,27 +1054,27 @@ function* ExecuteTask(ctx, task) {
ctx.logger.info('Start Task');
var error = constants.NO_ERROR;
tempDirs = getTempDir();
let fileTo = task.getToFile();
const fileTo = task.getToFile();
dataConvert.fileTo = fileTo ? path.join(tempDirs.result, fileTo) : '';
let builderParams = cmd.getBuilderParams();
let authorProps = {lastModifiedBy: null, modified: null};
const builderParams = cmd.getBuilderParams();
const authorProps = {lastModifiedBy: null, modified: null};
let isInJwtToken = cmd.getWithAuthorization();
error = yield* isUselessConvertion(ctx, task, cmd);
if (constants.NO_ERROR !== error) {
;
} else if (cmd.getUrl()) {
let format = cmd.getFormat();
const format = cmd.getFormat();
dataConvert.fileFrom = path.join(tempDirs.source, dataConvert.key + '.' + format);
if (utils.checkPathTraversal(ctx, dataConvert.key, tempDirs.source, dataConvert.fileFrom)) {
let url = cmd.getUrl();
let withAuthorization = cmd.getWithAuthorization();
let headers;
let fileSize;
let wopiParams = cmd.getWopiParams();
const wopiParams = cmd.getWopiParams();
if (wopiParams) {
withAuthorization = false;
isInJwtToken = true;
let fileInfo = wopiParams.commonInfo?.fileInfo;
const fileInfo = wopiParams.commonInfo?.fileInfo;
fileSize = fileInfo?.Size;
({url, headers} = yield wopiUtils.getWopiFileUrl(ctx, fileInfo, wopiParams.userAuth));
}
@ -1102,7 +1102,7 @@ function* ExecuteTask(ctx, task) {
} else if (cmd.getForgotten()) {
yield* downloadFileFromStorage(ctx, cmd.getForgotten(), tempDirs.source, tenForgottenFiles);
ctx.logger.debug('downloadFileFromStorage complete');
let list = yield utils.listObjects(tempDirs.source, false);
const list = yield utils.listObjects(tempDirs.source, false);
if (list.length > 0) {
dataConvert.fileFrom = list[0];
//store indicator file to determine if opening was from the forgotten file
@ -1115,7 +1115,7 @@ function* ExecuteTask(ctx, task) {
//in cause script in POST body
yield* downloadFileFromStorage(ctx, cmd.getDocId(), tempDirs.source);
ctx.logger.debug('downloadFileFromStorage complete');
let list = yield utils.listObjects(tempDirs.source, false);
const list = yield utils.listObjects(tempDirs.source, false);
if (list.length > 0) {
dataConvert.fileFrom = list[0];
}
@ -1132,8 +1132,8 @@ function* ExecuteTask(ctx, task) {
&& !cmd.getWopiParams();
if (canRollback) {
ctx.logger.warn('rollback to save changes to ooxml. See assemblyFormatAsOrigin param. formatTo=%s', formatChecker.getStringFromFormat(dataConvert.formatTo));
let extOld = path.extname(dataConvert.fileTo);
let extNew = '.' + formatChecker.getStringFromFormat(constants.AVS_OFFICESTUDIO_FILE_OTHER_OOXML);
const extOld = path.extname(dataConvert.fileTo);
const extNew = '.' + formatChecker.getStringFromFormat(constants.AVS_OFFICESTUDIO_FILE_OTHER_OOXML);
dataConvert.formatTo = constants.AVS_OFFICESTUDIO_FILE_OTHER_OOXML;
dataConvert.fileTo = dataConvert.fileTo.slice(0, -extOld.length) + extNew;
({childRes, isTimeout} = yield* spawnProcess(ctx, builderParams, tempDirs, dataConvert, authorProps, getTaskTime, task, isInJwtToken));
@ -1183,8 +1183,8 @@ function ackTask(ctx, res, task, ack) {
}
function receiveTaskSetTimeout(ctx, task, ack, outParams) {
//add DownloadTimeout to upload results
let delay = task.getVisibilityTimeout() * 1000 + ms(cfgDownloadTimeout.wholeCycle);
return setTimeout(function() {
const delay = task.getVisibilityTimeout() * 1000 + ms(cfgDownloadTimeout.wholeCycle);
return setTimeout(() => {
return co(function*() {
outParams.isAck = true;
ctx.logger.error('receiveTask timeout %d', delay);
@ -1198,9 +1198,9 @@ function receiveTask(data, ack) {
return co(function* () {
var res = null;
var task = null;
let outParams = {isAck: false};
const outParams = {isAck: false};
let timeoutId = undefined;
let ctx = new operationContext.Context();
const ctx = new operationContext.Context();
try {
task = new commonDefines.TaskQueueData(JSON.parse(data));
if (task) {
@ -1225,16 +1225,16 @@ function createErrorResponse(ctx, task){
}
ctx.logger.debug('createErrorResponse');
//simulate error response
let cmd = task.getCmd();
const cmd = task.getCmd();
cmd.setStatusInfo(constants.CONVERT_TEMPORARY);
let res = new commonDefines.TaskQueueData();
const res = new commonDefines.TaskQueueData();
res.setCtx(ctx);
res.setCmd(cmd);
return res;
}
function simulateErrorResponse(data){
let task = new commonDefines.TaskQueueData(JSON.parse(data));
let ctx = new operationContext.Context();
const task = new commonDefines.TaskQueueData(JSON.parse(data));
const ctx = new operationContext.Context();
ctx.initFromTaskQueueData(task);
//todo
//yield ctx.initTenantCache();
@ -1243,7 +1243,7 @@ function simulateErrorResponse(data){
function run() {
queue = new queueService(simulateErrorResponse);
queue.on('task', receiveTask);
queue.init(true, true, true, false, false, false, function(err) {
queue.init(true, true, true, false, false, false, (err) => {
if (null != err) {
operationContext.global.logger.error('createTaskQueue error: %s', err.stack);
}

2
FileConverter/sources/convertermaster.js
View File

@ -53,7 +53,7 @@ if (cluster.isMaster) {
const availableParallelism = os.availableParallelism?.();
operationContext.global.logger.warn('num of CPUs: %d; availableParallelism: %s', numCPUs, availableParallelism);
workersCount = Math.ceil((availableParallelism || numCPUs) * cfgMaxProcessCount);
let [licenseInfo] = await license.readLicense(cfgLicenseFile);
const [licenseInfo] = await license.readLicense(cfgLicenseFile);
workersCount = Math.min(licenseInfo.count, workersCount);
//todo send license to workers for multi-tenancy
};

10
Gruntfile.js
View File

@ -37,13 +37,13 @@ module.exports = function (grunt) {
let addons = grunt.option('addon') || [];
if (!Array.isArray(addons))
addons = [addons];
{addons = [addons];}
addons.forEach((element,index,self) => self[index] = path.join('..', element));
addons = addons.filter(element => grunt.file.isDir(element));
function _merge(target, ...sources) {
if (!sources.length) return target;
if (!sources.length) {return target;}
const source = sources.shift();
for (const key in source) {
@ -67,7 +67,7 @@ module.exports = function (grunt) {
}
}
addons.forEach(element => {
let _path = path.join(element, 'package.json');
const _path = path.join(element, 'package.json');
if (grunt.file.exists(_path)) {
_merge(packageFile, require(_path));
grunt.log.ok('addon '.green + element + ' is merged successfully'.green);
@ -119,10 +119,10 @@ module.exports = function (grunt) {
}
}
},
checkDependencies: checkDependencies
checkDependencies
});
grunt.registerTask('build-develop', 'Build develop scripts', function () {
grunt.registerTask('build-develop', 'Build develop scripts', () => {
grunt.initConfig({
copy: packageFile.grunt["develop-copy"]
});