mirror of
https://github.com/ether/etherpad-lite.git
synced 2025-01-24 00:00:55 +01:00
e841798314
This change extracts the grammar correction performed on the async branch, anticipating them in a single commit. It cannot be folded with the previous one, as it is not purely cosmetic.
344 lines
9.5 KiB
JavaScript
344 lines
9.5 KiB
JavaScript
/**
|
|
* Handles the import requests
|
|
*/
|
|
|
|
/*
|
|
* 2011 Peter 'Pita' Martischka (Primary Technology Ltd)
|
|
* 2012 Iván Eixarch
|
|
* 2014 John McLear (Etherpad Foundation / McLear Ltd)
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS-IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
var ERR = require("async-stacktrace")
|
|
, padManager = require("../db/PadManager")
|
|
, padMessageHandler = require("./PadMessageHandler")
|
|
, async = require("async")
|
|
, fs = require("fs")
|
|
, path = require("path")
|
|
, settings = require('../utils/Settings')
|
|
, formidable = require('formidable')
|
|
, os = require("os")
|
|
, importHtml = require("../utils/ImportHtml")
|
|
, importEtherpad = require("../utils/ImportEtherpad")
|
|
, log4js = require("log4js")
|
|
, hooks = require("ep_etherpad-lite/static/js/pluginfw/hooks.js");
|
|
|
|
var convertor = null;
|
|
var exportExtension = "htm";
|
|
|
|
// load abiword only if it is enabled and if soffice is disabled
|
|
if (settings.abiword != null && settings.soffice === null) {
|
|
convertor = require("../utils/Abiword");
|
|
}
|
|
|
|
// load soffice only if it is enabled
|
|
if (settings.soffice != null) {
|
|
convertor = require("../utils/LibreOffice");
|
|
exportExtension = "html";
|
|
}
|
|
|
|
const tmpDirectory = os.tmpdir();
|
|
|
|
/**
|
|
* do a requested import
|
|
*/
|
|
exports.doImport = function(req, res, padId)
|
|
{
|
|
var apiLogger = log4js.getLogger("ImportHandler");
|
|
|
|
// pipe to a file
|
|
// convert file to html via abiword or soffice
|
|
// set html in the pad
|
|
|
|
var srcFile, destFile
|
|
, pad
|
|
, text
|
|
, importHandledByPlugin
|
|
, directDatabaseAccess
|
|
, useConvertor;
|
|
|
|
var randNum = Math.floor(Math.random()*0xFFFFFFFF);
|
|
|
|
// setting flag for whether to use convertor or not
|
|
useConvertor = (convertor != null);
|
|
|
|
async.series([
|
|
// save the uploaded file to /tmp
|
|
function(callback) {
|
|
var form = new formidable.IncomingForm();
|
|
form.keepExtensions = true;
|
|
form.uploadDir = tmpDirectory;
|
|
|
|
form.parse(req, function(err, fields, files) {
|
|
if (err || files.file === undefined) {
|
|
// the upload failed, stop at this point
|
|
if (err) {
|
|
console.warn("Uploading Error: " + err.stack);
|
|
}
|
|
callback("uploadFailed");
|
|
|
|
return;
|
|
}
|
|
|
|
// everything ok, continue
|
|
// save the path of the uploaded file
|
|
srcFile = files.file.path;
|
|
callback();
|
|
});
|
|
},
|
|
|
|
// ensure this is a file ending we know, else we change the file ending to .txt
|
|
// this allows us to accept source code files like .c or .java
|
|
function(callback) {
|
|
var fileEnding = path.extname(srcFile).toLowerCase()
|
|
, knownFileEndings = [".txt", ".doc", ".docx", ".pdf", ".odt", ".html", ".htm", ".etherpad", ".rtf"]
|
|
, fileEndingKnown = (knownFileEndings.indexOf(fileEnding) > -1);
|
|
|
|
// if the file ending is known, continue as normal
|
|
if (fileEndingKnown) {
|
|
callback();
|
|
|
|
return;
|
|
}
|
|
|
|
// we need to rename this file with a .txt ending
|
|
if (settings.allowUnknownFileEnds === true) {
|
|
var oldSrcFile = srcFile;
|
|
srcFile = path.join(path.dirname(srcFile), path.basename(srcFile, fileEnding) + ".txt");
|
|
fs.rename(oldSrcFile, srcFile, callback);
|
|
} else {
|
|
console.warn("Not allowing unknown file type to be imported", fileEnding);
|
|
callback("uploadFailed");
|
|
}
|
|
},
|
|
|
|
function(callback) {
|
|
destFile = path.join(tmpDirectory, "etherpad_import_" + randNum + "." + exportExtension);
|
|
|
|
// Logic for allowing external Import Plugins
|
|
hooks.aCallAll("import", { srcFile: srcFile, destFile: destFile }, function(err, result) {
|
|
if (ERR(err, callback)) return callback();
|
|
|
|
if (result.length > 0) { // This feels hacky and wrong..
|
|
importHandledByPlugin = true;
|
|
}
|
|
callback();
|
|
});
|
|
},
|
|
|
|
function(callback) {
|
|
var fileEnding = path.extname(srcFile).toLowerCase()
|
|
var fileIsNotEtherpad = (fileEnding !== ".etherpad");
|
|
|
|
if (fileIsNotEtherpad) {
|
|
callback();
|
|
|
|
return;
|
|
}
|
|
|
|
// we do this here so we can see if the pad has quite a few edits
|
|
padManager.getPad(padId, function(err, _pad) {
|
|
var headCount = _pad.head;
|
|
if (headCount >= 10) {
|
|
apiLogger.warn("Direct database Import attempt of a pad that already has content, we won't be doing this");
|
|
return callback("padHasData");
|
|
}
|
|
|
|
fs.readFile(srcFile, "utf8", function(err, _text) {
|
|
directDatabaseAccess = true;
|
|
importEtherpad.setPadRaw(padId, _text, function(err) {
|
|
callback();
|
|
});
|
|
});
|
|
});
|
|
},
|
|
|
|
// convert file to html if necessary
|
|
function(callback) {
|
|
if (importHandledByPlugin || directDatabaseAccess) {
|
|
callback();
|
|
|
|
return;
|
|
}
|
|
|
|
var fileEnding = path.extname(srcFile).toLowerCase();
|
|
var fileIsHTML = (fileEnding === ".html" || fileEnding === ".htm");
|
|
var fileIsTXT = (fileEnding === ".txt");
|
|
|
|
if (fileIsTXT) useConvertor = false; // Don't use convertor for text files
|
|
|
|
// See https://github.com/ether/etherpad-lite/issues/2572
|
|
if (fileIsHTML || (useConvertor === false)) {
|
|
// if no convertor only rename
|
|
fs.rename(srcFile, destFile, callback);
|
|
|
|
return;
|
|
}
|
|
|
|
convertor.convertFile(srcFile, destFile, exportExtension, function(err) {
|
|
// catch convert errors
|
|
if (err) {
|
|
console.warn("Converting Error:", err);
|
|
return callback("convertFailed");
|
|
}
|
|
|
|
callback();
|
|
});
|
|
},
|
|
|
|
function(callback) {
|
|
if (useConvertor || directDatabaseAccess) {
|
|
callback();
|
|
|
|
return;
|
|
}
|
|
|
|
// Read the file with no encoding for raw buffer access.
|
|
fs.readFile(destFile, function(err, buf) {
|
|
if (err) throw err;
|
|
var isAscii = true;
|
|
// Check if there are only ascii chars in the uploaded file
|
|
for (var i=0, len=buf.length; i<len; i++) {
|
|
if (buf[i] > 240) {
|
|
isAscii=false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!isAscii) {
|
|
callback("uploadFailed");
|
|
|
|
return;
|
|
}
|
|
|
|
callback();
|
|
});
|
|
},
|
|
|
|
// get the pad object
|
|
function(callback) {
|
|
padManager.getPad(padId, function(err, _pad) {
|
|
if (ERR(err, callback)) return;
|
|
pad = _pad;
|
|
callback();
|
|
});
|
|
},
|
|
|
|
// read the text
|
|
function(callback) {
|
|
if (directDatabaseAccess) {
|
|
callback();
|
|
|
|
return;
|
|
}
|
|
|
|
fs.readFile(destFile, "utf8", function(err, _text) {
|
|
if (ERR(err, callback)) return;
|
|
text = _text;
|
|
// Title needs to be stripped out else it appends it to the pad..
|
|
text = text.replace("<title>", "<!-- <title>");
|
|
text = text.replace("</title>","</title>-->");
|
|
|
|
// node on windows has a delay on releasing of the file lock.
|
|
// We add a 100ms delay to work around this
|
|
if (os.type().indexOf("Windows") > -1) {
|
|
setTimeout(function() {callback();}, 100);
|
|
} else {
|
|
callback();
|
|
}
|
|
});
|
|
},
|
|
|
|
// change text of the pad and broadcast the changeset
|
|
function(callback) {
|
|
if (!directDatabaseAccess) {
|
|
var fileEnding = path.extname(srcFile).toLowerCase();
|
|
if (importHandledByPlugin || useConvertor || fileEnding == ".htm" || fileEnding == ".html") {
|
|
importHtml.setPadHTML(pad, text, function(e){
|
|
if (e) {
|
|
apiLogger.warn("Error importing, possibly caused by malformed HTML");
|
|
}
|
|
});
|
|
} else {
|
|
pad.setText(text);
|
|
}
|
|
}
|
|
|
|
// Load the Pad into memory then broadcast updates to all clients
|
|
padManager.unloadPad(padId);
|
|
padManager.getPad(padId, function(err, _pad) {
|
|
var pad = _pad;
|
|
padManager.unloadPad(padId);
|
|
|
|
// direct Database Access means a pad user should perform a switchToPad
|
|
// and not attempt to receive updated pad data
|
|
if (directDatabaseAccess) {
|
|
callback();
|
|
|
|
return;
|
|
}
|
|
|
|
padMessageHandler.updatePadClients(pad, function(){
|
|
callback();
|
|
});
|
|
});
|
|
|
|
},
|
|
|
|
// clean up temporary files
|
|
function(callback) {
|
|
if (directDatabaseAccess) {
|
|
callback();
|
|
|
|
return;
|
|
}
|
|
|
|
try {
|
|
fs.unlinkSync(srcFile);
|
|
} catch (e) {
|
|
console.log(e);
|
|
}
|
|
|
|
try {
|
|
fs.unlinkSync(destFile);
|
|
} catch (e) {
|
|
console.log(e);
|
|
}
|
|
|
|
callback();
|
|
}
|
|
], function(err) {
|
|
var status = "ok";
|
|
|
|
// check for known errors and replace the status
|
|
if (err == "uploadFailed" || err == "convertFailed" || err == "padHasData") {
|
|
status = err;
|
|
err = null;
|
|
}
|
|
|
|
ERR(err);
|
|
|
|
// close the connection
|
|
res.send(
|
|
"<head> \
|
|
<script type='text/javascript' src='../../static/js/jquery.js'></script> \
|
|
</head> \
|
|
<script> \
|
|
$(window).load(function(){ \
|
|
var impexp = window.parent.padimpexp.handleFrameCall('" + directDatabaseAccess +"', '" + status + "'); \
|
|
}) \
|
|
</script>"
|
|
);
|
|
});
|
|
}
|