You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
773 lines
32 KiB
773 lines
32 KiB
#include "UBDocumentPublisher.h"
|
|
|
|
#include "frameworks/UBPlatformUtils.h"
|
|
#include "frameworks/UBFileSystemUtils.h"
|
|
#include "frameworks/UBStringUtils.h"
|
|
|
|
#include "network/UBNetworkAccessManager.h"
|
|
#include "network/UBServerXMLHttpRequest.h"
|
|
|
|
#include "core/UBDocumentManager.h"
|
|
#include "core/UBApplication.h"
|
|
#include "core/UBPersistenceManager.h"
|
|
|
|
#include "gui/UBMainWindow.h"
|
|
|
|
#include "document/UBDocumentProxy.h"
|
|
|
|
#include "domain/UBGraphicsWidgetItem.h"
|
|
|
|
#include "quazip.h"
|
|
#include "quazipfile.h"
|
|
|
|
#include "adaptors/UBExportFullPDF.h"
|
|
#include "adaptors/UBExportDocument.h"
|
|
#include "adaptors/UBSvgSubsetAdaptor.h"
|
|
|
|
#include "UBSvgSubsetRasterizer.h"
|
|
|
|
#include "core/memcheck.h"
|
|
|
|
UBDocumentPublisher::UBDocumentPublisher(UBDocumentProxy* pDocument, QObject *parent)
|
|
: UBAbstractPublisher(parent)
|
|
, mSourceDocument(pDocument)
|
|
, mPublishingDocument(0)
|
|
{
|
|
connect(this, SIGNAL(authenticated(const QUuid&, const QString&))
|
|
, this, SLOT(postDocument(const QUuid&, const QString&)));
|
|
}
|
|
|
|
|
|
UBDocumentPublisher::~UBDocumentPublisher()
|
|
{
|
|
delete mPublishingDocument;
|
|
}
|
|
|
|
|
|
void UBDocumentPublisher::publish()
|
|
{
|
|
UBAbstractPublisher::authenticate();
|
|
}
|
|
|
|
|
|
void UBDocumentPublisher::postDocument(const QUuid& tokenUuid, const QString& encryptedBase64Token)
|
|
{
|
|
mAuthenticationUuid = tokenUuid;
|
|
mAuthenticationBase64Token = encryptedBase64Token;
|
|
|
|
UBDocumentPublishingDialog dialog(UBApplication::mainWindow);
|
|
|
|
dialog.videoWarning->setVisible(UBPersistenceManager::persistenceManager()->mayHaveVideo(mSourceDocument));
|
|
|
|
dialog.title->setText(mSourceDocument->name());
|
|
|
|
QString defaultEMail = UBSettings::settings()->uniboardWebEMail->get().toString();
|
|
dialog.email->setText(defaultEMail);
|
|
|
|
QString defaultAuthor = UBSettings::settings()->uniboardWebAuthor->get().toString();
|
|
dialog.author->setText(defaultAuthor);
|
|
|
|
if (dialog.exec() == QDialog::Accepted)
|
|
{
|
|
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
|
|
UBApplication::showMessage(tr("Preparing document for upload..."), true);
|
|
|
|
mTitle = dialog.title->text();
|
|
mDescription = dialog.description->toPlainText();
|
|
mEMail = dialog.email->text();
|
|
mAuthor = dialog.author->text();
|
|
|
|
bool attachPDF = dialog.attachPDF->isChecked();
|
|
bool attachUBZ = dialog.attachUBZ->isChecked();
|
|
|
|
mPublishingServiceUrl = UBSettings::settings()->documentsPublishingUrl;
|
|
|
|
UBSettings::settings()->uniboardWebEMail->set(mEMail);
|
|
UBSettings::settings()->uniboardWebAuthor->set(mAuthor);
|
|
|
|
QDir d;
|
|
d.mkpath(UBFileSystemUtils::defaultTempDirPath());
|
|
|
|
QString tmpDir = UBFileSystemUtils::createTempDir();
|
|
|
|
if (UBFileSystemUtils::copyDir(mSourceDocument->persistencePath(), tmpDir))
|
|
{
|
|
QUuid publishingUuid = QUuid::createUuid();
|
|
|
|
mPublishingDocument = new UBDocumentProxy(tmpDir);
|
|
mPublishingDocument->setPageCount(mSourceDocument->pageCount());
|
|
|
|
rasterizeScenes();
|
|
|
|
//rasterizePDF(); // not needed as we do not publish svg file anymore
|
|
|
|
//rasterizeSVGImages(); // not needed as we do not publish svg file anymore
|
|
|
|
upgradeDocumentForPublishing();
|
|
|
|
if (attachPDF)
|
|
{
|
|
UBExportFullPDF pdfExporter;
|
|
pdfExporter.setVerbode(false);
|
|
pdfExporter.persistsDocument(mSourceDocument,
|
|
mPublishingDocument->persistencePath() + "/" + UBStringUtils::toCanonicalUuid(publishingUuid) + ".pdf");
|
|
}
|
|
|
|
if (attachUBZ)
|
|
{
|
|
UBExportDocument ubzExporter;
|
|
ubzExporter.setVerbode(false);
|
|
ubzExporter.persistsDocument(mSourceDocument,
|
|
mPublishingDocument->persistencePath() + "/" + UBStringUtils::toCanonicalUuid(publishingUuid) + ".ubz");
|
|
}
|
|
|
|
// remove all useless files
|
|
|
|
for (int pageIndex = 0; pageIndex < mPublishingDocument->pageCount(); pageIndex++)
|
|
{
|
|
QString filename = mPublishingDocument->persistencePath() +
|
|
UBFileSystemUtils::digitFileFormat("/page%1.svg", pageIndex + 1);
|
|
|
|
QFile::remove(filename);
|
|
}
|
|
|
|
UBFileSystemUtils::deleteDir(mPublishingDocument->persistencePath() + "/" + UBPersistenceManager::imageDirectory);
|
|
UBFileSystemUtils::deleteDir(mPublishingDocument->persistencePath() + "/" + UBPersistenceManager::objectDirectory);
|
|
UBFileSystemUtils::deleteDir(mPublishingDocument->persistencePath() + "/" + UBPersistenceManager::videoDirectory);
|
|
UBFileSystemUtils::deleteDir(mPublishingDocument->persistencePath() + "/" + UBPersistenceManager::audioDirectory);
|
|
|
|
QString tempZipFile = UBFileSystemUtils::defaultTempDirPath()
|
|
+ "/" + UBStringUtils::toCanonicalUuid(QUuid::createUuid()) + ".zip";
|
|
|
|
//qDebug() << "compressing" << mPublishingDocument->persistencePath() << "in" << tempZipFile;
|
|
|
|
QuaZip zip(tempZipFile);
|
|
zip.setFileNameCodec("UTF-8");
|
|
if (!zip.open(QuaZip::mdCreate))
|
|
{
|
|
qWarning() << "Export failed. Cause: zip.open(): " << zip.getZipError() << "," << tempZipFile;
|
|
QApplication::restoreOverrideCursor();
|
|
return;
|
|
}
|
|
|
|
QuaZipFile outFile(&zip);
|
|
|
|
if (!UBFileSystemUtils::compressDirInZip(mPublishingDocument->persistencePath(), "", &outFile, true))
|
|
{
|
|
qWarning("Export failed. compressDirInZip failed ...");
|
|
zip.close();
|
|
//zip.remove();
|
|
UBApplication::showMessage(tr("Export failed."));
|
|
QApplication::restoreOverrideCursor();
|
|
return;
|
|
}
|
|
|
|
if (zip.getZipError() != 0)
|
|
{
|
|
qWarning("Export failed. Cause: zip.close(): %d", zip.getZipError());
|
|
zip.close();
|
|
//zip.remove();
|
|
UBApplication::showMessage(tr("Export failed."));
|
|
QApplication::restoreOverrideCursor();
|
|
return;
|
|
}
|
|
|
|
zip.close();
|
|
|
|
mPublishingUrl = QUrl(mPublishingServiceUrl + "/documents/publish/"
|
|
+ UBStringUtils::toCanonicalUuid(mSourceDocument->uuid()));
|
|
|
|
sendZipToUniboardWeb(tempZipFile, publishingUuid);
|
|
}
|
|
else
|
|
{
|
|
UBApplication::showMessage(tr("Export failed ..."));
|
|
QApplication::restoreOverrideCursor();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UBApplication::showMessage(tr("Export canceled ..."));
|
|
QApplication::restoreOverrideCursor();
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* // not needed as we do not publish svg file anymore
|
|
*
|
|
|
|
void UBDocumentPublisher::rasterizePDF()
|
|
{
|
|
if (UBPersistenceManager::persistenceManager()->mayHavePDF(mPublishingDocument))
|
|
{
|
|
UBSvgSubsetAdaptor::convertPDFObjectsToImages(mPublishingDocument);
|
|
|
|
QDir objectDir(mPublishingDocument->persistencePath() + "/" + UBPersistenceManager::objectDirectory);
|
|
|
|
QStringList filters;
|
|
filters << "*.pdf";
|
|
|
|
foreach(QFileInfo fi, objectDir.entryInfoList(filters))
|
|
{
|
|
QFile::remove(fi.absoluteFilePath());
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
/*
|
|
* // not needed as we do not publish svg file anymore
|
|
|
|
|
|
void UBDocumentPublisher::rasterizeSVGImages()
|
|
{
|
|
if (UBPersistenceManager::persistenceManager()->mayHaveSVGImages(mPublishingDocument))
|
|
{
|
|
UBSvgSubsetAdaptor::convertSvgImagesToImages(mPublishingDocument);
|
|
|
|
QDir objectDir(mPublishingDocument->persistencePath() + "/" + UBPersistenceManager::imageDirectory);
|
|
|
|
QStringList filters;
|
|
filters << "*.svg";
|
|
|
|
foreach(QFileInfo fi, objectDir.entryInfoList(filters))
|
|
{
|
|
QFile::remove(fi.absoluteFilePath());
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
void UBDocumentPublisher::rasterizeScenes()
|
|
{
|
|
|
|
for(int pageIndex = 0; pageIndex < mPublishingDocument->pageCount(); pageIndex++)
|
|
{
|
|
UBApplication::showMessage(tr("Converting page %1/%2 ...").arg(pageIndex + 1).arg(mPublishingDocument->pageCount()), true);
|
|
|
|
UBSvgSubsetRasterizer rasterizer(mPublishingDocument, pageIndex);
|
|
|
|
QString filename = mPublishingDocument->persistencePath() +
|
|
UBFileSystemUtils::digitFileFormat("/page%1.jpg", pageIndex + 1);
|
|
|
|
rasterizer.rasterizeToFile(filename);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
void UBDocumentPublisher::updateGoogleMapApiKey()
|
|
{
|
|
QDir widgestDir(mPublishingDocument->persistencePath() + "/" + UBPersistenceManager::widgetDirectory);
|
|
|
|
QString uniboardWebGoogleMapApiKey = UBSettings::settings()->uniboardWebGoogleMapApiKey->get().toString();
|
|
|
|
foreach(QFileInfo dirInfo, widgestDir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot))
|
|
{
|
|
QString config = UBFileSystemUtils::readTextFile(dirInfo.absoluteFilePath() + "/config.xml").toLower();
|
|
|
|
if (config.contains("google") && config.contains("map"))
|
|
{
|
|
QDir widgetDir(dirInfo.absoluteFilePath());
|
|
|
|
foreach(QFileInfo fileInfo, widgetDir.entryInfoList(QDir::Files | QDir::NoDotAndDotDot))
|
|
{
|
|
QFile file(fileInfo.absoluteFilePath());
|
|
|
|
if(file.open(QIODevice::ReadWrite))
|
|
{
|
|
QTextStream stream(&file);
|
|
QString content = stream.readAll();
|
|
|
|
if (content.contains("ABQIAAAA6vtVqAUu8kZ_eTz7c8kwSBT9UCAhw_xm0LNFHsWmQxTJAdp5lxSY_5r-lZriY_7sACaMnl80JcX6Og"))
|
|
{
|
|
content.replace("ABQIAAAA6vtVqAUu8kZ_eTz7c8kwSBT9UCAhw_xm0LNFHsWmQxTJAdp5lxSY_5r-lZriY_7sACaMnl80JcX6Og",
|
|
uniboardWebGoogleMapApiKey);
|
|
|
|
file.resize(0);
|
|
file.write(content.toUtf8());
|
|
}
|
|
file.close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void UBDocumentPublisher::upgradeDocumentForPublishing()
|
|
{
|
|
for(int pageIndex = 0; pageIndex < mPublishingDocument->pageCount(); pageIndex++)
|
|
{
|
|
UBGraphicsScene *scene = UBSvgSubsetAdaptor::loadScene(mPublishingDocument, pageIndex);
|
|
|
|
bool sceneHasWidget = false;
|
|
|
|
QList<UBGraphicsW3CWidgetItem*> widgets;
|
|
|
|
foreach(QGraphicsItem* item, scene->items())
|
|
{
|
|
UBGraphicsW3CWidgetItem *widgetItem = dynamic_cast<UBGraphicsW3CWidgetItem*>(item);
|
|
|
|
if (widgetItem)
|
|
{
|
|
generateWidgetPropertyScript(widgetItem, pageIndex + 1);
|
|
sceneHasWidget = true;
|
|
widgets << widgetItem;
|
|
}
|
|
}
|
|
|
|
//if (sceneHasWidget)
|
|
//{
|
|
// updateSVGForWidget(pageIndex); // not needed as we do not publish svg file anymore
|
|
//}
|
|
|
|
QString filename = mPublishingDocument->persistencePath() +
|
|
UBFileSystemUtils::digitFileFormat("/page%1.json", pageIndex + 1);
|
|
|
|
QFile jsonFile(filename);
|
|
if (jsonFile.open(QIODevice::WriteOnly | QIODevice::Truncate))
|
|
{
|
|
jsonFile.write("{\n");
|
|
jsonFile.write(QString(" \"scene\": {\n").toUtf8());
|
|
jsonFile.write(QString(" \"x\": %1,\n").arg(scene->normalizedSceneRect().x()).toUtf8());
|
|
jsonFile.write(QString(" \"y\": %1,\n").arg(scene->normalizedSceneRect().y()).toUtf8());
|
|
jsonFile.write(QString(" \"width\": %1,\n").arg(scene->normalizedSceneRect().width()).toUtf8());
|
|
jsonFile.write(QString(" \"height\": %1\n").arg(scene->normalizedSceneRect().height()).toUtf8());
|
|
jsonFile.write(QString(" },\n").toUtf8());
|
|
|
|
jsonFile.write(QString(" \"widgets\": [\n").toUtf8());
|
|
|
|
bool first = true;
|
|
|
|
foreach(UBGraphicsW3CWidgetItem* widget, widgets)
|
|
{
|
|
if (!first)
|
|
jsonFile.write(QString(" ,\n").toUtf8());
|
|
|
|
jsonFile.write(QString(" {\n").toUtf8());
|
|
jsonFile.write(QString(" \"uuid\": \"%1\",\n").arg(UBStringUtils::toCanonicalUuid(widget->uuid())).toUtf8());
|
|
jsonFile.write(QString(" \"id\": \"%1\",\n").arg(widget->metadatas().id).toUtf8());
|
|
|
|
jsonFile.write(QString(" \"name\": \"%1\",\n").arg(widget->w3cWidget()->metadatas().name).toUtf8());
|
|
jsonFile.write(QString(" \"description\": \"%1\",\n").arg(widget->w3cWidget()->metadatas().description).toUtf8());
|
|
jsonFile.write(QString(" \"author\": \"%1\",\n").arg(widget->w3cWidget()->metadatas().author).toUtf8());
|
|
jsonFile.write(QString(" \"authorEmail\": \"%1\",\n").arg(widget->w3cWidget()->metadatas().authorEmail).toUtf8());
|
|
jsonFile.write(QString(" \"authorHref\": \"%1\",\n").arg(widget->w3cWidget()->metadatas().authorHref).toUtf8());
|
|
jsonFile.write(QString(" \"version\": \"%1\",\n").arg(widget->w3cWidget()->metadatas().authorHref).toUtf8());
|
|
|
|
jsonFile.write(QString(" \"x\": %1,\n").arg(widget->sceneBoundingRect().x()).toUtf8());
|
|
jsonFile.write(QString(" \"y\": %1,\n").arg(widget->sceneBoundingRect().y()).toUtf8());
|
|
jsonFile.write(QString(" \"width\": %1,\n").arg(widget->sceneBoundingRect().width()).toUtf8());
|
|
jsonFile.write(QString(" \"height\": %1,\n").arg(widget->sceneBoundingRect().height()).toUtf8());
|
|
|
|
jsonFile.write(QString(" \"nominalWidth\": %1,\n").arg(widget->boundingRect().width()).toUtf8());
|
|
jsonFile.write(QString(" \"nominalHeight\": %1,\n").arg(widget->boundingRect().height()).toUtf8());
|
|
|
|
QString url = UBPersistenceManager::widgetDirectory + "/" + widget->uuid().toString() + ".wgt";
|
|
jsonFile.write(QString(" \"src\": \"%1\",\n").arg(url).toUtf8());
|
|
QString startFile = widget->w3cWidget()->mainHtmlFileName();
|
|
jsonFile.write(QString(" \"startFile\": \"%1\",\n").arg(startFile).toUtf8());
|
|
|
|
QMap<QString, QString> preferences = widget->preferences();
|
|
|
|
jsonFile.write(QString(" \"preferences\": {\n").toUtf8());
|
|
|
|
foreach(QString key, preferences.keys())
|
|
{
|
|
QString sep = ",";
|
|
if (key == preferences.keys().last())
|
|
sep = "";
|
|
|
|
jsonFile.write(QString(" \"%1\": \"%2\"%3\n")
|
|
.arg(key)
|
|
.arg(preferences.value(key))
|
|
.arg(sep)
|
|
.toUtf8());
|
|
}
|
|
jsonFile.write(QString(" },\n").toUtf8());
|
|
|
|
jsonFile.write(QString(" \"datastore\": {\n").toUtf8());
|
|
|
|
QMap<QString, QString> datastoreEntries = widget->datastoreEntries();
|
|
|
|
foreach(QString entry, datastoreEntries.keys())
|
|
{
|
|
QString sep = ",";
|
|
if (entry == datastoreEntries.keys().last())
|
|
sep = "";
|
|
|
|
jsonFile.write(QString(" \"%1\": \"%2\"%3\n")
|
|
.arg(entry)
|
|
.arg(datastoreEntries.value(entry))
|
|
.arg(sep)
|
|
.toUtf8());
|
|
}
|
|
jsonFile.write(QString(" }\n").toUtf8());
|
|
|
|
jsonFile.write(QString(" }\n").toUtf8());
|
|
|
|
first = false;
|
|
}
|
|
|
|
jsonFile.write(" ]\n");
|
|
jsonFile.write("}\n");
|
|
}
|
|
else
|
|
{
|
|
qWarning() << "Cannot open file" << filename << "for saving page state";
|
|
}
|
|
|
|
delete scene;
|
|
}
|
|
|
|
updateGoogleMapApiKey();
|
|
}
|
|
|
|
|
|
/** // not needed as we do not publish svg file anymore
|
|
void UBDocumentPublisher::updateSVGForWidget(int pageIndex)
|
|
{
|
|
QString fileName = mPublishingDocument->persistencePath() +
|
|
UBFileSystemUtils::digitFileFormat("/page%1.svg", pageIndex + 1);
|
|
|
|
QFile svgFile(fileName);
|
|
|
|
if (svgFile.exists())
|
|
{
|
|
if (!svgFile.open(QIODevice::ReadWrite))
|
|
{
|
|
qWarning() << "Cannot open file " << fileName << " for widget upgrade ...";
|
|
return;
|
|
}
|
|
|
|
QTextStream stream(&svgFile);
|
|
QStringList lines;
|
|
|
|
QString line;
|
|
do
|
|
{
|
|
line = stream.readLine();
|
|
if (!line.isNull())
|
|
{
|
|
if (line.contains("<svg") && line.contains(">")) // TODO UB 4.6, this is naive ... the SVG tag may be on several lines
|
|
{
|
|
lines << "<?xml-stylesheet type=\"text/css\" href=\"" + UBSettings::settings()->documentPlayerCssUrl + "\" ?>";
|
|
lines << line;
|
|
lines << "";
|
|
lines << " <script type=\"text/ecmascript\" xlink:href=\"" + UBSettings::settings()->documentPlayerScriptUrl + "\"/>";
|
|
lines << " <script type=\"text/ecmascript\" xlink:href=\"" + UBSettings::settings()->documentPlayerPageScriptUrl + "\"/>";
|
|
lines << "";
|
|
}
|
|
else
|
|
{
|
|
lines << line;
|
|
}
|
|
}
|
|
}
|
|
while (!line.isNull());
|
|
|
|
svgFile.resize(0);
|
|
svgFile.write(lines.join("\n").toUtf8()); // TODO UB 4.x detect real html encoding
|
|
|
|
svgFile.close();
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
void UBDocumentPublisher::generateWidgetPropertyScript(UBGraphicsW3CWidgetItem *widgetItem, int pageNumber)
|
|
{
|
|
|
|
QMap<QString, QString> preferences = widgetItem->preferences();
|
|
QMap<QString, QString> datastoreEntries = widgetItem->datastoreEntries();
|
|
|
|
QString startFileName = widgetItem->w3cWidget()->mainHtmlFileName();
|
|
|
|
if (!startFileName.startsWith("http://"))
|
|
{
|
|
QString startFilePath = mPublishingDocument->persistencePath() + "/"
|
|
+ UBPersistenceManager::widgetDirectory + "/"
|
|
+ widgetItem->uuid().toString() + ".wgt/" + startFileName;
|
|
|
|
QFile startFile(startFilePath);
|
|
|
|
if(startFile.exists())
|
|
{
|
|
if(startFile.open(QIODevice::ReadWrite))
|
|
{
|
|
QTextStream stream(&startFile);
|
|
QStringList lines;
|
|
|
|
bool addedJs = false;
|
|
|
|
QString line;
|
|
do
|
|
{
|
|
line = stream.readLine();
|
|
if (!line.isNull())
|
|
{
|
|
lines << line;
|
|
|
|
if (!addedJs && line.contains("<head") && line.contains(">") ) // TODO UB 4.6, this is naive ... the HEAD tag may be on several lines
|
|
{
|
|
lines << "";
|
|
lines << " <script type=\"text/javascript\">";
|
|
|
|
lines << " var widget = {};";
|
|
lines << " widget.id = '" + widgetItem->w3cWidget()->metadatas().id + "';";
|
|
lines << " widget.name = '" + widgetItem->w3cWidget()->metadatas().name + "';";
|
|
lines << " widget.description = '" + widgetItem->w3cWidget()->metadatas().description + "';";
|
|
lines << " widget.author = '" + widgetItem->w3cWidget()->metadatas().author + "';";
|
|
lines << " widget.authorEmail = '" + widgetItem->w3cWidget()->metadatas().authorEmail + "';";
|
|
lines << " widget.authorHref = '" + widgetItem->w3cWidget()->metadatas().authorHref + "';";
|
|
lines << " widget.version = '" + widgetItem->w3cWidget()->metadatas().version + "';";
|
|
|
|
lines << " widget.uuid = '" + UBStringUtils::toCanonicalUuid(widgetItem->uuid()) + "';";
|
|
|
|
lines << " widget.width = " + QString("%1").arg(widgetItem->w3cWidget()->width()) + ";";
|
|
lines << " widget.height = " + QString("%1").arg(widgetItem->w3cWidget()->height()) + ";";
|
|
lines << " widget.openUrl = function(url) { window.open(url); }";
|
|
lines << " widget.preferences = new Array()";
|
|
|
|
foreach(QString pref, preferences.keys())
|
|
{
|
|
lines << " widget.preferences['" + pref + "'] = '" + preferences.value(pref) + "';";
|
|
}
|
|
|
|
lines << " widget.preferences.key = function(index) {";
|
|
lines << " var currentIndex = 0;";
|
|
lines << " for(key in widget.preferences){";
|
|
lines << " if (currentIndex == index){ return key;}";
|
|
lines << " currentIndex++;";
|
|
lines << " }";
|
|
lines << " return '';";
|
|
lines << " }";
|
|
|
|
lines << " widget.preferences.getItem = function(key) {";
|
|
lines << " return widget.preferences[key];";
|
|
lines << " }";
|
|
|
|
lines << " widget.preferences.setItem = function(key, value) {}";
|
|
lines << " widget.preferences.removeItem = function(key) {}";
|
|
lines << " widget.preferences.clear = function() {}";
|
|
|
|
lines << " var uniboard = {};";
|
|
lines << " uniboard.pageCount = " + QString("%1").arg(mPublishingDocument->pageCount()) + ";";
|
|
lines << " uniboard.currentPageNumber = " + QString("%1").arg(pageNumber) + ";";
|
|
lines << " uniboard.uuid = '" + UBStringUtils::toCanonicalUuid(widgetItem->uuid()) + "'";
|
|
lines << " uniboard.lang = navigator.language;";
|
|
lines << " uniboard.locale = function() {return navigator.language}";
|
|
lines << " uniboard.messages = {}";
|
|
lines << " uniboard.messages.subscribeToTopic = function(topicName){}";
|
|
lines << " uniboard.messages.unsubscribeFromTopic = function(topicName){}";
|
|
lines << " uniboard.messages.sendMessage = function(topicName, message){}";
|
|
|
|
lines << " uniboard.datastore = {};";
|
|
lines << " uniboard.datastore.document = new Array();";
|
|
foreach(QString entry, datastoreEntries.keys())
|
|
{
|
|
lines << " uniboard.datastore.document['" + entry + "'] = '" + datastoreEntries.value(entry) + "';";
|
|
}
|
|
|
|
lines << " uniboard.datastore.document.key = function(index) {";
|
|
lines << " var currentIndex = 0;";
|
|
lines << " for(key in uniboard.datastore.document){";
|
|
lines << " if (currentIndex == index){ return key;}";
|
|
lines << " currentIndex++;";
|
|
lines << " }";
|
|
lines << " return '';";
|
|
lines << " }";
|
|
|
|
lines << " uniboard.datastore.document.getItem = function(key) {";
|
|
lines << " return uniboard.datastore.document[key];";
|
|
lines << " }";
|
|
|
|
lines << " uniboard.datastore.document.setItem = function(key, value) {}";
|
|
lines << " uniboard.datastore.document.removeItem = function(key) {}";
|
|
lines << " uniboard.datastore.document.clear = function() {}";
|
|
|
|
lines << " uniboard.setTool = function(tool){}";
|
|
lines << " uniboard.setPenColor = function(color){}";
|
|
lines << " uniboard.setMarkerColor = function(color){}";
|
|
|
|
lines << " uniboard.pageThumbnail = function(pageNumber){";
|
|
lines << " var nb;";
|
|
lines << " if (pageNumber < 10) return 'page00' + pageNumber + '.thumbnail.jpg';";
|
|
lines << " if (pageNumber < 100) return 'page0' + pageNumber + '.thumbnail.jpg';";
|
|
lines << " return 'page' + pageNumber + '.thumbnail.jpg;'";
|
|
lines << " }";
|
|
|
|
lines << " uniboard.zoom = function(factor, x, y){}";
|
|
lines << " uniboard.move = function(x, y){}";
|
|
lines << " uniboard.move = function(x, y){}";
|
|
lines << " uniboard.moveTo = function(x, y){}";
|
|
lines << " uniboard.drawLineTo = function(x, y, width){}";
|
|
lines << " uniboard.eraseLineTo = function(x, y, width){}";
|
|
lines << " uniboard.clear = function(){}";
|
|
lines << " uniboard.setBackground = function(dark, crossed){}";
|
|
lines << " uniboard.addObject = function(url, width, height, x, y, background){}";
|
|
lines << " uniboard.resize = function(width, height){window.resizeTo(width, height);}";
|
|
|
|
lines << " uniboard.showMessage = function(message){alert(message);}";
|
|
lines << " uniboard.centerOn = function(x, y){}";
|
|
lines << " uniboard.addText = function(text, x, y){}";
|
|
|
|
lines << " uniboard.setPreference = function(key, value){}";
|
|
lines << " uniboard.preference = function(key, defValue){";
|
|
lines << " var pref = widget.preferences[key];";
|
|
lines << " if (pref == undefined) ";
|
|
lines << " return defValue;";
|
|
lines << " else ";
|
|
lines << " return pref;";
|
|
lines << " }";
|
|
lines << " uniboard.preferenceKeys = function(){";
|
|
lines << " var keys = new Array();";
|
|
lines << " for(key in widget.preferences){";
|
|
lines << " keys.push(key);";
|
|
lines << " }";
|
|
lines << " return keys;";
|
|
lines << " }";
|
|
|
|
lines << " uniboard.datastore.document.key = function(index) {";
|
|
lines << " var currentIndex = 0;";
|
|
lines << " for(key in uniboard.datastore.document){";
|
|
lines << " if (currentIndex == index){ return key;}";
|
|
lines << " currentIndex++;";
|
|
lines << " }";
|
|
lines << " return '';";
|
|
lines << " }";
|
|
|
|
lines << " uniboard.datastore.document.getItem = function(key) {";
|
|
lines << " return uniboard.datastore.document[key];";
|
|
lines << " }";
|
|
|
|
lines << " uniboard.datastore.document.setItem = function(key, value) {}";
|
|
lines << " uniboard.datastore.document.removeItem = function(key) {}";
|
|
lines << " uniboard.datastore.document.clear = function() {}";
|
|
|
|
lines << " </script>";
|
|
lines << "";
|
|
|
|
addedJs = true;
|
|
}
|
|
}
|
|
}
|
|
while (!line.isNull());
|
|
|
|
startFile.resize(0);
|
|
startFile.write(lines.join("\n").toUtf8()); // TODO UB 4.x detect real html encoding
|
|
|
|
startFile.close();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qWarning() << "Remote Widget start file, cannot inject widget preferences and datastore entries";
|
|
}
|
|
}
|
|
|
|
|
|
void UBDocumentPublisher::sendZipToUniboardWeb(const QString& zipFilePath, const QUuid& publishingUuid)
|
|
{
|
|
QFile zipFile(zipFilePath);
|
|
|
|
if(!zipFile.open(QIODevice::ReadOnly))
|
|
{
|
|
qWarning() << "Cannot open file" << zipFilePath << "for upload to Uniboard Web";
|
|
return;
|
|
}
|
|
|
|
QUrl publishingEndpoint = QUrl(mPublishingServiceUrl);
|
|
|
|
mUploadRequest = new UBServerXMLHttpRequest(UBNetworkAccessManager::defaultAccessManager()
|
|
, "application/octet-stream");
|
|
|
|
mUploadRequest->setVerbose(true);
|
|
|
|
connect(mUploadRequest, SIGNAL(progress(qint64, qint64)), this, SLOT(uploadProgress(qint64, qint64)));
|
|
connect(mUploadRequest, SIGNAL(finished(bool, const QByteArray&)), this, SLOT(postZipUploadResponse(bool, const QByteArray&)));
|
|
|
|
mUploadRequest->addHeader("Publishing-UUID", UBStringUtils::toCanonicalUuid(publishingUuid));
|
|
mUploadRequest->addHeader("Document-UUID", UBStringUtils::toCanonicalUuid(mSourceDocument->uuid()));
|
|
mUploadRequest->addHeader("Document-PageCount", QString("%1").arg(mSourceDocument->pageCount()));
|
|
mUploadRequest->addHeader("Document-Title", mTitle);
|
|
mUploadRequest->addHeader("Document-Author", mAuthor);
|
|
mUploadRequest->addHeader("Document-AuthorEMail", mEMail);
|
|
mUploadRequest->addHeader("Document-Description", mDescription);
|
|
mUploadRequest->addHeader("Deletion-Token", UBStringUtils::toCanonicalUuid(QUuid::createUuid()));
|
|
mUploadRequest->addHeader("Token-UUID", UBStringUtils::toCanonicalUuid(mAuthenticationUuid));
|
|
mUploadRequest->addHeader("Token-Encrypted", mAuthenticationBase64Token);
|
|
|
|
mUploadRequest->post(publishingEndpoint, zipFile.readAll());
|
|
|
|
zipFile.remove();
|
|
}
|
|
|
|
|
|
void UBDocumentPublisher::uploadProgress(qint64 bytesSent, qint64 bytesTotal)
|
|
{
|
|
int percentage = (((qreal)bytesSent / (qreal)bytesTotal ) * 100);
|
|
|
|
if (bytesSent < bytesTotal)
|
|
UBApplication::showMessage(tr("Upload to Uniboard Web in progress %1 %").arg(percentage), true);
|
|
else
|
|
UBApplication::showMessage(tr("Sending document ..."), true);
|
|
|
|
}
|
|
|
|
|
|
void UBDocumentPublisher::postZipUploadResponse(bool success, const QByteArray& payload)
|
|
{
|
|
if (success)
|
|
{
|
|
UBApplication::showMessage(tr("The document has been sent to %1").arg(UBSettings::settings()->uniboardWebUrl->get().toString()), false);
|
|
}
|
|
else
|
|
{
|
|
qWarning() << "error uploading document to Uniboard Web" << QString::fromUtf8(payload);
|
|
|
|
QString errorMessage = QString::fromUtf8(payload);
|
|
|
|
if (errorMessage.length() == 0)
|
|
UBApplication::showMessage(tr("Error while publishing document to %1")
|
|
.arg(UBSettings::settings()->uniboardWebUrl->get().toString()), false);
|
|
else
|
|
UBApplication::showMessage(tr("Error while publishing document to %1 : (%2)")
|
|
.arg(UBSettings::settings()->uniboardWebUrl->get().toString())
|
|
.arg(errorMessage), false);
|
|
}
|
|
|
|
QApplication::restoreOverrideCursor();
|
|
|
|
deleteLater();
|
|
}
|
|
|
|
|
|
UBDocumentPublishingDialog::UBDocumentPublishingDialog(QWidget *parent)
|
|
: QDialog(parent)
|
|
{
|
|
Ui::documentPublishingDialog::setupUi(this);
|
|
|
|
connect(dialogButtons, SIGNAL(accepted()), this, SLOT(accept()));
|
|
connect(dialogButtons, SIGNAL(rejected()), this, SLOT(reject()));
|
|
|
|
connect(title, SIGNAL(textChanged(const QString&)), this, SLOT(updateUIState(const QString&)));
|
|
connect(email, SIGNAL(textChanged(const QString&)), this, SLOT(updateUIState(const QString&)));
|
|
|
|
dialogButtons->button(QDialogButtonBox::Ok)->setEnabled(false);
|
|
dialogButtons->button(QDialogButtonBox::Ok)->setText(tr("Publish"));
|
|
}
|
|
|
|
|
|
void UBDocumentPublishingDialog::updateUIState(const QString& string)
|
|
{
|
|
Q_UNUSED(string);
|
|
|
|
bool ok = title->text().length() > 0
|
|
&& email->text().length() > 0;
|
|
|
|
dialogButtons->button(QDialogButtonBox::Ok)->setEnabled(ok);
|
|
}
|
|
|