Move qt-ui to desktop-widgets

Since we have now destkop and mobile versions, 'qt-ui' was a very
poor name choice for a folder that contains only destkop-enabled
widgets.

Also, move the graphicsview-common.h/cpp to subsurface-core because
it doesn't depend on qgraphicsview, it merely implements all the
colors that we use throughout Subsurface, and we will use colors on both
desktop and mobile versions

Same thing applies for metrics.h/cpp

Signed-off-by: Tomaz Canabrava <tomaz.canabrava@intel.com>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>

1 files changed, 1121 insertions, 0 deletions

diff --git a/desktop-widgets/subsurfacewebservices.cpp b/desktop-widgets/subsurfacewebservices.cpp
new file mode 100644
index 000000000..ee079cc48
--- /dev/null
+++ b/desktop-widgets/subsurfacewebservices.cpp
@@ -0,0 +1,1121 @@
+#include "subsurfacewebservices.h"
+#include "helpers.h"
+#include "webservice.h"
+#include "mainwindow.h"
+#include "usersurvey.h"
+#include "divelist.h"
+#include "globe.h"
+#include "maintab.h"
+#include "display.h"
+#include "membuffer.h"
+#include <errno.h>
+
+#include <QDir>
+#include <QHttpMultiPart>
+#include <QMessageBox>
+#include <QSettings>
+#include <QXmlStreamReader>
+#include <qdesktopservices.h>
+#include <QShortcut>
+#include <QDebug>
+
+#ifdef Q_OS_UNIX
+#include <unistd.h> // for dup(2)
+#endif
+
+#include <QUrlQuery>
+
+#ifndef PATH_MAX
+#define PATH_MAX 4096
+#endif
+
+struct dive_table gps_location_table;
+
+// we don't overwrite any existing GPS info in the dive
+// so get the dive site and if there is none or there is one without GPS fix, add it
+static void copy_gps_location(struct dive *from, struct dive *to)
+{
+	struct dive_site *ds = get_dive_site_for_dive(to);
+	if (!ds || !dive_site_has_gps_location(ds)) {
+		struct dive_site *gds = get_dive_site_for_dive(from);
+		if (!ds) {
+			// simply link to the one created for the fake dive
+			to->dive_site_uuid = gds->uuid;
+		} else {
+			ds->latitude = gds->latitude;
+			ds->longitude = gds->longitude;
+			if (same_string(ds->name, ""))
+				ds->name = copy_string(gds->name);
+		}
+	}
+}
+
+#define SAME_GROUP 6 * 3600 // six hours
+//TODO: C Code. static functions are not good if we plan to have a test for them.
+static bool merge_locations_into_dives(void)
+{
+	int i, j, tracer=0, changed=0;
+	struct dive *gpsfix, *nextgpsfix, *dive;
+
+	sort_table(&gps_location_table);
+
+	for_each_dive (i, dive) {
+		if (!dive_has_gps_location(dive)) {
+			for (j = tracer; (gpsfix = get_dive_from_table(j, &gps_location_table)) !=NULL; j++) {
+				if (time_during_dive_with_offset(dive, gpsfix->when, SAME_GROUP)) {
+					if (verbose)
+						qDebug() << "processing gpsfix @" << get_dive_date_string(gpsfix->when) <<
+							    "which is withing six hours of dive from" <<
+							    get_dive_date_string(dive->when) << "until" <<
+							    get_dive_date_string(dive->when + dive->duration.seconds);
+					/*
+					 * If position is fixed during dive. This is the good one.
+					 * Asign and mark position, and end gps_location loop
+					 */
+					if (time_during_dive_with_offset(dive, gpsfix->when, 0)) {
+						if (verbose)
+							qDebug() << "gpsfix is during the dive, pick that one";
+						copy_gps_location(gpsfix, dive);
+						changed++;
+						tracer = j;
+						break;
+					} else {
+						/*
+						 * If it is not, check if there are more position fixes in SAME_GROUP range
+						 */
+						if ((nextgpsfix = get_dive_from_table(j + 1, &gps_location_table)) &&
+						    time_during_dive_with_offset(dive, nextgpsfix->when, SAME_GROUP)) {
+							if (verbose)
+								qDebug() << "look at the next gps fix @" << get_dive_date_string(nextgpsfix->when);
+							/* first let's test if this one is during the dive */
+							if (time_during_dive_with_offset(dive, nextgpsfix->when, 0)) {
+								if (verbose)
+									qDebug() << "which is during the dive, pick that one";
+								copy_gps_location(nextgpsfix, dive);
+								changed++;
+								tracer = j + 1;
+								break;
+							}
+							/* we know the gps fixes are sorted; if they are both before the dive, ignore the first,
+							 * if theay are both after the dive, take the first,
+							 * if the first is before and the second is after, take the closer one */
+							if (nextgpsfix->when < dive->when) {
+								if (verbose)
+									qDebug() << "which is closer to the start of the dive, do continue with that";
+								continue;
+							} else if (gpsfix->when > dive->when + dive->duration.seconds) {
+								if (verbose)
+									qDebug() << "which is even later after the end of the dive, so pick the previous one";
+								copy_gps_location(gpsfix, dive);
+								changed++;
+								tracer = j;
+								break;
+							} else {
+								/* ok, gpsfix is before, nextgpsfix is after */
+								if (dive->when - gpsfix->when <= nextgpsfix->when - (dive->when + dive->duration.seconds)) {
+									if (verbose)
+										qDebug() << "pick the one before as it's closer to the start";
+									copy_gps_location(gpsfix, dive);
+									changed++;
+									tracer = j;
+									break;
+								} else {
+									if (verbose)
+										qDebug() << "pick the one after as it's closer to the start";
+									copy_gps_location(nextgpsfix, dive);
+									changed++;
+									tracer = j + 1;
+									break;
+								}
+							}
+						/*
+						 * If no more positions in range, the actual is the one. Asign, mark and end loop.
+						 */
+						} else {
+							if (verbose)
+								qDebug() << "which seems to be the best one for this dive, so pick it";
+							copy_gps_location(gpsfix, dive);
+							changed++;
+							tracer = j;
+							break;
+						}
+					}
+				} else {
+					/* If position is out of SAME_GROUP range and in the future, mark position for
+					 * next dive iteration and end the gps_location loop
+					 */
+					if (gpsfix->when >= dive->when + dive->duration.seconds + SAME_GROUP) {
+						tracer = j;
+						break;
+					}
+				}
+			}
+		}
+	}
+	return changed > 0;
+}
+
+// TODO: This looks like should be ported to C code. or a big part of it.
+bool DivelogsDeWebServices::prepare_dives_for_divelogs(const QString &tempfile, const bool selected)
+{
+	static const char errPrefix[] = "divelog.de-upload:";
+	if (!amount_selected) {
+		report_error(tr("no dives were selected").toUtf8());
+		return false;
+	}
+
+	xsltStylesheetPtr xslt = NULL;
+	struct zip *zip;
+
+	xslt = get_stylesheet("divelogs-export.xslt");
+	if (!xslt) {
+		qDebug() << errPrefix << "missing stylesheet";
+		report_error(tr("stylesheet to export to divelogs.de is not found").toUtf8());
+		return false;
+	}
+
+
+	int error_code;
+	zip = zip_open(QFile::encodeName(QDir::toNativeSeparators(tempfile)), ZIP_CREATE, &error_code);
+	if (!zip) {
+		char buffer[1024];
+		zip_error_to_str(buffer, sizeof buffer, error_code, errno);
+		report_error(tr("failed to create zip file for upload: %s").toUtf8(), buffer);
+		return false;
+	}
+
+	/* walk the dive list in chronological order */
+	int i;
+	struct dive *dive;
+	for_each_dive (i, dive) {
+		FILE *f;
+		char filename[PATH_MAX];
+		int streamsize;
+		const char *membuf;
+		xmlDoc *transformed;
+		struct zip_source *s;
+		struct membuffer mb = { 0 };
+
+		/*
+		 * Get the i'th dive in XML format so we can process it.
+		 * We need to save to a file before we can reload it back into memory...
+		 */
+		if (selected && !dive->selected)
+			continue;
+		/* make sure the buffer is empty and add the dive */
+		mb.len = 0;
+
+		struct dive_site *ds = get_dive_site_by_uuid(dive->dive_site_uuid);
+
+		if (ds) {
+			put_format(&mb, "<divelog><divesites><site uuid='%8x' name='", dive->dive_site_uuid);
+			put_quoted(&mb, ds->name, 1, 0);
+			put_format(&mb, "'");
+			if (ds->latitude.udeg || ds->longitude.udeg) {
+				put_degrees(&mb, ds->latitude, " gps='", " ");
+				put_degrees(&mb, ds->longitude, "", "'");
+			}
+			put_format(&mb, "/>\n</divesites>\n");
+		}
+
+		save_one_dive_to_mb(&mb, dive);
+
+		if (ds) {
+			put_format(&mb, "</divelog>\n");
+		}
+		membuf = mb_cstring(&mb);
+		streamsize = strlen(membuf);
+		/*
+		 * Parse the memory buffer into XML document and
+		 * transform it to divelogs.de format, finally dumping
+		 * the XML into a character buffer.
+		 */
+		xmlDoc *doc = xmlReadMemory(membuf, streamsize, "divelog", NULL, 0);
+		if (!doc) {
+			qWarning() << errPrefix << "could not parse back into memory the XML file we've just created!";
+			report_error(tr("internal error").toUtf8());
+			goto error_close_zip;
+		}
+		free((void *)membuf);
+
+		transformed = xsltApplyStylesheet(xslt, doc, NULL);
+		if (!transformed) {
+			qWarning() << errPrefix << "XSLT transform failed for dive: " << i;
+			report_error(tr("Conversion of dive %1 to divelogs.de format failed").arg(i).toUtf8());
+			continue;
+		}
+		xmlDocDumpMemory(transformed, (xmlChar **)&membuf, &streamsize);
+		xmlFreeDoc(doc);
+		xmlFreeDoc(transformed);
+
+		/*
+		 * Save the XML document into a zip file.
+		 */
+		snprintf(filename, PATH_MAX, "%d.xml", i + 1);
+		s = zip_source_buffer(zip, membuf, streamsize, 1);
+		if (s) {
+			int64_t ret = zip_add(zip, filename, s);
+			if (ret == -1)
+				qDebug() << errPrefix << "failed to include dive:" << i;
+		}
+	}
+	xsltFreeStylesheet(xslt);
+	if (zip_close(zip)) {
+		int ze, se;
+#if LIBZIP_VERSION_MAJOR >= 1
+		zip_error_t *error = zip_get_error(zip);
+		ze = zip_error_code_zip(error);
+		se = zip_error_code_system(error);
+#else
+		zip_error_get(zip, &ze, &se);
+#endif
+		report_error(qPrintable(tr("error writing zip file: %s zip error %d system error %d - %s")),
+			     qPrintable(QDir::toNativeSeparators(tempfile)), ze, se, zip_strerror(zip));
+		return false;
+	}
+	return true;
+
+error_close_zip:
+	zip_close(zip);
+	QFile::remove(tempfile);
+	xsltFreeStylesheet(xslt);
+	return false;
+}
+
+WebServices::WebServices(QWidget *parent, Qt::WindowFlags f) : QDialog(parent, f), reply(0)
+{
+	ui.setupUi(this);
+	connect(ui.buttonBox, SIGNAL(clicked(QAbstractButton *)), this, SLOT(buttonClicked(QAbstractButton *)));
+	connect(ui.download, SIGNAL(clicked(bool)), this, SLOT(startDownload()));
+	connect(ui.upload, SIGNAL(clicked(bool)), this, SLOT(startUpload()));
+	connect(&timeout, SIGNAL(timeout()), this, SLOT(downloadTimedOut()));
+	ui.buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
+	timeout.setSingleShot(true);
+	defaultApplyText = ui.buttonBox->button(QDialogButtonBox::Apply)->text();
+	userAgent = getUserAgent();
+}
+
+void WebServices::hidePassword()
+{
+	ui.password->hide();
+	ui.passLabel->hide();
+}
+
+void WebServices::hideUpload()
+{
+	ui.upload->hide();
+	ui.download->show();
+}
+
+void WebServices::hideDownload()
+{
+	ui.download->hide();
+	ui.upload->show();
+}
+
+QNetworkAccessManager *WebServices::manager()
+{
+	static QNetworkAccessManager *manager = new QNetworkAccessManager(qApp);
+	return manager;
+}
+
+void WebServices::downloadTimedOut()
+{
+	if (!reply)
+		return;
+
+	reply->deleteLater();
+	reply = NULL;
+	resetState();
+	ui.status->setText(tr("Operation timed out"));
+}
+
+void WebServices::updateProgress(qint64 current, qint64 total)
+{
+	if (!reply)
+		return;
+	if (total == -1) {
+		total = INT_MAX / 2 - 1;
+	}
+	if (total >= INT_MAX / 2) {
+		// over a gigabyte!
+		if (total >= Q_INT64_C(1) << 47) {
+			total >>= 16;
+			current >>= 16;
+		}
+		total >>= 16;
+		current >>= 16;
+	}
+	ui.progressBar->setRange(0, total);
+	ui.progressBar->setValue(current);
+	ui.status->setText(tr("Transferring data..."));
+
+	// reset the timer: 30 seconds after we last got any data
+	timeout.start();
+}
+
+void WebServices::connectSignalsForDownload(QNetworkReply *reply)
+{
+	connect(reply, SIGNAL(finished()), this, SLOT(downloadFinished()));
+	connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
+		this, SLOT(downloadError(QNetworkReply::NetworkError)));
+	connect(reply, SIGNAL(downloadProgress(qint64, qint64)), this,
+		SLOT(updateProgress(qint64, qint64)));
+
+	timeout.start(30000); // 30s
+}
+
+void WebServices::resetState()
+{
+	ui.download->setEnabled(true);
+	ui.upload->setEnabled(true);
+	ui.userID->setEnabled(true);
+	ui.password->setEnabled(true);
+	ui.progressBar->reset();
+	ui.progressBar->setRange(0, 1);
+	ui.status->setText(QString());
+	ui.buttonBox->button(QDialogButtonBox::Apply)->setText(defaultApplyText);
+}
+
+// #
+// #
+// #		Subsurface Web Service Implementation.
+// #
+// #
+
+SubsurfaceWebServices::SubsurfaceWebServices(QWidget *parent, Qt::WindowFlags f) : WebServices(parent, f)
+{
+	QSettings s;
+	if (!prefs.save_userid_local || !*prefs.userid)
+		ui.userID->setText(s.value("subsurface_webservice_uid").toString().toUpper());
+	else
+		ui.userID->setText(prefs.userid);
+	hidePassword();
+	hideUpload();
+	ui.progressBar->setFormat(tr("Enter User ID and click Download"));
+	ui.progressBar->setRange(0, 1);
+	ui.progressBar->setValue(-1);
+	ui.progressBar->setAlignment(Qt::AlignCenter);
+	ui.saveUidLocal->setChecked(prefs.save_userid_local);
+	QShortcut *close = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_W), this);
+	connect(close, SIGNAL(activated()), this, SLOT(close()));
+	QShortcut *quit = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q), this);
+	connect(quit, SIGNAL(activated()), parent, SLOT(close()));
+}
+
+void SubsurfaceWebServices::buttonClicked(QAbstractButton *button)
+{
+	ui.buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
+	switch (ui.buttonBox->buttonRole(button)) {
+	case QDialogButtonBox::ApplyRole: {
+		int i;
+		struct dive *d;
+		struct dive_site *ds;
+		bool changed = false;
+		clear_table(&gps_location_table);
+		QByteArray url = tr("Webservice").toLocal8Bit();
+		parse_xml_buffer(url.data(), downloadedData.data(), downloadedData.length(), &gps_location_table, NULL);
+		// make sure we mark all the dive sites that were created
+		for (i = 0; i < gps_location_table.nr; i++) {
+			d = get_dive_from_table(i, &gps_location_table);
+			ds = get_dive_site_by_uuid(d->dive_site_uuid);
+			if (ds)
+				ds->notes = strdup("SubsurfaceWebservice");
+		}
+		/* now merge the data in the gps_location table into the dive_table */
+		if (merge_locations_into_dives()) {
+			changed = true;
+			mark_divelist_changed(true);
+			MainWindow::instance()->information()->updateDiveInfo();
+		}
+
+		/* store last entered uid in config */
+		QSettings s;
+		QString qDialogUid = ui.userID->text().toUpper();
+		bool qSaveUid = ui.saveUidLocal->checkState();
+		set_save_userid_local(qSaveUid);
+		if (qSaveUid) {
+			QString qSettingUid = s.value("subsurface_webservice_uid").toString();
+			QString qFileUid = QString(prefs.userid);
+			bool s_eq_d = (qSettingUid == qDialogUid);
+			bool d_eq_f = (qDialogUid == qFileUid);
+			if (!d_eq_f || s_eq_d)
+				s.setValue("subsurface_webservice_uid", qDialogUid);
+			set_userid(qDialogUid.toLocal8Bit().data());
+		} else {
+			s.setValue("subsurface_webservice_uid", qDialogUid);
+		}
+		s.sync();
+		hide();
+		close();
+		resetState();
+		/* and now clean up and remove all the extra dive sites that were created */
+		QSet<uint32_t> usedUuids;
+		for_each_dive(i, d) {
+			if (d->dive_site_uuid)
+				usedUuids.insert(d->dive_site_uuid);
+		}
+		for_each_dive_site(i, ds) {
+			if (!usedUuids.contains(ds->uuid) && same_string(ds->notes, "SubsurfaceWebservice")) {
+				delete_dive_site(ds->uuid);
+				i--; // otherwise we skip one site
+			}
+		}
+#ifndef NO_MARBLE
+		// finally now that all the extra GPS fixes that weren't used have been deleted
+		// we can update the globe
+		if (changed) {
+			GlobeGPS::instance()->repopulateLabels();
+			GlobeGPS::instance()->centerOnDiveSite(get_dive_site_by_uuid(current_dive->dive_site_uuid));
+		}
+#endif
+
+	} break;
+	case QDialogButtonBox::RejectRole:
+		if (reply != NULL && reply->isOpen()) {
+			reply->abort();
+			delete reply;
+			reply = NULL;
+		}
+		resetState();
+		break;
+	case QDialogButtonBox::HelpRole:
+		QDesktopServices::openUrl(QUrl("http://api.hohndel.org"));
+		break;
+	default:
+		break;
+	}
+}
+
+void SubsurfaceWebServices::startDownload()
+{
+	QUrl url("http://api.hohndel.org/api/dive/get/");
+	QUrlQuery query;
+	query.addQueryItem("login", ui.userID->text().toUpper());
+	url.setQuery(query);
+
+	QNetworkRequest request;
+	request.setUrl(url);
+	request.setRawHeader("Accept", "text/xml");
+	request.setRawHeader("User-Agent", userAgent.toUtf8());
+	reply = manager()->get(request);
+	ui.status->setText(tr("Connecting..."));
+	ui.progressBar->setEnabled(true);
+	ui.progressBar->setRange(0, 0); // this makes the progressbar do an 'infinite spin'
+	ui.download->setEnabled(false);
+	ui.buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
+	connectSignalsForDownload(reply);
+}
+
+void SubsurfaceWebServices::downloadFinished()
+{
+	if (!reply)
+		return;
+
+	ui.progressBar->setRange(0, 1);
+	ui.progressBar->setValue(1);
+	ui.progressBar->setFormat("%p%");
+	downloadedData = reply->readAll();
+
+	ui.download->setEnabled(true);
+	ui.status->setText(tr("Download finished"));
+
+	uint resultCode = download_dialog_parse_response(downloadedData);
+	setStatusText(resultCode);
+	if (resultCode == DD_STATUS_OK) {
+		ui.buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
+	}
+	reply->deleteLater();
+	reply = NULL;
+}
+
+void SubsurfaceWebServices::downloadError(QNetworkReply::NetworkError)
+{
+	resetState();
+	ui.status->setText(tr("Download error: %1").arg(reply->errorString()));
+	reply->deleteLater();
+	reply = NULL;
+}
+
+void SubsurfaceWebServices::setStatusText(int status)
+{
+	QString text;
+	switch (status) {
+	case DD_STATUS_ERROR_CONNECT:
+		text = tr("Connection error: ");
+		break;
+	case DD_STATUS_ERROR_ID:
+		text = tr("Invalid user identifier!");
+		break;
+	case DD_STATUS_ERROR_PARSE:
+		text = tr("Cannot parse response!");
+		break;
+	case DD_STATUS_OK:
+		text = tr("Download successful");
+		break;
+	}
+	ui.status->setText(text);
+}
+
+//TODO: C-Code.
+/* requires that there is a <download> or <error> tag under the <root> tag */
+void SubsurfaceWebServices::download_dialog_traverse_xml(xmlNodePtr node, unsigned int *download_status)
+{
+	xmlNodePtr cur_node;
+	for (cur_node = node; cur_node; cur_node = cur_node->next) {
+		if ((!strcmp((const char *)cur_node->name, (const char *)"download")) &&
+		    (!strcmp((const char *)xmlNodeGetContent(cur_node), (const char *)"ok"))) {
+			*download_status = DD_STATUS_OK;
+			return;
+		} else if (!strcmp((const char *)cur_node->name, (const char *)"error")) {
+			*download_status = DD_STATUS_ERROR_ID;
+			return;
+		}
+	}
+}
+
+// TODO: C-Code
+unsigned int SubsurfaceWebServices::download_dialog_parse_response(const QByteArray &xml)
+{
+	xmlNodePtr root;
+	xmlDocPtr doc = xmlParseMemory(xml.data(), xml.length());
+	unsigned int status = DD_STATUS_ERROR_PARSE;
+
+	if (!doc)
+		return DD_STATUS_ERROR_PARSE;
+	root = xmlDocGetRootElement(doc);
+	if (!root) {
+		status = DD_STATUS_ERROR_PARSE;
+		goto end;
+	}
+	if (root->children)
+		download_dialog_traverse_xml(root->children, &status);
+end:
+	xmlFreeDoc(doc);
+	return status;
+}
+
+// #
+// #
+// #		Divelogs DE  Web Service Implementation.
+// #
+// #
+
+struct DiveListResult {
+	QString errorCondition;
+	QString errorDetails;
+	QByteArray idList; // comma-separated, suitable to be sent in the fetch request
+	int idCount;
+};
+
+static DiveListResult parseDiveLogsDeDiveList(const QByteArray &xmlData)
+{
+	/* XML format seems to be:
+	 * <DiveDateReader version="1.0">
+	 *   <DiveDates>
+	 *     <date diveLogsId="nnn" lastModified="YYYY-MM-DD hh:mm:ss">DD.MM.YYYY hh:mm</date>
+	 *     [repeat <date></date>]
+	 *   </DiveDates>
+	 * </DiveDateReader>
+	 */
+	QXmlStreamReader reader(xmlData);
+	const QString invalidXmlError = QObject::tr("Invalid response from server");
+	bool seenDiveDates = false;
+	DiveListResult result;
+	result.idCount = 0;
+
+	if (reader.readNextStartElement() && reader.name() != "DiveDateReader") {
+		result.errorCondition = invalidXmlError;
+		result.errorDetails =
+			QObject::tr("Expected XML tag 'DiveDateReader', got instead '%1")
+				.arg(reader.name().toString());
+		goto out;
+	}
+
+	while (reader.readNextStartElement()) {
+		if (reader.name() != "DiveDates") {
+			if (reader.name() == "Login") {
+				QString status = reader.readElementText();
+				// qDebug() << "Login status:" << status;
+
+				// Note: there has to be a better way to determine a successful login...
+				if (status == "failed") {
+					result.errorCondition = "Login failed";
+					goto out;
+				}
+			} else {
+				// qDebug() << "Skipping" << reader.name();
+			}
+			continue;
+		}
+
+		// process <DiveDates>
+		seenDiveDates = true;
+		while (reader.readNextStartElement()) {
+			if (reader.name() != "date") {
+				// qDebug() << "Skipping" << reader.name();
+				continue;
+			}
+			QStringRef id = reader.attributes().value("divelogsId");
+			// qDebug() << "Found" << reader.name() << "with id =" << id;
+			if (!id.isEmpty()) {
+				result.idList += id.toLatin1();
+				result.idList += ',';
+				++result.idCount;
+			}
+
+			reader.skipCurrentElement();
+		}
+	}
+
+	// chop the ending comma, if any
+	result.idList.chop(1);
+
+	if (!seenDiveDates) {
+		result.errorCondition = invalidXmlError;
+		result.errorDetails = QObject::tr("Expected XML tag 'DiveDates' not found");
+	}
+
+out:
+	if (reader.hasError()) {
+		// if there was an XML error, overwrite the result or other error conditions
+		result.errorCondition = invalidXmlError;
+		result.errorDetails = QObject::tr("Malformed XML response. Line %1: %2")
+						.arg(reader.lineNumber())
+						.arg(reader.errorString());
+	}
+	return result;
+}
+
+DivelogsDeWebServices *DivelogsDeWebServices::instance()
+{
+	static DivelogsDeWebServices *self = new DivelogsDeWebServices(MainWindow::instance());
+	self->setAttribute(Qt::WA_QuitOnClose, false);
+	return self;
+}
+
+void DivelogsDeWebServices::downloadDives()
+{
+	uploadMode = false;
+	resetState();
+	hideUpload();
+	exec();
+}
+
+void DivelogsDeWebServices::prepareDivesForUpload(bool selected)
+{
+	/* generate a random filename and create/open that file with zip_open */
+	QString filename = QDir::tempPath() + "/import-" + QString::number(qrand() % 99999999) + ".dld";
+	if (prepare_dives_for_divelogs(filename, selected)) {
+		QFile f(filename);
+		if (f.open(QIODevice::ReadOnly)) {
+			uploadDives((QIODevice *)&f);
+			f.close();
+			f.remove();
+			return;
+		} else {
+			report_error("Failed to open upload file %s\n", qPrintable(filename));
+		}
+	} else {
+		report_error("Failed to create upload file %s\n", qPrintable(filename));
+	}
+	MainWindow::instance()->getNotificationWidget()->showNotification(get_error_string(), KMessageWidget::Error);
+}
+
+void DivelogsDeWebServices::uploadDives(QIODevice *dldContent)
+{
+	QHttpMultiPart mp(QHttpMultiPart::FormDataType);
+	QHttpPart part;
+	QFile *f = (QFile *)dldContent;
+	QFileInfo fi(*f);
+	QString args("form-data; name=\"userfile\"; filename=\"" + fi.absoluteFilePath() + "\"");
+	part.setRawHeader("Content-Disposition", args.toLatin1());
+	part.setBodyDevice(dldContent);
+	mp.append(part);
+
+	multipart = &mp;
+	hideDownload();
+	resetState();
+	uploadMode = true;
+	ui.buttonBox->button(QDialogButtonBox::Cancel)->setEnabled(true);
+	ui.buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
+	ui.buttonBox->button(QDialogButtonBox::Apply)->setText(tr("Done"));
+	exec();
+
+	multipart = NULL;
+	if (reply != NULL && reply->isOpen()) {
+		reply->abort();
+		delete reply;
+		reply = NULL;
+	}
+}
+
+DivelogsDeWebServices::DivelogsDeWebServices(QWidget *parent, Qt::WindowFlags f) : WebServices(parent, f),
+	multipart(NULL),
+	uploadMode(false)
+{
+	QSettings s;
+	ui.userID->setText(s.value("divelogde_user").toString());
+	ui.password->setText(s.value("divelogde_pass").toString());
+	ui.saveUidLocal->hide();
+	hideUpload();
+	QShortcut *close = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_W), this);
+	connect(close, SIGNAL(activated()), this, SLOT(close()));
+	QShortcut *quit = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q), this);
+	connect(quit, SIGNAL(activated()), parent, SLOT(close()));
+}
+
+void DivelogsDeWebServices::startUpload()
+{
+	QSettings s;
+	s.setValue("divelogde_user", ui.userID->text());
+	s.setValue("divelogde_pass", ui.password->text());
+	s.sync();
+
+	ui.status->setText(tr("Uploading dive list..."));
+	ui.progressBar->setRange(0, 0); // this makes the progressbar do an 'infinite spin'
+	ui.upload->setEnabled(false);
+	ui.userID->setEnabled(false);
+	ui.password->setEnabled(false);
+
+	QNetworkRequest request;
+	request.setUrl(QUrl("https://divelogs.de/DivelogsDirectImport.php"));
+	request.setRawHeader("Accept", "text/xml, application/xml");
+	request.setRawHeader("User-Agent", userAgent.toUtf8());
+
+	QHttpPart part;
+	part.setRawHeader("Content-Disposition", "form-data; name=\"user\"");
+	part.setBody(ui.userID->text().toUtf8());
+	multipart->append(part);
+
+	part.setRawHeader("Content-Disposition", "form-data; name=\"pass\"");
+	part.setBody(ui.password->text().toUtf8());
+	multipart->append(part);
+
+	reply = manager()->post(request, multipart);
+	connect(reply, SIGNAL(finished()), this, SLOT(uploadFinished()));
+	connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this,
+		SLOT(uploadError(QNetworkReply::NetworkError)));
+	connect(reply, SIGNAL(uploadProgress(qint64, qint64)), this,
+		SLOT(updateProgress(qint64, qint64)));
+
+	timeout.start(30000); // 30s
+}
+
+void DivelogsDeWebServices::startDownload()
+{
+	ui.status->setText(tr("Downloading dive list..."));
+	ui.progressBar->setRange(0, 0); // this makes the progressbar do an 'infinite spin'
+	ui.download->setEnabled(false);
+	ui.userID->setEnabled(false);
+	ui.password->setEnabled(false);
+
+	QNetworkRequest request;
+	request.setUrl(QUrl("https://divelogs.de/xml_available_dives.php"));
+	request.setRawHeader("Accept", "text/xml, application/xml");
+	request.setRawHeader("User-Agent", userAgent.toUtf8());
+	request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
+
+	QUrlQuery body;
+	body.addQueryItem("user", ui.userID->text());
+	body.addQueryItem("pass", ui.password->text());
+
+	reply = manager()->post(request, body.query(QUrl::FullyEncoded).toLatin1());
+	connect(reply, SIGNAL(finished()), this, SLOT(listDownloadFinished()));
+	connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
+		this, SLOT(downloadError(QNetworkReply::NetworkError)));
+
+	timeout.start(30000); // 30s
+}
+
+void DivelogsDeWebServices::listDownloadFinished()
+{
+	if (!reply)
+		return;
+	QByteArray xmlData = reply->readAll();
+	reply->deleteLater();
+	reply = NULL;
+
+	// parse the XML data we downloaded
+	DiveListResult diveList = parseDiveLogsDeDiveList(xmlData);
+	if (!diveList.errorCondition.isEmpty()) {
+		// error condition
+		resetState();
+		ui.status->setText(diveList.errorCondition);
+		return;
+	}
+
+	ui.status->setText(tr("Downloading %1 dives...").arg(diveList.idCount));
+
+	QNetworkRequest request;
+	request.setUrl(QUrl("https://divelogs.de/DivelogsDirectExport.php"));
+	request.setRawHeader("Accept", "application/zip, */*");
+	request.setRawHeader("User-Agent", userAgent.toUtf8());
+	request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
+
+	QUrlQuery body;
+	body.addQueryItem("user", ui.userID->text());
+	body.addQueryItem("pass", ui.password->text());
+	body.addQueryItem("ids", diveList.idList);
+
+	reply = manager()->post(request, body.query(QUrl::FullyEncoded).toLatin1());
+	connect(reply, SIGNAL(readyRead()), this, SLOT(saveToZipFile()));
+	connectSignalsForDownload(reply);
+}
+
+void DivelogsDeWebServices::saveToZipFile()
+{
+	if (!zipFile.isOpen()) {
+		zipFile.setFileTemplate(QDir::tempPath() + "/import-XXXXXX.dld");
+		zipFile.open();
+	}
+
+	zipFile.write(reply->readAll());
+}
+
+void DivelogsDeWebServices::downloadFinished()
+{
+	if (!reply)
+		return;
+
+	ui.download->setEnabled(true);
+	ui.status->setText(tr("Download finished - %1").arg(reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString()));
+	reply->deleteLater();
+	reply = NULL;
+
+	int errorcode;
+	zipFile.seek(0);
+#if defined(Q_OS_UNIX) && defined(LIBZIP_VERSION_MAJOR)
+	int duppedfd = dup(zipFile.handle());
+	struct zip *zip = NULL;
+	if (duppedfd >= 0) {
+		zip = zip_fdopen(duppedfd, 0, &errorcode);
+		if (!zip)
+			::close(duppedfd);
+	} else {
+		QMessageBox::critical(this, tr("Problem with download"),
+				      tr("The archive could not be opened:\n"));
+		return;
+	}
+#else
+	struct zip *zip = zip_open(QFile::encodeName(zipFile.fileName()), 0, &errorcode);
+#endif
+	if (!zip) {
+		char buf[512];
+		zip_error_to_str(buf, sizeof(buf), errorcode, errno);
+		QMessageBox::critical(this, tr("Corrupted download"),
+				      tr("The archive could not be opened:\n%1").arg(QString::fromLocal8Bit(buf)));
+		zipFile.close();
+		return;
+	}
+	// now allow the user to cancel or accept
+	ui.buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
+
+	zip_close(zip);
+	zipFile.close();
+#if defined(Q_OS_UNIX) && defined(LIBZIP_VERSION_MAJOR)
+	::close(duppedfd);
+#endif
+}
+
+void DivelogsDeWebServices::uploadFinished()
+{
+	if (!reply)
+		return;
+
+	ui.progressBar->setRange(0, 1);
+	ui.upload->setEnabled(true);
+	ui.userID->setEnabled(true);
+	ui.password->setEnabled(true);
+	ui.buttonBox->button(QDialogButtonBox::Cancel)->setEnabled(false);
+	ui.buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
+	ui.buttonBox->button(QDialogButtonBox::Apply)->setText(tr("Done"));
+	ui.status->setText(tr("Upload finished"));
+
+	// check what the server sent us: it might contain
+	// an error condition, such as a failed login
+	QByteArray xmlData = reply->readAll();
+	reply->deleteLater();
+	reply = NULL;
+	char *resp = xmlData.data();
+	if (resp) {
+		char *parsed = strstr(resp, "<Login>");
+		if (parsed) {
+			if (strstr(resp, "<Login>succeeded</Login>")) {
+				if (strstr(resp, "<FileCopy>failed</FileCopy>")) {
+					ui.status->setText(tr("Upload failed"));
+					return;
+				}
+				ui.status->setText(tr("Upload successful"));
+				return;
+			}
+			ui.status->setText(tr("Login failed"));
+			return;
+		}
+		ui.status->setText(tr("Cannot parse response"));
+	}
+}
+
+void DivelogsDeWebServices::setStatusText(int status)
+{
+}
+
+void DivelogsDeWebServices::downloadError(QNetworkReply::NetworkError)
+{
+	resetState();
+	ui.status->setText(tr("Error: %1").arg(reply->errorString()));
+	reply->deleteLater();
+	reply = NULL;
+}
+
+void DivelogsDeWebServices::uploadError(QNetworkReply::NetworkError error)
+{
+	downloadError(error);
+}
+
+void DivelogsDeWebServices::buttonClicked(QAbstractButton *button)
+{
+	ui.buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
+	switch (ui.buttonBox->buttonRole(button)) {
+	case QDialogButtonBox::ApplyRole: {
+		/* in 'uploadMode' button is called 'Done' and closes the dialog */
+		if (uploadMode) {
+			hide();
+			close();
+			resetState();
+			break;
+		}
+		/* parse file and import dives */
+		parse_file(QFile::encodeName(zipFile.fileName()));
+		process_dives(true, false);
+		MainWindow::instance()->refreshDisplay();
+
+		/* store last entered user/pass in config */
+		QSettings s;
+		s.setValue("divelogde_user", ui.userID->text());
+		s.setValue("divelogde_pass", ui.password->text());
+		s.sync();
+		hide();
+		close();
+		resetState();
+	} break;
+	case QDialogButtonBox::RejectRole:
+		// these two seem to be causing a crash:
+		// reply->deleteLater();
+		resetState();
+		break;
+	case QDialogButtonBox::HelpRole:
+		QDesktopServices::openUrl(QUrl("http://divelogs.de"));
+		break;
+	default:
+		break;
+	}
+}
+
+UserSurveyServices::UserSurveyServices(QWidget *parent, Qt::WindowFlags f) : WebServices(parent, f)
+{
+
+}
+
+QNetworkReply* UserSurveyServices::sendSurvey(QString values)
+{
+	QNetworkRequest request;
+	request.setUrl(QString("http://subsurface-divelog.org/survey?%1").arg(values));
+	request.setRawHeader("Accept", "text/xml");
+	request.setRawHeader("User-Agent", userAgent.toUtf8());
+	reply = manager()->get(request);
+	return reply;
+}
+
+CloudStorageAuthenticate::CloudStorageAuthenticate(QObject *parent) :
+	QObject(parent),
+	reply(NULL)
+{
+	userAgent = getUserAgent();
+}
+
+#define CLOUDURL QString(prefs.cloud_base_url)
+#define CLOUDBACKENDSTORAGE CLOUDURL + "/storage"
+#define CLOUDBACKENDVERIFY CLOUDURL + "/verify"
+#define CLOUDBACKENDUPDATE CLOUDURL + "/update"
+
+QNetworkReply* CloudStorageAuthenticate::backend(QString email, QString password, QString pin, QString newpasswd)
+{
+	QString payload(email + " " + password);
+	QUrl requestUrl;
+	if (pin == "" && newpasswd == "") {
+		requestUrl = QUrl(CLOUDBACKENDSTORAGE);
+	} else if (newpasswd != "") {
+		requestUrl = QUrl(CLOUDBACKENDUPDATE);
+		payload += " " + newpasswd;
+	} else {
+		requestUrl = QUrl(CLOUDBACKENDVERIFY);
+		payload += " " + pin;
+	}
+	QNetworkRequest *request = new QNetworkRequest(requestUrl);
+	request->setRawHeader("Accept", "text/xml, text/plain");
+	request->setRawHeader("User-Agent", userAgent.toUtf8());
+	request->setHeader(QNetworkRequest::ContentTypeHeader, "text/plain");
+	reply = WebServices::manager()->post(*request, qPrintable(payload));
+	connect(reply, SIGNAL(finished()), this, SLOT(uploadFinished()));
+	connect(reply, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslErrors(QList<QSslError>)));
+	connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this,
+		SLOT(uploadError(QNetworkReply::NetworkError)));
+	return reply;
+}
+
+void CloudStorageAuthenticate::uploadFinished()
+{
+	static QString myLastError;
+
+	QString cloudAuthReply(reply->readAll());
+	qDebug() << "Completed connection with cloud storage backend, response" << cloudAuthReply;
+	if (cloudAuthReply == "[VERIFIED]" || cloudAuthReply == "[OK]") {
+		prefs.cloud_verification_status = CS_VERIFIED;
+		NotificationWidget *nw = MainWindow::instance()->getNotificationWidget();
+		if (nw->getNotificationText() == myLastError)
+			nw->hideNotification();
+		myLastError.clear();
+	} else if (cloudAuthReply == "[VERIFY]") {
+		prefs.cloud_verification_status = CS_NEED_TO_VERIFY;
+	} else if (cloudAuthReply == "[PASSWDCHANGED]") {
+		free(prefs.cloud_storage_password);
+		prefs.cloud_storage_password = prefs.cloud_storage_newpassword;
+		prefs.cloud_storage_newpassword = NULL;
+		emit passwordChangeSuccessful();
+		return;
+	} else {
+		prefs.cloud_verification_status = CS_INCORRECT_USER_PASSWD;
+		myLastError = cloudAuthReply;
+		report_error("%s", qPrintable(cloudAuthReply));
+		MainWindow::instance()->getNotificationWidget()->showNotification(get_error_string(), KMessageWidget::Error);
+	}
+	emit finishedAuthenticate();
+}
+
+void CloudStorageAuthenticate::uploadError(QNetworkReply::NetworkError error)
+{
+	qDebug() << "Received error response from cloud storage backend:" << reply->errorString();
+}
+
+void CloudStorageAuthenticate::sslErrors(QList<QSslError> errorList)
+{
+	if (verbose) {
+		qDebug() << "Received error response trying to set up https connection with cloud storage backend:";
+		Q_FOREACH (QSslError err, errorList) {
+			qDebug() << err.errorString();
+		}
+	}
+	QSslConfiguration conf = reply->sslConfiguration();
+	QSslCertificate cert = conf.peerCertificate();
+	QByteArray hexDigest = cert.digest().toHex();
+	if (reply->url().toString().contains(prefs.cloud_base_url) &&
+	    hexDigest == "13ff44c62996cfa5cd69d6810675490e") {
+		if (verbose)
+			qDebug() << "Overriding SSL check as I recognize the certificate digest" << hexDigest;
+		reply->ignoreSslErrors();
+	} else {
+		if (verbose)
+			qDebug() << "got invalid SSL certificate with hex digest" << hexDigest;
+	}
+}