diff options
Diffstat (limited to 'SQLiteStudio3/coreSQLiteStudio/services')
18 files changed, 555 insertions, 1382 deletions
diff --git a/SQLiteStudio3/coreSQLiteStudio/services/bugreporter.cpp b/SQLiteStudio3/coreSQLiteStudio/services/bugreporter.cpp deleted file mode 100644 index 54b0905..0000000 --- a/SQLiteStudio3/coreSQLiteStudio/services/bugreporter.cpp +++ /dev/null @@ -1,202 +0,0 @@ -#include "bugreporter.h" -#include "services/config.h" -#include "services/notifymanager.h" -#include <QNetworkAccessManager> -#include <QNetworkReply> -#include <QNetworkRequest> -#include <QUrlQuery> - -BugReporter::BugReporter(QObject *parent) : - QObject(parent) -{ - networkManager = new QNetworkAccessManager(this); - connect(networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(finished(QNetworkReply*))); -} - -QUrl BugReporter::getReporterEmailHelpUrl() const -{ - return QUrl(QString::fromLatin1(reporterEmailHelpUrl)); -} - -QUrl BugReporter::getReporterUserAndPasswordHelpUrl() const -{ - return QUrl(QString::fromLatin1(reporterUserPassHelpUrl)); -} - -void BugReporter::validateBugReportCredentials(const QString& login, const QString& password) -{ - if (credentialsValidationInProgress) - { - credentialsValidationInProgress->abort(); - credentialsValidationInProgress->deleteLater(); - } - - QUrlQuery query; - query.addQueryItem("validateUser", login); - query.addQueryItem("password", password); - - QUrl url = QUrl(QString::fromLatin1(bugReportServiceUrl) + "?" + query.query(QUrl::FullyEncoded)); - QNetworkRequest request(url); - credentialsValidationInProgress = networkManager->get(request); - replyToHandler[credentialsValidationInProgress] = [this](bool success, const QString& data) - { - if (success && data.trimmed() != "OK") - { - success = false; - emit credentialsValidationResult(success, tr("Invalid login or password")); - } - else - { - emit credentialsValidationResult(success, success ? QString() : data); - } - }; -} - -void BugReporter::abortCredentialsValidation() -{ - if (credentialsValidationInProgress) - { - credentialsValidationInProgress->abort(); - credentialsValidationInProgress->deleteLater(); - credentialsValidationInProgress = nullptr; - } -} - -void BugReporter::useBugReportCredentials(const QString& login, const QString& password) -{ - CFG_CORE.Internal.BugReportUser.set(login); - CFG_CORE.Internal.BugReportPassword.set(password); -} - -void BugReporter::clearBugReportCredentials() -{ - CFG_CORE.Internal.BugReportUser.set(QString()); - CFG_CORE.Internal.BugReportPassword.set(QString()); -} - -void BugReporter::reportBug(const QString& title, const QString& details, const QString& version, const QString& os, const QString& plugins, BugReporter::ResponseHandler responseHandler, const QString& urlSuffix) -{ - static_qstring(contentsTpl, "%1\n\n<b>Plugins loaded:</b>\n%2\n\n<b>Version:</b>\n%3\n\n<b>Operating System:</b>\n%4"); - QString contents = contentsTpl.arg(escapeParam(details), plugins, version, os); - - QUrlQuery query; - query.addQueryItem("brief", escapeParam(title)); - query.addQueryItem("contents", contents); - query.addQueryItem("os", os); - query.addQueryItem("version", version); - query.addQueryItem("featureRequest", "0"); - - QUrl url = QUrl(QString::fromLatin1(bugReportServiceUrl) + "?" + escapeUrl(query.query(QUrl::FullyEncoded) + urlSuffix)); - QNetworkRequest request(url); - QNetworkReply* reply = networkManager->get(request); - if (responseHandler) - replyToHandler[reply] = responseHandler; - - replyToTypeAndTitle[reply] = QPair<bool,QString>(false, title); -} - -void BugReporter::requestFeature(const QString& title, const QString& details, BugReporter::ResponseHandler responseHandler, const QString& urlSuffix) -{ - QUrlQuery query; - query.addQueryItem("brief", escapeParam(title)); - query.addQueryItem("contents", escapeParam(details)); - query.addQueryItem("featureRequest", "1"); - - QUrl url = QUrl(QString::fromLatin1(bugReportServiceUrl) + "?" + escapeUrl(query.query(QUrl::FullyEncoded) + urlSuffix)); - QNetworkRequest request(url); - QNetworkReply* reply = networkManager->get(request); - if (responseHandler) - replyToHandler[reply] = responseHandler; - - replyToTypeAndTitle[reply] = QPair<bool,QString>(true, title); -} - -QString BugReporter::escapeParam(const QString &input) -{ - return input.toHtmlEscaped(); -} - -QString BugReporter::escapeUrl(const QString &input) -{ - // For some reason the ";" character is not encodedy by QUrlQuery when using FullEncoded. Pity. We have to do it manually. - QString copy = input; - return copy.replace(";", "%3B"); -} - -void BugReporter::finished(QNetworkReply* reply) -{ - if (reply == credentialsValidationInProgress) - credentialsValidationInProgress = nullptr; - - if (!replyToHandler.contains(reply)) - { - reply->deleteLater(); - return; - } - - bool success = (reply->error() == QNetworkReply::NoError); - QString data; - if (success) - data = QString::fromLatin1(reply->readAll()); - else - data = reply->errorString(); - - replyToHandler[reply](success, data); - replyToHandler.remove(reply); - - if (replyToTypeAndTitle.contains(reply)) - { - if (success) - CFG->addReportHistory(replyToTypeAndTitle[reply].first, replyToTypeAndTitle[reply].second, data); - - replyToTypeAndTitle.remove(reply); - } - - reply->deleteLater(); -} - -void BugReporter::reportBug(const QString& email, const QString& title, const QString& details, const QString& version, const QString& os, const QString& plugins, - ResponseHandler responseHandler) -{ - QUrlQuery query; - query.addQueryItem("byEmail", email); - QString urlSuffix = "&" + query.query(QUrl::FullyEncoded); - - reportBug(title, details, version, os, plugins, responseHandler, urlSuffix); -} - -void BugReporter::reportBug(const QString& title, const QString& details, const QString& version, const QString& os, - const QString& plugins, ResponseHandler responseHandler) -{ - QString user = CFG_CORE.Internal.BugReportUser.get(); - QString pass = CFG_CORE.Internal.BugReportPassword.get(); - - QUrlQuery query; - query.addQueryItem("byUser", user); - query.addQueryItem("password", pass); - QString urlSuffix = "&" + query.query(QUrl::FullyEncoded); - - reportBug(title, details, version, os, plugins, responseHandler, urlSuffix); -} - -void BugReporter::requestFeature(const QString& email, const QString& title, const QString& details, ResponseHandler responseHandler) -{ - QUrlQuery query; - query.addQueryItem("byEmail", email); - QString urlSuffix = "&" + query.query(QUrl::FullyEncoded); - - requestFeature(title, details, responseHandler, urlSuffix); -} - -void BugReporter::requestFeature(const QString& title, const QString& details, ResponseHandler responseHandler) -{ - QString user = CFG_CORE.Internal.BugReportUser.get(); - QString pass = CFG_CORE.Internal.BugReportPassword.get(); - - QUrlQuery query; - query.addQueryItem("byUser", user); - query.addQueryItem("password", pass); - QString urlSuffix = "&" + query.query(QUrl::FullyEncoded); - - requestFeature(title, details, responseHandler, urlSuffix); -} diff --git a/SQLiteStudio3/coreSQLiteStudio/services/bugreporter.h b/SQLiteStudio3/coreSQLiteStudio/services/bugreporter.h deleted file mode 100644 index 3e8eb8d..0000000 --- a/SQLiteStudio3/coreSQLiteStudio/services/bugreporter.h +++ /dev/null @@ -1,62 +0,0 @@ -#ifndef BUGREPORTER_H -#define BUGREPORTER_H - -#include "common/global.h" -#include "sqlitestudio.h" -#include <QObject> -#include <QHash> - -class QNetworkAccessManager; -class QNetworkReply; - -class API_EXPORT BugReporter : public QObject -{ - Q_OBJECT - - public: - typedef std::function<void(bool success, const QString& data)> ResponseHandler; - - explicit BugReporter(QObject *parent = 0); - - QUrl getReporterEmailHelpUrl() const; - QUrl getReporterUserAndPasswordHelpUrl() const; - void validateBugReportCredentials(const QString& login, const QString& password); - void abortCredentialsValidation(); - void useBugReportCredentials(const QString& login, const QString& password); - void clearBugReportCredentials(); - - private: - void reportBug(const QString& title, const QString& details, const QString& version, const QString& os, const QString& plugins, - ResponseHandler responseHandler, const QString& urlSuffix); - void requestFeature(const QString& title, const QString& details, ResponseHandler responseHandler, const QString& urlSuffix); - - static QString escapeParam(const QString& input); - static QString escapeUrl(const QString& input); - - QNetworkAccessManager* networkManager = nullptr; - QHash<QNetworkReply*,ResponseHandler> replyToHandler; - QHash<QNetworkReply*,QPair<bool,QString>> replyToTypeAndTitle; - QNetworkReply* credentialsValidationInProgress = nullptr; - - static_char* bugReportServiceUrl = "http://sqlitestudio.pl/report_bug3.rvt"; - static_char* reporterEmailHelpUrl = "http://wiki.sqlitestudio.pl/index.php/User_Manual#Reporter_email_address"; - static_char* reporterUserPassHelpUrl = "http://wiki.sqlitestudio.pl/index.php/User_Manual#Reporter_user_and_password"; - - signals: - void credentialsValidationResult(bool success, const QString& errorMessage); - - private slots: - void finished(QNetworkReply* reply); - - public slots: - void reportBug(const QString& email, const QString& title, const QString& details, const QString& version, const QString& os, const QString& plugins, - ResponseHandler responseHandler = nullptr); - void reportBug(const QString& title, const QString& details, const QString& version, const QString& os, const QString& plugins, - ResponseHandler responseHandler = nullptr); - void requestFeature(const QString& email, const QString& title, const QString& details, ResponseHandler responseHandler = nullptr); - void requestFeature(const QString& title, const QString& details, ResponseHandler responseHandler = nullptr); -}; - -#define BUGS SQLITESTUDIO->getBugReporter() - -#endif // BUGREPORTER_H diff --git a/SQLiteStudio3/coreSQLiteStudio/services/config.h b/SQLiteStudio3/coreSQLiteStudio/services/config.h index 1e4c410..202120a 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/config.h +++ b/SQLiteStudio3/coreSQLiteStudio/services/config.h @@ -20,6 +20,8 @@ CFG_CATEGORIES(Core, CFG_CATEGORY(General, CFG_ENTRY(int, SqlHistorySize, 10000) CFG_ENTRY(int, DdlHistorySize, 1000) + CFG_ENTRY(int, BindParamsCacheSize, 1000) + CFG_ENTRY(int, PopulateHistorySize, 100) CFG_ENTRY(QString, LoadedPlugins, "") CFG_ENTRY(QVariantHash, ActiveCodeFormatter, QVariantHash()) CFG_ENTRY(bool, CheckUpdatesOnStartup, true) @@ -31,6 +33,7 @@ CFG_CATEGORIES(Core, CFG_CATEGORY(Internal, CFG_ENTRY(QVariantList, Functions, QVariantList()) CFG_ENTRY(QVariantList, Collations, QVariantList()) + CFG_ENTRY(QVariantList, Extensions, QVariantList()) CFG_ENTRY(QString, BugReportUser, QString()) CFG_ENTRY(QString, BugReportPassword, QString()) CFG_ENTRY(QString, BugReportRecentTitle, QString()) @@ -118,6 +121,7 @@ class API_EXPORT Config : public QObject virtual bool isMassSaving() const = 0; virtual void set(const QString& group, const QString& key, const QVariant& value) = 0; virtual QVariant get(const QString& group, const QString& key) = 0; + virtual QVariant get(const QString& group, const QString& key, const QVariant& defaultValue) = 0; virtual QHash<QString,QVariant> getAll() = 0; virtual bool addDb(const QString& name, const QString& path, const QHash<QString, QVariant> &options) = 0; @@ -144,6 +148,7 @@ class API_EXPORT Config : public QObject virtual qint64 addSqlHistory(const QString& sql, const QString& dbName, int timeSpentMillis, int rowsAffected) = 0; virtual void updateSqlHistory(qint64 id, const QString& sql, const QString& dbName, int timeSpentMillis, int rowsAffected) = 0; virtual void clearSqlHistory() = 0; + virtual void deleteSqlHistory(const QList<qint64>& ids) = 0; virtual QAbstractItemModel* getSqlHistoryModel() = 0; virtual void addCliHistory(const QString& text) = 0; @@ -151,6 +156,15 @@ class API_EXPORT Config : public QObject virtual void clearCliHistory() = 0; virtual QStringList getCliHistory() const = 0; + virtual void addBindParamHistory(const QVector<QPair<QString, QVariant>>& params) = 0; + virtual void applyBindParamHistoryLimit() = 0; + virtual QVector<QPair<QString, QVariant>> getBindParamHistory(const QStringList& paramNames) const = 0; + + virtual void addPopulateHistory(const QString& database, const QString& table, int rows, const QHash<QString, QPair<QString, QVariant>>& columnsPluginsConfig) = 0; + virtual void applyPopulateHistoryLimit() = 0; + virtual QHash<QString, QPair<QString, QVariant>> getPopulateHistory(const QString& database, const QString& table, int& rows) const = 0; + virtual QVariant getPopulateHistory(const QString& pluginName) const = 0; + virtual void addDdlHistory(const QString& queries, const QString& dbName, const QString& dbFile) = 0; virtual QList<DdlHistoryEntryPtr> getDdlHistoryFor(const QString& dbName, const QString& dbFile, const QDate& date) = 0; virtual DdlHistoryModel* getDdlHistoryModel() = 0; diff --git a/SQLiteStudio3/coreSQLiteStudio/services/dbmanager.h b/SQLiteStudio3/coreSQLiteStudio/services/dbmanager.h index 52746e4..2b5fa41 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/dbmanager.h +++ b/SQLiteStudio3/coreSQLiteStudio/services/dbmanager.h @@ -144,12 +144,13 @@ class API_EXPORT DbManager : public QObject /** * @brief Creates in-memory SQLite3 database. + * @param pureInit If true, avoids registering collations/functions/extensions in a database. Skips rich initialization and gives pure database connection. * @return Created database. * * Created database can be used for any purpose. Note that DbManager doesn't own created * database and it's up to the caller to delete the database when it's no longer needed. */ - virtual Db* createInMemDb() = 0; + virtual Db* createInMemDb(bool pureInit = false) = 0; /** * @brief Tells if given database is temporary. diff --git a/SQLiteStudio3/coreSQLiteStudio/services/functionmanager.h b/SQLiteStudio3/coreSQLiteStudio/services/functionmanager.h index 2581b4f..5fb4908 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/functionmanager.h +++ b/SQLiteStudio3/coreSQLiteStudio/services/functionmanager.h @@ -3,6 +3,7 @@ #include "coreSQLiteStudio_global.h" #include "common/global.h" +#include <QVariant> #include <QList> #include <QSharedPointer> #include <QObject> diff --git a/SQLiteStudio3/coreSQLiteStudio/services/impl/collationmanagerimpl.cpp b/SQLiteStudio3/coreSQLiteStudio/services/impl/collationmanagerimpl.cpp index 5876021..7d24e47 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/impl/collationmanagerimpl.cpp +++ b/SQLiteStudio3/coreSQLiteStudio/services/impl/collationmanagerimpl.cpp @@ -27,7 +27,7 @@ QList<CollationManager::CollationPtr> CollationManagerImpl::getAllCollations() c QList<CollationManager::CollationPtr> CollationManagerImpl::getCollationsForDatabase(const QString& dbName) const { QList<CollationPtr> results; - foreach (const CollationPtr& coll, collations) + for (const CollationPtr& coll : collations) { if (coll->allDatabases || coll->databases.contains(dbName, Qt::CaseInsensitive)) results << coll; @@ -120,6 +120,6 @@ void CollationManagerImpl::loadFromConfig() void CollationManagerImpl::refreshCollationsByKey() { collationsByKey.clear(); - foreach (CollationPtr collation, collations) + for (CollationPtr collation : collations) collationsByKey[collation->name] = collation; } diff --git a/SQLiteStudio3/coreSQLiteStudio/services/impl/configimpl.cpp b/SQLiteStudio3/coreSQLiteStudio/services/impl/configimpl.cpp index cf8b115..860e828 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/impl/configimpl.cpp +++ b/SQLiteStudio3/coreSQLiteStudio/services/impl/configimpl.cpp @@ -4,6 +4,7 @@ #include "services/notifymanager.h" #include "sqlitestudio.h" #include "db/dbsqlite3.h" +#include "common/utils.h" #include <QtGlobal> #include <QDebug> #include <QList> @@ -94,11 +95,7 @@ bool ConfigImpl::isMassSaving() const void ConfigImpl::set(const QString &group, const QString &key, const QVariant &value) { - QByteArray bytes; - QDataStream stream(&bytes, QIODevice::WriteOnly); - stream << value; - - db->exec("INSERT OR REPLACE INTO settings VALUES (?, ?, ?)", {group, key, bytes}); + db->exec("INSERT OR REPLACE INTO settings VALUES (?, ?, ?)", {group, key, serializeToBytes(value)}); } QVariant ConfigImpl::get(const QString &group, const QString &key) @@ -107,6 +104,15 @@ QVariant ConfigImpl::get(const QString &group, const QString &key) return deserializeValue(results->getSingleCell()); } +QVariant ConfigImpl::get(const QString &group, const QString &key, const QVariant &defaultValue) +{ + QVariant value = get(group, key); + if (!value.isValid() || value.isNull()) + return defaultValue; + + return value; +} + QHash<QString,QVariant> ConfigImpl::getAll() { SqlQueryPtr results = db->exec("SELECT [group], [key], value FROM settings"); @@ -225,7 +231,7 @@ void ConfigImpl::storeGroups(const QList<DbGroupPtr>& groups) db->begin(); db->exec("DELETE FROM groups"); - foreach (const DbGroupPtr& group, groups) + for (const DbGroupPtr& group : groups) storeGroup(group); db->commit(); @@ -241,7 +247,7 @@ void ConfigImpl::storeGroup(const ConfigImpl::DbGroupPtr &group, qint64 parentId {group->name, group->order, parent, group->open, group->referencedDbName}); qint64 newParentId = results->getRegularInsertRowId(); - foreach (const DbGroupPtr& childGroup, group->childs) + for (const DbGroupPtr& childGroup : group->childs) storeGroup(childGroup, newParentId); } @@ -304,6 +310,11 @@ void ConfigImpl::clearSqlHistory() QtConcurrent::run(this, &ConfigImpl::asyncClearSqlHistory); } +void ConfigImpl::deleteSqlHistory(const QList<qint64>& ids) +{ + QtConcurrent::run(this, &ConfigImpl::asyncDeleteSqlHistory, ids); +} + QAbstractItemModel* ConfigImpl::getSqlHistoryModel() { if (!sqlHistoryModel) @@ -338,6 +349,122 @@ QStringList ConfigImpl::getCliHistory() const return results->columnAsList<QString>("text"); } +void ConfigImpl::addBindParamHistory(const QVector<QPair<QString, QVariant> >& params) +{ + QtConcurrent::run(this, &ConfigImpl::asyncAddBindParamHistory, params); +} + +void ConfigImpl::applyBindParamHistoryLimit() +{ + QtConcurrent::run(this, &ConfigImpl::asyncApplyBindParamHistoryLimit); +} + +QVector<QPair<QString, QVariant>> ConfigImpl::getBindParamHistory(const QStringList& paramNames) const +{ + static_qstring(directQuery, "SELECT id FROM bind_params WHERE pattern = ? ORDER BY id DESC"); + static_qstring(paramsByIdQuery, "SELECT name, value FROM bind_param_values WHERE bind_params_id = ? ORDER BY position"); + static_qstring(singleParamQuery, "SELECT value FROM bind_param_values WHERE %1 = ? ORDER BY id DESC LIMIT 1;"); + static_qstring(singleParamName, "name"); + static_qstring(singleParamPosition, "position"); + + QVector<QPair<QString, QVariant>> bindParams; + bindParams.reserve(paramNames.size()); + + SqlQueryPtr results = db->exec(directQuery, {paramNames.join(",")}); + if (results->isError()) + { + qWarning() << "Error while getting BindParams (1):" << db->getErrorText(); + return bindParams; + } + + // Got an exact match? Extract values and return. + QVariant exactMatch = results->getSingleCell(); + if (!exactMatch.isNull()) + { + results = db->exec(paramsByIdQuery, {exactMatch.toLongLong()}); + if (results->isError()) + { + qWarning() << "Error while getting BindParams (2):" << db->getErrorText(); + } + else + { + for (const SqlResultsRowPtr& row : results->getAll()) + bindParams << QPair<QString, QVariant>(row->value("name").toString(), row->value("value")); + } + return bindParams; + } + + // No exact match. Will look for values one by one using param name and position. + int position = 0; + for (const QString& bindParam : paramNames) + { + if (bindParam == "?") + results = db->exec(singleParamQuery.arg(singleParamPosition), {position}); + else + results = db->exec(singleParamQuery.arg(singleParamName), {bindParam}); + + bindParams << QPair<QString, QVariant>(bindParam, results->getSingleCell()); + position++; + } + return bindParams; +} + +void ConfigImpl::addPopulateHistory(const QString& database, const QString& table, int rows, const QHash<QString, QPair<QString, QVariant> >& columnsPluginsConfig) +{ + QtConcurrent::run(this, &ConfigImpl::asyncAddPopulateHistory, database, table, rows, columnsPluginsConfig); +} + +void ConfigImpl::applyPopulateHistoryLimit() +{ + QtConcurrent::run(this, &ConfigImpl::asyncApplyPopulateHistoryLimit); +} + +QHash<QString, QPair<QString, QVariant>> ConfigImpl::getPopulateHistory(const QString& database, const QString& table, int& rows) const +{ + static_qstring(initialQuery, "SELECT id, rows FROM populate_history WHERE [database] = ? AND [table] = ? ORDER BY id DESC LIMIT 1"); + static_qstring(columnsQuery, "SELECT column_name, plugin_name, plugin_config FROM populate_column_history WHERE populate_history_id = ?"); + + QHash<QString, QPair<QString, QVariant>> historyEntry; + SqlQueryPtr results = db->exec(initialQuery, {database, table}); + if (results->isError()) + { + qWarning() << "Error while getting Populating history entry (1):" << db->getErrorText(); + return historyEntry; + } + + if (!results->hasNext()) + return historyEntry; + + SqlResultsRowPtr row = results->next(); + qint64 historyEntryId = row->value("id").toLongLong(); + rows = row->value("rows").toInt(); + + results = db->exec(columnsQuery, {historyEntryId}); + QVariant value; + while (results->hasNext()) + { + row = results->next(); + value = deserializeValue(row->value("plugin_config")); + historyEntry[row->value("column_name").toString()] = QPair<QString, QVariant>(row->value("plugin_name").toString(), value); + } + + return historyEntry; +} + +QVariant ConfigImpl::getPopulateHistory(const QString& pluginName) const +{ + static_qstring(columnsQuery, "SELECT plugin_config FROM populate_column_history WHERE plugin_name = ? ORDER BY id DESC LiMIT 1"); + + SqlQueryPtr results = db->exec(columnsQuery, {pluginName}); + if (results->isError()) + { + qWarning() << "Error while getting Populating history entry (2):" << db->getErrorText(); + return QVariant(); + } + + return deserializeValue(results->getSingleCell()); +} + void ConfigImpl::addDdlHistory(const QString& queries, const QString& dbName, const QString& dbFile) { QtConcurrent::run(this, &ConfigImpl::asyncAddDdlHistory, queries, dbName, dbFile); @@ -503,9 +630,9 @@ QString ConfigImpl::getPortableConfigPath() if (!file.isDir() || !file.isReadable() || !file.isWritable()) continue; - foreach (file, dir.entryInfoList()) + for (const QFileInfo& entryFile : dir.entryInfoList()) { - if (!file.isReadable() || !file.isWritable()) + if (!entryFile.isReadable() || !entryFile.isWritable()) continue; } @@ -522,8 +649,7 @@ void ConfigImpl::initTables() if (!tables.contains("version")) { - QString table; - foreach (table, tables) + for (const QString& table : tables) db->exec("DROP TABLE "+table); tables.clear(); @@ -554,6 +680,34 @@ void ConfigImpl::initTables() if (!tables.contains("reports_history")) db->exec("CREATE TABLE reports_history (id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, feature_request BOOLEAN, title TEXT, url TEXT)"); + + if (!tables.contains("bind_params")) + { + db->exec("CREATE TABLE bind_params (id INTEGER PRIMARY KEY AUTOINCREMENT, pattern TEXT NOT NULL)"); + db->exec("CREATE INDEX bind_params_patt_idx ON bind_params (pattern);"); + } + + if (!tables.contains("bind_param_values")) + { + db->exec("CREATE TABLE bind_param_values (id INTEGER PRIMARY KEY AUTOINCREMENT, bind_params_id INTEGER REFERENCES bind_params (id) " + "ON DELETE CASCADE ON UPDATE CASCADE NOT NULL, position INTEGER NOT NULL, name TEXT NOT NULL, value)"); + db->exec("CREATE INDEX bind_param_values_fk_idx ON bind_param_values (bind_params_id);"); + } + + if (!tables.contains("populate_history")) + { + db->exec("CREATE TABLE populate_history (id INTEGER PRIMARY KEY AUTOINCREMENT, [database] TEXT NOT NULL, [table] TEXT NOT NULL, rows INTEGER NOT NULL)"); + } + + if (!tables.contains("populate_column_history")) + { + db->exec("CREATE TABLE populate_column_history (id INTEGER PRIMARY KEY AUTOINCREMENT, populate_history_id INTEGER REFERENCES populate_history (id) " + "ON DELETE CASCADE ON UPDATE CASCADE NOT NULL, column_name TEXT NOT NULL, plugin_name TEXT NOT NULL, plugin_config BLOB)"); + db->exec("CREATE INDEX populate_plugin_history_idx ON populate_column_history (plugin_name)"); + } + + if (!tables.contains("reports_history")) + db->exec("CREATE TABLE reports_history (id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, feature_request BOOLEAN, title TEXT, url TEXT)"); } void ConfigImpl::initDbFile() @@ -646,19 +800,13 @@ bool ConfigImpl::tryInitDbFile(const QPair<QString, bool> &dbPath) return true; } -QVariant ConfigImpl::deserializeValue(const QVariant &value) +QVariant ConfigImpl::deserializeValue(const QVariant &value) const { if (!value.isValid()) return QVariant(); QByteArray bytes = value.toByteArray(); - if (bytes.isNull()) - return QVariant(); - - QVariant deserializedValue; - QDataStream stream(bytes); - stream >> deserializedValue; - return deserializedValue; + return deserializeFromBytes(bytes); } void ConfigImpl::asyncAddSqlHistory(qint64 id, const QString& sql, const QString& dbName, int timeSpentMillis, int rowsAffected) @@ -709,6 +857,23 @@ void ConfigImpl::asyncClearSqlHistory() emit sqlHistoryRefreshNeeded(); } +void ConfigImpl::asyncDeleteSqlHistory(const QList<qint64>& ids) +{ + if (!db->begin()) { + NOTIFY_MANAGER->warn(tr("Could not start database transaction for deleting SQL history, therefore it's not deleted.")); + return; + } + for (const qint64& id : ids) + db->exec("DELETE FROM sqleditor_history WHERE id = ?", id); + + if (!db->commit()) { + NOTIFY_MANAGER->warn(tr("Could not commit database transaction for deleting SQL history, therefore it's not deleted.")); + db->rollback(); + return; + } + emit sqlHistoryRefreshNeeded(); +} + void ConfigImpl::asyncAddCliHistory(const QString& text) { static_qstring(insertQuery, "INSERT INTO cli_history (text) VALUES (?)"); @@ -722,7 +887,7 @@ void ConfigImpl::asyncAddCliHistory(const QString& text) void ConfigImpl::asyncApplyCliHistoryLimit() { - static_qstring(limitQuery, "DELETE FROM cli_history WHERE id >= (SELECT id FROM cli_history ORDER BY id LIMIT 1 OFFSET %1)"); + static_qstring(limitQuery, "DELETE FROM cli_history WHERE id <= (SELECT id FROM cli_history ORDER BY id DESC LIMIT 1 OFFSET %1)"); SqlQueryPtr results = db->exec(limitQuery.arg(CFG_CORE.Console.HistorySize.get())); if (results->isError()) @@ -738,6 +903,105 @@ void ConfigImpl::asyncClearCliHistory() qWarning() << "Error while clearing CLI history:" << db->getErrorText(); } +void ConfigImpl::asyncAddBindParamHistory(const QVector<QPair<QString, QVariant> >& params) +{ + static_qstring(insertParamsQuery, "INSERT INTO bind_params (pattern) VALUES (?)"); + static_qstring(insertValuesQuery, "INSERT INTO bind_param_values (bind_params_id, position, name, value) VALUES (?, ?, ?, ?)"); + + if (!db->begin()) + { + qWarning() << "Failed to store BindParam cache, because could not begin SQL transaction. Details:" << db->getErrorText(); + return; + } + + QStringList paramNames; + for (const QPair<QString, QVariant>& paramPair : params) + paramNames << paramPair.first; + + SqlQueryPtr results = db->exec(insertParamsQuery, {paramNames.join(",")}); + RowId rowId = results->getInsertRowId(); + qint64 bindParamsId = rowId["ROWID"].toLongLong(); + + int position = 0; + for (const QPair<QString, QVariant>& paramPair : params) + { + results = db->exec(insertValuesQuery, {bindParamsId, position++, paramPair.first, paramPair.second}); + if (results->isError()) + { + qWarning() << "Failed to store BindParam cache, due to SQL error:" << db->getErrorText(); + db->rollback(); + return; + } + } + + if (!db->commit()) + { + qWarning() << "Failed to store BindParam cache, because could not commit SQL transaction. Details:" << db->getErrorText(); + db->rollback(); + } + + asyncApplyBindParamHistoryLimit(); +} + +void ConfigImpl::asyncApplyBindParamHistoryLimit() +{ + static_qstring(findBindParamIdQuery, "SELECT bind_params_id FROM bind_param_values ORDER BY id DESC LIMIT 1 OFFSET %1"); + static_qstring(limitBindParamsQuery, "DELETE FROM bind_params WHERE id <= ?"); // will cascade with FK to bind_param_values + + SqlQueryPtr results = db->exec(findBindParamIdQuery.arg(CFG_CORE.General.BindParamsCacheSize.get())); + if (results->isError()) + qWarning() << "Error while limiting BindParam history (step 1):" << db->getErrorText(); + + qint64 bindParamId = results->getSingleCell().toLongLong(); + results = db->exec(limitBindParamsQuery, {bindParamId}); + if (results->isError()) + qWarning() << "Error while limiting BindParam history (step 2):" << db->getErrorText(); +} + +void ConfigImpl::asyncAddPopulateHistory(const QString& database, const QString& table, int rows, const QHash<QString, QPair<QString, QVariant>>& columnsPluginsConfig) +{ + static_qstring(insertQuery, "INSERT INTO populate_history ([database], [table], rows) VALUES (?, ?, ?)"); + static_qstring(insertColumnQuery, "INSERT INTO populate_column_history (populate_history_id, column_name, plugin_name, plugin_config) VALUES (?, ?, ?, ?)"); + + if (!db->begin()) + { + qWarning() << "Failed to store Populating history entry, because could not begin SQL transaction. Details:" << db->getErrorText(); + return; + } + + SqlQueryPtr results = db->exec(insertQuery, {database, table, rows}); + RowId rowId = results->getInsertRowId(); + qint64 populateHistoryId = rowId["ROWID"].toLongLong(); + + for (QHash<QString, QPair<QString, QVariant>>::const_iterator colIt = columnsPluginsConfig.begin(); colIt != columnsPluginsConfig.end(); colIt++) + { + results = db->exec(insertColumnQuery, {populateHistoryId, colIt.key(), colIt.value().first, serializeToBytes(colIt.value().second)}); + if (results->isError()) + { + qWarning() << "Failed to store Populating history entry, due to SQL error:" << db->getErrorText(); + db->rollback(); + return; + } + } + + if (!db->commit()) + { + qWarning() << "Failed to store Populating history entry, because could not commit SQL transaction. Details:" << db->getErrorText(); + db->rollback(); + } + + asyncApplyPopulateHistoryLimit(); +} + +void ConfigImpl::asyncApplyPopulateHistoryLimit() +{ + static_qstring(limitQuery, "DELETE FROM populate_history WHERE id <= (SELECT id FROM populate_history ORDER BY id DESC LIMIT 1 OFFSET %1)"); + + SqlQueryPtr results = db->exec(limitQuery.arg(CFG_CORE.General.PopulateHistorySize.get())); + if (results->isError()) + qWarning() << "Error while limiting Populating history:" << db->getErrorText(); +} + void ConfigImpl::asyncAddDdlHistory(const QString& queries, const QString& dbName, const QString& dbFile) { static_qstring(insert, "INSERT INTO ddl_history (dbname, file, timestamp, queries) VALUES (?, ?, ?, ?)"); @@ -799,7 +1063,12 @@ void ConfigImpl::mergeMasterConfig() if (masterConfigFile.isEmpty()) return; - qInfo() << "Updating settings from master configuration file: " << masterConfigFile; +#if QT_VERSION >= 0x050500 + qInfo() +#else + qDebug() +#endif + << "Updating settings from master configuration file: " << masterConfigFile; Db* masterDb = new DbSqlite3("SQLiteStudio master settings", masterConfigFile, {{DB_PURE_INIT, true}}); if (!masterDb->open()) diff --git a/SQLiteStudio3/coreSQLiteStudio/services/impl/configimpl.h b/SQLiteStudio3/coreSQLiteStudio/services/impl/configimpl.h index 08bcec7..561aab4 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/impl/configimpl.h +++ b/SQLiteStudio3/coreSQLiteStudio/services/impl/configimpl.h @@ -29,6 +29,7 @@ class API_EXPORT ConfigImpl : public Config bool isMassSaving() const; void set(const QString& group, const QString& key, const QVariant& value); QVariant get(const QString& group, const QString& key); + QVariant get(const QString& group, const QString& key, const QVariant& defaultValue); QHash<QString,QVariant> getAll(); bool addDb(const QString& name, const QString& path, const QHash<QString, QVariant> &options); @@ -56,6 +57,7 @@ class API_EXPORT ConfigImpl : public Config qint64 addSqlHistory(const QString& sql, const QString& dbName, int timeSpentMillis, int rowsAffected); void updateSqlHistory(qint64 id, const QString& sql, const QString& dbName, int timeSpentMillis, int rowsAffected); void clearSqlHistory(); + void deleteSqlHistory(const QList<qint64>& ids); QAbstractItemModel* getSqlHistoryModel(); void addCliHistory(const QString& text); @@ -63,6 +65,15 @@ class API_EXPORT ConfigImpl : public Config void clearCliHistory(); QStringList getCliHistory() const; + void addBindParamHistory(const QVector<QPair<QString, QVariant>>& params); + void applyBindParamHistoryLimit(); + QVector<QPair<QString, QVariant>> getBindParamHistory(const QStringList& paramNames) const; + + void addPopulateHistory(const QString& database, const QString& table, int rows, const QHash<QString, QPair<QString, QVariant>>& columnsPluginsConfig); + void applyPopulateHistoryLimit(); + QHash<QString, QPair<QString, QVariant>> getPopulateHistory(const QString& database, const QString& table, int& rows) const; + QVariant getPopulateHistory(const QString& pluginName) const; + void addDdlHistory(const QString& queries, const QString& dbName, const QString& dbFile); QList<DdlHistoryEntryPtr> getDdlHistoryFor(const QString& dbName, const QString& dbFile, const QDate& date); DdlHistoryModel* getDdlHistoryModel(); @@ -94,16 +105,23 @@ class API_EXPORT ConfigImpl : public Config void initTables(); void initDbFile(); bool tryInitDbFile(const QPair<QString, bool>& dbPath); - QVariant deserializeValue(const QVariant& value); + QVariant deserializeValue(const QVariant& value) const; void asyncAddSqlHistory(qint64 id, const QString& sql, const QString& dbName, int timeSpentMillis, int rowsAffected); void asyncUpdateSqlHistory(qint64 id, const QString& sql, const QString& dbName, int timeSpentMillis, int rowsAffected); void asyncClearSqlHistory(); + void asyncDeleteSqlHistory(const QList<qint64> &ids); void asyncAddCliHistory(const QString& text); void asyncApplyCliHistoryLimit(); void asyncClearCliHistory(); + void asyncAddBindParamHistory(const QVector<QPair<QString, QVariant>>& params); + void asyncApplyBindParamHistoryLimit(); + + void asyncAddPopulateHistory(const QString& database, const QString& table, int rows, const QHash<QString, QPair<QString, QVariant>>& columnsPluginsConfig); + void asyncApplyPopulateHistoryLimit(); + void asyncAddDdlHistory(const QString& queries, const QString& dbName, const QString& dbFile); void asyncClearDdlHistory(); diff --git a/SQLiteStudio3/coreSQLiteStudio/services/impl/dbmanagerimpl.cpp b/SQLiteStudio3/coreSQLiteStudio/services/impl/dbmanagerimpl.cpp index 74f482f..217c2b7 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/impl/dbmanagerimpl.cpp +++ b/SQLiteStudio3/coreSQLiteStudio/services/impl/dbmanagerimpl.cpp @@ -23,7 +23,8 @@ DbManagerImpl::DbManagerImpl(QObject *parent) : DbManagerImpl::~DbManagerImpl() { - foreach (Db* db, dbList) +// qDebug() << "DbManagerImpl::~DbManagerImpl()"; + for (Db* db : dbList) { disconnect(db, SIGNAL(disconnected()), this, SLOT(dbDisconnectedSlot())); disconnect(db, SIGNAL(aboutToDisconnect(bool&)), this, SLOT(dbAboutToDisconnect(bool&))); @@ -261,12 +262,16 @@ Db* DbManagerImpl::getByPath(const QString &path) return pathToDb.value(pathDir.absolutePath()); } -Db* DbManagerImpl::createInMemDb() +Db* DbManagerImpl::createInMemDb(bool pureInit) { if (!inMemDbCreatorPlugin) return nullptr; - return inMemDbCreatorPlugin->getInstance("", ":memory:", {}); + QHash<QString, QVariant> opts; + if (pureInit) + opts[DB_PURE_INIT] = true; + + return inMemDbCreatorPlugin->getInstance("", ":memory:", opts); } bool DbManagerImpl::isTemporary(Db* db) @@ -341,7 +346,7 @@ void DbManagerImpl::loadInitialDbList() { QUrl url; InvalidDb* db = nullptr; - foreach (const Config::CfgDbPtr& cfgDb, CFG->dbList()) + for (const Config::CfgDbPtr& cfgDb : CFG->dbList()) { db = new InvalidDb(cfgDb->name, cfgDb->path, cfgDb->options); diff --git a/SQLiteStudio3/coreSQLiteStudio/services/impl/dbmanagerimpl.h b/SQLiteStudio3/coreSQLiteStudio/services/impl/dbmanagerimpl.h index 2e3630a..5f99f86 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/impl/dbmanagerimpl.h +++ b/SQLiteStudio3/coreSQLiteStudio/services/impl/dbmanagerimpl.h @@ -42,7 +42,7 @@ class API_EXPORT DbManagerImpl : public DbManager QStringList getDbNames(); Db* getByName(const QString& name, Qt::CaseSensitivity cs = Qt::CaseInsensitive); Db* getByPath(const QString& path); - Db* createInMemDb(); + Db* createInMemDb(bool pureInit = false); bool isTemporary(Db* db); QString quickAddDb(const QString &path, const QHash<QString, QVariant> &options); DbPlugin* getPluginForDbFile(const QString& filePath); diff --git a/SQLiteStudio3/coreSQLiteStudio/services/impl/functionmanagerimpl.cpp b/SQLiteStudio3/coreSQLiteStudio/services/impl/functionmanagerimpl.cpp index 826b34b..2fcc689 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/impl/functionmanagerimpl.cpp +++ b/SQLiteStudio3/coreSQLiteStudio/services/impl/functionmanagerimpl.cpp @@ -40,7 +40,7 @@ QList<FunctionManager::ScriptFunction*> FunctionManagerImpl::getAllScriptFunctio QList<FunctionManager::ScriptFunction*> FunctionManagerImpl::getScriptFunctionsForDatabase(const QString& dbName) const { QList<ScriptFunction*> results; - foreach (ScriptFunction* func, functions) + for (ScriptFunction* func : functions) { if (func->allDatabases || func->databases.contains(dbName, Qt::CaseInsensitive)) results << func; @@ -280,10 +280,10 @@ void FunctionManagerImpl::initNativeFunctions() void FunctionManagerImpl::refreshFunctionsByKey() { functionsByKey.clear(); - foreach (ScriptFunction* func, functions) + for (ScriptFunction* func : functions) functionsByKey[Key(func)] = func; - foreach (NativeFunction* func, nativeFunctions) + for (NativeFunction* func : nativeFunctions) nativeFunctionsByKey[Key(func)] = func; } @@ -291,7 +291,7 @@ void FunctionManagerImpl::storeInConfig() { QVariantList list; QHash<QString,QVariant> fnHash; - foreach (ScriptFunction* func, functions) + for (ScriptFunction* func : functions) { fnHash["name"] = func->name; fnHash["lang"] = func->lang; diff --git a/SQLiteStudio3/coreSQLiteStudio/services/impl/pluginmanagerimpl.cpp b/SQLiteStudio3/coreSQLiteStudio/services/impl/pluginmanagerimpl.cpp index 9fe21de..c67156c 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/impl/pluginmanagerimpl.cpp +++ b/SQLiteStudio3/coreSQLiteStudio/services/impl/pluginmanagerimpl.cpp @@ -50,7 +50,7 @@ void PluginManagerImpl::deinit() emit aboutToQuit(); // Plugin containers and their plugins - foreach (PluginContainer* container, pluginContainer.values()) + for (PluginContainer* container : pluginContainer.values()) { if (container->builtIn) { @@ -61,13 +61,13 @@ void PluginManagerImpl::deinit() unload(container->name); } - foreach (PluginContainer* container, pluginContainer.values()) + for (PluginContainer* container : pluginContainer.values()) delete container; pluginContainer.clear(); // Types - foreach (PluginType* type, registeredPluginTypes) + for (PluginType* type : registeredPluginTypes) delete type; registeredPluginTypes.clear(); @@ -113,10 +113,10 @@ void PluginManagerImpl::scanPlugins() nameFilters << "*.so" << "*.dll" << "*.dylib"; QPluginLoader* loader = nullptr; - foreach (QString pluginDirPath, pluginDirs) + for (QString pluginDirPath : pluginDirs) { QDir pluginDir(pluginDirPath); - foreach (QString fileName, pluginDir.entryList(nameFilters, QDir::Files)) + for (QString fileName : pluginDir.entryList(nameFilters, QDir::Files)) { fileName = pluginDir.absoluteFilePath(fileName); loader = new QPluginLoader(fileName); @@ -158,7 +158,7 @@ bool PluginManagerImpl::initPlugin(QPluginLoader* loader, const QString& fileNam QJsonObject pluginMetaData = loader->metaData(); QString pluginTypeName = pluginMetaData.value("MetaData").toObject().value("type").toString(); PluginType* pluginType = nullptr; - foreach (PluginType* type, registeredPluginTypes) + for (PluginType* type : registeredPluginTypes) { if (type->getName() == pluginTypeName) { @@ -169,7 +169,7 @@ bool PluginManagerImpl::initPlugin(QPluginLoader* loader, const QString& fileNam if (!pluginType) { - qWarning() << "Could not load plugin" + fileName + "because its type was not recognized:" << pluginTypeName; + qWarning() << "Could not load plugin" << fileName << "because its type was not recognized:" << pluginTypeName; return false; } @@ -305,7 +305,7 @@ bool PluginManagerImpl::initPlugin(Plugin* plugin) { QString pluginName = plugin->getName(); PluginType* pluginType = nullptr; - foreach (PluginType* type, registeredPluginTypes) + for (PluginType* type : registeredPluginTypes) { if (type->test(plugin)) { @@ -316,7 +316,7 @@ bool PluginManagerImpl::initPlugin(Plugin* plugin) if (!pluginType) { - qWarning() << "Could not load built-in plugin" + pluginName + "because its type was not recognized."; + qWarning() << "Could not load built-in plugin" << pluginName << "because its type was not recognized."; return false; } @@ -363,7 +363,7 @@ QStringList PluginManagerImpl::getAllPluginNames(PluginType* type) const if (!pluginCategories.contains(type)) return names; - foreach (PluginContainer* container, pluginCategories[type]) + for (PluginContainer* container : pluginCategories[type]) names << container->name; return names; @@ -685,7 +685,7 @@ QList<Plugin*> PluginManagerImpl::getLoadedPlugins(PluginType* type) const if (!pluginCategories.contains(type)) return list; - foreach (PluginContainer* container, pluginCategories[type]) + for (PluginContainer* container : pluginCategories[type]) { if (container->loaded) list << container->plugin; @@ -769,7 +769,7 @@ bool PluginManagerImpl::arePluginsInitiallyLoaded() const QList<Plugin*> PluginManagerImpl::getLoadedPlugins() const { QList<Plugin*> plugins; - foreach (PluginContainer* container, pluginContainer.values()) + for (PluginContainer* container : pluginContainer.values()) { if (container->loaded) plugins << container->plugin; @@ -780,7 +780,7 @@ QList<Plugin*> PluginManagerImpl::getLoadedPlugins() const QStringList PluginManagerImpl::getLoadedPluginNames() const { QStringList names; - foreach (PluginContainer* container, pluginContainer.values()) + for (PluginContainer* container : pluginContainer.values()) { if (container->loaded) names << container->name; @@ -792,7 +792,7 @@ QList<PluginManager::PluginDetails> PluginManagerImpl::getAllPluginDetails() con { QList<PluginManager::PluginDetails> results; PluginManager::PluginDetails details; - foreach (PluginContainer* container, pluginContainer.values()) + for (PluginContainer* container : pluginContainer.values()) { details.name = container->name; details.title = container->title; diff --git a/SQLiteStudio3/coreSQLiteStudio/services/impl/sqliteextensionmanagerimpl.cpp b/SQLiteStudio3/coreSQLiteStudio/services/impl/sqliteextensionmanagerimpl.cpp new file mode 100644 index 0000000..63dbaf6 --- /dev/null +++ b/SQLiteStudio3/coreSQLiteStudio/services/impl/sqliteextensionmanagerimpl.cpp @@ -0,0 +1,70 @@ +#include "sqliteextensionmanagerimpl.h" +#include "services/notifymanager.h" +#include "services/dbmanager.h" + +SqliteExtensionManagerImpl::SqliteExtensionManagerImpl() +{ + init(); +} + +void SqliteExtensionManagerImpl::setExtensions(const QList<SqliteExtensionManager::ExtensionPtr>& newExtensions) +{ + extensions = newExtensions; + storeInConfig(); + emit extensionListChanged(); +} + +QList<SqliteExtensionManager::ExtensionPtr> SqliteExtensionManagerImpl::getAllExtensions() const +{ + return extensions; +} + +QList<SqliteExtensionManager::ExtensionPtr> SqliteExtensionManagerImpl::getExtensionForDatabase(const QString& dbName) const +{ + QList<ExtensionPtr> results; + for (const ExtensionPtr& ext : extensions) + { + if (ext->allDatabases || ext->databases.contains(dbName, Qt::CaseInsensitive)) + results << ext; + } + return results; +} + +void SqliteExtensionManagerImpl::init() +{ + loadFromConfig(); +} + +void SqliteExtensionManagerImpl::storeInConfig() +{ + QVariantList list; + QHash<QString,QVariant> extHash; + for (ExtensionPtr ext : extensions) + { + extHash["filePath"] = ext->filePath; + extHash["initFunc"] = ext->initFunc; + extHash["allDatabases"] = ext->allDatabases; + extHash["databases"] =common(DBLIST->getDbNames(), ext->databases); + list << extHash; + } + CFG_CORE.Internal.Extensions.set(list); +} + +void SqliteExtensionManagerImpl::loadFromConfig() +{ + extensions.clear(); + + QVariantList list = CFG_CORE.Internal.Extensions.get(); + QHash<QString,QVariant> extHash; + ExtensionPtr ext; + for (const QVariant& var : list) + { + extHash = var.toHash(); + ext = ExtensionPtr::create(); + ext->filePath = extHash["filePath"].toString(); + ext->initFunc = extHash["initFunc"].toString(); + ext->databases = extHash["databases"].toStringList(); + ext->allDatabases = extHash["allDatabases"].toBool(); + extensions << ext; + } +} diff --git a/SQLiteStudio3/coreSQLiteStudio/services/impl/sqliteextensionmanagerimpl.h b/SQLiteStudio3/coreSQLiteStudio/services/impl/sqliteextensionmanagerimpl.h new file mode 100644 index 0000000..6fd7f46 --- /dev/null +++ b/SQLiteStudio3/coreSQLiteStudio/services/impl/sqliteextensionmanagerimpl.h @@ -0,0 +1,23 @@ +#ifndef SQLITEEXTENSIONMANAGERIMPL_H +#define SQLITEEXTENSIONMANAGERIMPL_H + +#include "services/sqliteextensionmanager.h" + +class SqliteExtensionManagerImpl : public SqliteExtensionManager +{ + public: + SqliteExtensionManagerImpl(); + + void setExtensions(const QList<ExtensionPtr>& newExtensions); + QList<ExtensionPtr> getAllExtensions() const; + QList<ExtensionPtr> getExtensionForDatabase(const QString& dbName) const; + + private: + void init(); + void storeInConfig(); + void loadFromConfig(); + + QList<ExtensionPtr> extensions; +}; + +#endif // SQLITEEXTENSIONMANAGERIMPL_H diff --git a/SQLiteStudio3/coreSQLiteStudio/services/pluginmanager.h b/SQLiteStudio3/coreSQLiteStudio/services/pluginmanager.h index 4f822bc..f771c2c 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/pluginmanager.h +++ b/SQLiteStudio3/coreSQLiteStudio/services/pluginmanager.h @@ -380,7 +380,7 @@ class API_EXPORT PluginManager : public QObject template <class T> PluginType* getPluginType() const { - foreach (PluginType* type, getPluginTypes()) + for (PluginType* type : getPluginTypes()) { if (!dynamic_cast<DefinedPluginType<T>*>(type)) continue; @@ -406,7 +406,7 @@ class API_EXPORT PluginManager : public QObject if (!type) return typedPlugins; - foreach (Plugin* plugin, getLoadedPlugins(type)) + for (Plugin* plugin : getLoadedPlugins(type)) typedPlugins << dynamic_cast<T*>(plugin); return typedPlugins; @@ -427,7 +427,7 @@ class API_EXPORT PluginManager : public QObject if (!type) return names; - foreach (Plugin* plugin, getLoadedPlugins(type)) + for (Plugin* plugin : getLoadedPlugins(type)) names << plugin->getName(); return names; diff --git a/SQLiteStudio3/coreSQLiteStudio/services/sqliteextensionmanager.h b/SQLiteStudio3/coreSQLiteStudio/services/sqliteextensionmanager.h new file mode 100644 index 0000000..a135f3b --- /dev/null +++ b/SQLiteStudio3/coreSQLiteStudio/services/sqliteextensionmanager.h @@ -0,0 +1,34 @@ +#ifndef SQLITEEXTENSIONMANAGER_H +#define SQLITEEXTENSIONMANAGER_H + +#include "coreSQLiteStudio_global.h" +#include "sqlitestudio.h" +#include <QSharedPointer> +#include <QObject> + +class API_EXPORT SqliteExtensionManager : public QObject +{ + Q_OBJECT + + public: + struct API_EXPORT Extension + { + QString filePath; + QString initFunc; + QStringList databases; + bool allDatabases = true; + }; + + typedef QSharedPointer<Extension> ExtensionPtr; + + virtual void setExtensions(const QList<ExtensionPtr>& newExtensions) = 0; + virtual QList<ExtensionPtr> getAllExtensions() const = 0; + virtual QList<ExtensionPtr> getExtensionForDatabase(const QString& dbName) const = 0; + + signals: + void extensionListChanged(); +}; + +#define SQLITE_EXTENSIONS SQLITESTUDIO->getSqliteExtensionManager() + +#endif // SQLITEEXTENSIONMANAGER_H diff --git a/SQLiteStudio3/coreSQLiteStudio/services/updatemanager.cpp b/SQLiteStudio3/coreSQLiteStudio/services/updatemanager.cpp index 3663a1b..87df73b 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/updatemanager.cpp +++ b/SQLiteStudio3/coreSQLiteStudio/services/updatemanager.cpp @@ -1,461 +1,100 @@ #ifdef PORTABLE_CONFIG #include "updatemanager.h" -#include "services/pluginmanager.h" #include "services/notifymanager.h" #include "common/unused.h" -#include <QTemporaryDir> -#include <QNetworkAccessManager> -#include <QNetworkReply> -#include <QNetworkRequest> -#include <QUrl> -#include <QUrlQuery> #include <QDebug> +#include <QRegularExpression> #include <QCoreApplication> -#include <QJsonDocument> -#include <QJsonObject> -#include <QJsonArray> -#include <QJsonValue> -#include <QProcess> -#include <QThread> -#include <QtConcurrent/QtConcurrent> - -#ifdef Q_OS_WIN32 -#include "JlCompress.h" -#include <windows.h> -#include <shellapi.h> -#endif - -// Note on creating update packages: -// Packages for Linux and MacOSX should be an archive of _contents_ of SQLiteStudio directory, -// while for Windows it should be an archive of SQLiteStudio directory itself. - -QString UpdateManager::staticErrorMessage; -UpdateManager::RetryFunction UpdateManager::retryFunction = nullptr; +#include <QFileInfo> +#include <QtConcurrent/QtConcurrentRun> UpdateManager::UpdateManager(QObject *parent) : QObject(parent) { - networkManager = new QNetworkAccessManager(this); - connect(networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(finished(QNetworkReply*))); - connect(this, SIGNAL(updatingError(QString)), NOTIFY_MANAGER, SLOT(error(QString))); -} - -UpdateManager::~UpdateManager() -{ - cleanup(); -} + qRegisterMetaType<QList<UpdateManager::UpdateEntry>>(); -void UpdateManager::checkForUpdates(bool force) -{ - getUpdatesMetadata(updatesCheckReply, force); -} - -void UpdateManager::update() -{ - if (updatesGetUrlsReply || updatesInProgress) - return; - - getUpdatesMetadata(updatesGetUrlsReply); -} + connect(this, SIGNAL(updatingError(QString)), NOTIFY_MANAGER, SLOT(error(QString))); -QString UpdateManager::getPlatformForUpdate() const -{ -#if defined(Q_OS_LINUX) - if (QSysInfo::WordSize == 64) - return "linux64"; - else - return "linux32"; -#elif defined(Q_OS_WIN) - return "win32"; + QString updateBinary = +#if defined(Q_OS_WIN) + "UpdateSQLiteStudio.exe"; +#elif defined(Q_OS_LINUX) + "UpdateSQLiteStudio"; #elif defined(Q_OS_OSX) - return "macosx"; + "../../UpdateSQLiteStudio.app/Contents/MacOS/UpdateSQLiteStudio"; #else - return QString(); + ""; #endif -} - -QString UpdateManager::getCurrentVersions() const -{ - QJsonArray versionsArray; - - QJsonObject arrayEntry; - arrayEntry["component"] = "SQLiteStudio"; - arrayEntry["version"] = SQLITESTUDIO->getVersionString(); - versionsArray.append(arrayEntry); - - for (const PluginManager::PluginDetails& details : PLUGINS->getAllPluginDetails()) - { - if (details.builtIn) - continue; - arrayEntry["component"] = details.name; - arrayEntry["version"] = details.versionString; - versionsArray.append(arrayEntry); + if (!updateBinary.isEmpty()) { + updateBinaryAbsolutePath = QFileInfo(QCoreApplication::applicationDirPath() + "/" + updateBinary).absoluteFilePath(); } - - QJsonObject topObj; - topObj["versions"] = versionsArray; - - QJsonDocument doc(topObj); - return QString::fromLatin1(doc.toJson(QJsonDocument::Compact)); -} - -bool UpdateManager::isPlatformEligibleForUpdate() const -{ - return !getPlatformForUpdate().isNull() && getDistributionType() != DistributionType::OS_MANAGED; -} - -#if defined(Q_OS_WIN32) -bool UpdateManager::executePreFinalStepWin(const QString &tempDir, const QString &backupDir, const QString &appDir, bool reqAdmin) -{ - bool res; - if (reqAdmin) - res = executeFinalStepAsRootWin(tempDir, backupDir, appDir); - else - res = executeFinalStep(tempDir, backupDir, appDir); - - if (res) - { - QFileInfo path(qApp->applicationFilePath()); - QProcess::startDetached(appDir + "/" + path.fileName(), {WIN_POST_FINAL_UPDATE_OPTION_NAME, tempDir}); - } - return res; } -#endif -void UpdateManager::handleAvailableUpdatesReply(QNetworkReply* reply) -{ - if (reply->error() != QNetworkReply::NoError) - { - updatingFailed(tr("An error occurred while checking for updates: %1.").arg(reply->errorString())); - reply->deleteLater(); - return; - } - - QJsonParseError err; - QByteArray data = reply->readAll(); - reply->deleteLater(); - - QJsonDocument doc = QJsonDocument::fromJson(data, &err); - if (err.error != QJsonParseError::NoError) - { - qWarning() << "Invalid response from update service:" << err.errorString() << "\n" << "The data was:" << QString::fromLatin1(data); - notifyWarn(tr("Could not check available updates, because server responded with invalid message format. It is safe to ignore this warning.")); - return; - } - - QList<UpdateEntry> updates = readMetadata(doc); - if (updates.size() > 0) - emit updatesAvailable(updates); - else - emit noUpdatesAvailable(); -} - -void UpdateManager::getUpdatesMetadata(QNetworkReply*& replyStoragePointer, bool force) +UpdateManager::~UpdateManager() { -#ifdef PORTABLE_CONFIG - if ((!CFG_CORE.General.CheckUpdatesOnStartup.get() && !force) || !isPlatformEligibleForUpdate() || replyStoragePointer) - return; - - QUrlQuery query; - query.addQueryItem("platform", getPlatformForUpdate()); - query.addQueryItem("data", getCurrentVersions()); - QUrl url(QString::fromLatin1(updateServiceUrl) + "?" + query.query(QUrl::FullyEncoded)); - QNetworkRequest request(url); - replyStoragePointer = networkManager->get(request); -#endif } -void UpdateManager::handleUpdatesMetadata(QNetworkReply* reply) +void UpdateManager::checkForUpdates() { - if (reply->error() != QNetworkReply::NoError) - { - updatingFailed(tr("An error occurred while reading updates metadata: %1.").arg(reply->errorString())); - reply->deleteLater(); + if (!CFG_CORE.General.CheckUpdatesOnStartup.get()) return; - } - QJsonParseError err; - QByteArray data = reply->readAll(); - reply->deleteLater(); - - QJsonDocument doc = QJsonDocument::fromJson(data, &err); - if (err.error != QJsonParseError::NoError) - { - qWarning() << "Invalid response from update service for getting metadata:" << err.errorString() << "\n" << "The data was:" << QString::fromLatin1(data); - notifyWarn(tr("Could not download updates, because server responded with invalid message format. " - "You can try again later or download and install updates manually. See <a href=\"%1\">User Manual</a> for details.").arg(manualUpdatesHelpUrl)); + if (updateBinaryAbsolutePath.isEmpty()) { + qDebug() << "Updater binary not defined. Skipping updates checking."; return; } - tempDir = new QTemporaryDir(); - if (!tempDir->isValid()) { - notifyWarn(tr("Could not create temporary directory for downloading the update. Updating aborted.")); + if (!QFileInfo(updateBinaryAbsolutePath).exists()) { + QString errorDetails = tr("Updates installer executable is missing."); + emit updatingError(tr("Unable to check for updates (%1)").arg(errorDetails.trimmed())); + qWarning() << "Error while checking for updates: " << errorDetails; return; } - updatesInProgress = true; - updatesToDownload = readMetadata(doc); - totalDownloadsCount = updatesToDownload.size(); - totalPercent = 0; - - if (totalDownloadsCount == 0) - { - updatingFailed(tr("There was no updates to download. Updating aborted.")); - return; - } - - downloadUpdates(); + QtConcurrent::run(this, &UpdateManager::checkForUpdatesAsync); } -QList<UpdateManager::UpdateEntry> UpdateManager::readMetadata(const QJsonDocument& doc) +void UpdateManager::checkForUpdatesAsync() { - QList<UpdateEntry> updates; - UpdateEntry entry; - QJsonObject obj = doc.object(); - QJsonArray versionsArray = obj["newVersions"].toArray(); - QJsonObject entryObj; - for (const QJsonValue& value : versionsArray) - { - entryObj = value.toObject(); - entry.compontent = entryObj["component"].toString(); - entry.version = entryObj["version"].toString(); - entry.url = entryObj["url"].toString(); - updates << entry; - } - - return updates; -} - -void UpdateManager::downloadUpdates() -{ - if (updatesToDownload.size() == 0) + QProcess proc; + proc.start(updateBinaryAbsolutePath, {"--checkupdates"}); + if (!waitForProcess(proc)) { - QtConcurrent::run(this, &UpdateManager::installUpdates); - return; - } + QString errorDetails = QString::fromLocal8Bit(proc.readAllStandardError()); - UpdateEntry entry = updatesToDownload.takeFirst(); - currentJobTitle = tr("Downloading: %1").arg(entry.compontent); - emit updatingProgress(currentJobTitle, 0, totalPercent); + if (errorDetails.toLower().contains("no updates")) { + emit noUpdatesAvailable(); + return; + } - QStringList parts = entry.url.split("/"); - if (parts.size() < 1) - { - updatingFailed(tr("Could not determinate file name from update URL: %1. Updating aborted.").arg(entry.url)); - return; - } + if (errorDetails.isEmpty()) + errorDetails = tr("details are unknown"); - QString path = tempDir->path() + QLatin1Char('/') + parts.last(); - currentDownloadFile = new QFile(path); - if (!currentDownloadFile->open(QIODevice::WriteOnly)) - { - updatingFailed(tr("Failed to open file '%1' for writting: %2. Updating aborted.").arg(path, currentDownloadFile->errorString())); + emit updatingError(tr("Unable to check for updates (%1)").arg(errorDetails.trimmed())); + qWarning() << "Error while checking for updates: " << errorDetails; return; } - updatesToInstall[entry.compontent] = path; - - QNetworkRequest request(QUrl(entry.url)); - updatesGetReply = networkManager->get(request); - connect(updatesGetReply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(downloadProgress(qint64,qint64))); - connect(updatesGetReply, SIGNAL(readyRead()), this, SLOT(readDownload())); + processCheckResults(proc.readAllStandardOutput()); } -void UpdateManager::updatingFailed(const QString& errMsg) -{ - cleanup(); - updatesInProgress = false; - emit updatingError(errMsg); -} - -void UpdateManager::installUpdates() +void UpdateManager::update() { - currentJobTitle = tr("Installing updates."); - totalPercent = (totalDownloadsCount - updatesToDownload.size()) * 100 / (totalDownloadsCount + 1); - emit updatingProgress(currentJobTitle, 0, totalPercent); - - requireAdmin = doRequireAdminPrivileges(); - - QTemporaryDir installTempDir; - QString appDirName = QDir(getAppDirPath()).dirName(); - QString targetDir = installTempDir.path() + QLatin1Char('/') + appDirName; - if (!copyRecursively(getAppDirPath(), targetDir)) + bool success = QProcess::startDetached(updateBinaryAbsolutePath, {"--updater"}); + if (!success) { - updatingFailed(tr("Could not copy current application directory into %1 directory.").arg(installTempDir.path())); + emit updatingError(tr("Unable to run updater application (%1). Please report this.").arg(updateBinaryAbsolutePath)); return; } - emit updatingProgress(currentJobTitle, 40, totalPercent); - - int i = 0; - int updatesCnt = updatesToInstall.size(); - for (const QString& component : updatesToInstall.keys()) - { - if (!installComponent(component, targetDir)) - { - cleanup(); - updatesInProgress = false; - return; - } - i++; - emit updatingProgress(currentJobTitle, (30 + (50 / updatesCnt * i)), totalPercent); - } - - if (!executeFinalStep(targetDir)) - { - cleanup(); - updatesInProgress = false; - return; - } - - currentJobTitle = QString(); - totalPercent = 100; - emit updatingProgress(currentJobTitle, 100, totalPercent); - cleanup(); - updatesInProgress = false; -#ifdef Q_OS_WIN32 - installTempDir.setAutoRemove(false); -#endif - - SQLITESTUDIO->setImmediateQuit(true); qApp->exit(0); } -bool UpdateManager::executeFinalStep(const QString& tempDir, const QString& backupDir, const QString& appDir) -{ - bool isWin = false; -#ifdef Q_OS_WIN32 - isWin = true; - - // Windows needs to wait for previus process to exit - QThread::sleep(3); - - QDir dir(backupDir); - QString dirName = dir.dirName(); - dir.cdUp(); - if (!dir.mkdir(dirName)) - { - staticUpdatingFailed(tr("Could not create directory %1.").arg(backupDir)); - return false; - } -#endif - while (!moveDir(appDir, backupDir, isWin)) - { - if (!retryFunction) - { - staticUpdatingFailed(tr("Could not rename directory %1 to %2.\nDetails: %3").arg(appDir, backupDir, staticErrorMessage)); - return false; - } - - if (!retryFunction(tr("Cannot not rename directory %1 to %2.\nDetails: %3").arg(appDir, backupDir, staticErrorMessage))) - return false; - } - - if (!moveDir(tempDir, appDir, isWin)) - { - if (!moveDir(backupDir, appDir, isWin)) - { - staticUpdatingFailed(tr("Could not move directory %1 to %2 and also failed to restore original directory, " - "so the original SQLiteStudio directory is now located at: %3").arg(tempDir, appDir, backupDir)); - } - else - { - staticUpdatingFailed(tr("Could not rename directory %1 to %2. Rolled back to the original SQLiteStudio version.").arg(tempDir, appDir)); - } - deleteDir(backupDir); - return false; - } - - deleteDir(backupDir); - return true; -} - -bool UpdateManager::handleUpdateOptions(const QStringList& argList, int& returnCode) -{ - if (argList.size() == 5 && argList[1] == UPDATE_OPTION_NAME) - { - bool result = UpdateManager::executeFinalStep(argList[2], argList[3], argList[4]); - if (result) - returnCode = 0; - else - returnCode = 1; - - return true; - } - -#ifdef Q_OS_WIN32 - if (argList.size() == 6 && argList[1] == WIN_PRE_FINAL_UPDATE_OPTION_NAME) - { - bool result = UpdateManager::executePreFinalStepWin(argList[2], argList[3], argList[4], (bool)argList[5].toInt()); - if (result) - returnCode = 0; - else - returnCode = -1; - - return true; - } - - if (argList.size() == 3 && argList[1] == WIN_POST_FINAL_UPDATE_OPTION_NAME) - { - QThread::sleep(1); // to make sure that the previous process has quit - returnCode = 0; - UpdateManager::executePostFinalStepWin(argList[2]); - return true; - } -#endif - - return false; -} - -QString UpdateManager::getStaticErrorMessage() -{ - return staticErrorMessage; -} - -bool UpdateManager::executeFinalStep(const QString& tempDir) -{ - QString appDir = getAppDirPath(); - - // Find inexisting dir name next to app dir - QDir backupDir(getBackupDir(appDir)); - -#if defined(Q_OS_WIN32) - return runAnotherInstanceForUpdate(tempDir, backupDir.absolutePath(), qApp->applicationDirPath(), requireAdmin); -#else - bool res; - if (requireAdmin) - res = executeFinalStepAsRoot(tempDir, backupDir.absolutePath(), appDir); - else - res = executeFinalStep(tempDir, backupDir.absolutePath(), appDir); - - if (res) - QProcess::startDetached(qApp->applicationFilePath(), QStringList()); - - return res; -#endif -} - -bool UpdateManager::installComponent(const QString& component, const QString& tempDir) -{ - if (!unpackToDir(updatesToInstall[component], tempDir)) - { - updatingFailed(tr("Could not unpack component %1 into %2 directory.").arg(component, tempDir)); - return false; - } - - // In future here we might also delete/change some files, according to some update script. - return true; -} - -void UpdateManager::cleanup() +bool UpdateManager::isPlatformEligibleForUpdate() const { - safe_delete(currentDownloadFile); - safe_delete(tempDir); - updatesToDownload.clear(); - updatesToInstall.clear(); - requireAdmin = false; + return getDistributionType() != DistributionType::OS_MANAGED; } bool UpdateManager::waitForProcess(QProcess& proc) @@ -481,582 +120,33 @@ bool UpdateManager::waitForProcess(QProcess& proc) return true; } -QString UpdateManager::readError(QProcess& proc, bool reverseOrder) -{ - QString err = QString::fromLocal8Bit(reverseOrder ? proc.readAllStandardOutput() : proc.readAllStandardError()); - if (err.isEmpty()) - err = QString::fromLocal8Bit(reverseOrder ? proc.readAllStandardError() : proc.readAllStandardOutput()); - - QString errStr = proc.errorString(); - if (!errStr.isEmpty()) - err += "\n" + errStr; - - return err; -} - -void UpdateManager::staticUpdatingFailed(const QString& errMsg) +void UpdateManager::processCheckResults(const QByteArray &results) { -#if defined(Q_OS_WIN32) - staticErrorMessage = errMsg; -#else - UPDATES->handleStaticFail(errMsg); -#endif - qCritical() << errMsg; -} - -bool UpdateManager::executeFinalStepAsRoot(const QString& tempDir, const QString& backupDir, const QString& appDir) -{ -#if defined(Q_OS_LINUX) - return executeFinalStepAsRootLinux(tempDir, backupDir, appDir); -#elif defined(Q_OS_WIN32) - return executeFinalStepAsRootWin(tempDir, backupDir, appDir); -#elif defined(Q_OS_MACX) - return executeFinalStepAsRootMac(tempDir, backupDir, appDir); -#else - qCritical() << "Unknown update platform in UpdateManager::executeFinalStepAsRoot() for package" << packagePath; - return false; -#endif -} - -#if defined(Q_OS_LINUX) -bool UpdateManager::executeFinalStepAsRootLinux(const QString& tempDir, const QString& backupDir, const QString& appDir) -{ - QStringList args = {qApp->applicationFilePath(), UPDATE_OPTION_NAME, tempDir, backupDir, appDir}; - - QProcess proc; - LinuxPermElevator elevator = findPermElevatorForLinux(); - switch (elevator) - { - case LinuxPermElevator::KDESU: - proc.setProgram("kdesu"); - args.prepend("-t"); - proc.setArguments(args); - break; - case LinuxPermElevator::GKSU: - proc.setProgram("gksu"); // TODO test gksu updates - proc.setArguments(args); - break; - case LinuxPermElevator::PKEXEC: - { - // We call CLI for doing final step, because pkexec runs cmd completly in root env, so there's no X server. - args[0] += "cli"; - - QStringList newArgs; - for (const QString& arg : args) - newArgs << wrapCmdLineArgument(arg); - - QString cmd = "cd " + wrapCmdLineArgument(qApp->applicationDirPath()) +"; " + newArgs.join(" "); - - proc.setProgram("pkexec"); - proc.setArguments({"sh", "-c", cmd}); - } - break; - case LinuxPermElevator::NONE: - updatingFailed(tr("Could not find permissions elevator application to run update as a root. Looked for: %1").arg("kdesu, gksu, pkexec")); - return false; - } - - proc.start(); - if (!waitForProcess(proc)) - { - updatingFailed(tr("Could not execute final updating steps as root: %1").arg(readError(proc, (elevator == LinuxPermElevator::KDESU)))); - return false; - } - - return true; -} -#endif - -#ifdef Q_OS_MACX -bool UpdateManager::executeFinalStepAsRootMac(const QString& tempDir, const QString& backupDir, const QString& appDir) -{ - // Prepare script for updater - // osascript -e "do shell script \"stufftorunasroot\" with administrator privileges" - QStringList args = {wrapCmdLineArgument(qApp->applicationFilePath() + "cli"), - UPDATE_OPTION_NAME, - wrapCmdLineArgument(tempDir), - wrapCmdLineArgument(backupDir), - wrapCmdLineArgument(appDir)}; - QProcess proc; - - QString innerCmd = wrapCmdLineArgument(args.join(" ")); - - static_qstring(scriptTpl, "do shell script %1 with administrator privileges"); - QString scriptCmd = scriptTpl.arg(innerCmd); - - // Prepare updater temporary directory - QTemporaryDir updaterDir; - if (!updaterDir.isValid()) - { - updatingFailed(tr("Could not execute final updating steps as admin: %1").arg(tr("Cannot create temporary directory for updater."))); - return false; - } - - // Create updater script - QString scriptPath = updaterDir.path() + "/UpdateSQLiteStudio.scpt"; - QFile updaterScript(scriptPath); - if (!updaterScript.open(QIODevice::WriteOnly)) - { - updatingFailed(tr("Could not execute final updating steps as admin: %1").arg(tr("Cannot create updater script file."))); - return false; - } - updaterScript.write(scriptCmd.toLocal8Bit()); - updaterScript.close(); - - // Compile script to updater application - QString updaterApp = updaterDir.path() + "/UpdateSQLiteStudio.app"; - proc.setProgram("osacompile"); - proc.setArguments({"-o", updaterApp, scriptPath}); - proc.start(); - if (!waitForProcess(proc)) - { - updatingFailed(tr("Could not execute final updating steps as admin: %1").arg(readError(proc))); - return false; - } - - // Execute updater - proc.setProgram(updaterApp + "/Contents/MacOS/applet"); - proc.setArguments({}); - proc.start(); - if (!waitForProcess(proc)) - { - updatingFailed(tr("Could not execute final updating steps as admin: %1").arg(readError(proc))); - return false; - } - - // Validating update - // The updater script will not return error if the user canceled the password prompt. - // We need to check if the update was actually made and return true only then. - if (QDir(tempDir).exists()) - { - // Temp dir still exists, so it was not moved by root process - updatingFailed(tr("Updating canceled.")); - return false; - } - - return true; -} -#endif - -#ifdef Q_OS_WIN32 -bool UpdateManager::executeFinalStepAsRootWin(const QString& tempDir, const QString& backupDir, const QString& appDir) -{ - QString updateBin = qApp->applicationDirPath() + "/" + WIN_UPDATER_BINARY; - - QString installFilePath = tempDir + "/" + WIN_INSTALL_FILE; - QFile installFile(installFilePath); - installFile.open(QIODevice::WriteOnly); - QString nl("\n"); - installFile.write(UPDATE_OPTION_NAME); - installFile.write(nl.toLocal8Bit()); - installFile.write(backupDir.toLocal8Bit()); - installFile.write(nl.toLocal8Bit()); - installFile.write(appDir.toLocal8Bit()); - installFile.write(nl.toLocal8Bit()); - installFile.close(); - - int res = (int)::ShellExecuteA(0, "runas", updateBin.toUtf8().constData(), 0, 0, SW_SHOWNORMAL); - if (res < 32) - { - staticUpdatingFailed(tr("Could not execute final updating steps as administrator.")); - return false; - } - - // Since I suck as a developer and I cannot implement a simple synchronous app call under Windows - // (QProcess does it somehow, but I'm too lazy to look it up and probably the solution wouldn't be compatible - // with our "privileges elevation" trick above... so after all I think we're stuck with this solution for now), - // I do the workaround here, which makes this process wait for the other process to create the "done" - // file when it's done, so this process knows when the other has ended. This way we can proceed with this - // process and we will delete some directories later on, which were required by that other process. - if (!waitForFileToDisappear(installFilePath, 10)) - { - staticUpdatingFailed(tr("Could not execute final updating steps as administrator. Updater startup timed out.")); - return false; - } - - if (!waitForFileToAppear(appDir + QLatin1Char('/') + WIN_UPDATE_DONE_FILE, 30)) - { - staticUpdatingFailed(tr("Could not execute final updating steps as administrator. Updater operation timed out.")); - return false; - } - - return true; -} -#endif - -#if defined(Q_OS_WIN32) -bool UpdateManager::executePostFinalStepWin(const QString &tempDir) -{ - QString doneFile = qApp->applicationDirPath() + QLatin1Char('/') + WIN_UPDATE_DONE_FILE; - QFile::remove(doneFile); - - QDir dir(tempDir); - dir.cdUp(); - if (!deleteDir(dir.absolutePath())) - staticUpdatingFailed(tr("Could not clean up temporary directory %1. You can delete it manually at any time.").arg(dir.absolutePath())); - - QProcess::startDetached(qApp->applicationFilePath(), QStringList()); - return true; -} - -bool UpdateManager::waitForFileToDisappear(const QString &filePath, int seconds) -{ - QFile file(filePath); - while (file.exists() && seconds > 0) - { - QThread::sleep(1); - seconds--; - } - - return !file.exists(); -} - -bool UpdateManager::waitForFileToAppear(const QString &filePath, int seconds) -{ - QFile file(filePath); - while (!file.exists() && seconds > 0) - { - QThread::sleep(1); - seconds--; - } - - return file.exists(); -} - -bool UpdateManager::runAnotherInstanceForUpdate(const QString &tempDir, const QString &backupDir, const QString &appDir, bool reqAdmin) -{ - bool res = QProcess::startDetached(tempDir + "/SQLiteStudio.exe", {WIN_PRE_FINAL_UPDATE_OPTION_NAME, tempDir, backupDir, appDir, - QString::number((int)reqAdmin)}); - if (!res) - { - updatingFailed(tr("Could not run new version for continuing update.")); - return false; - } - - return true; -} -#endif - -UpdateManager::LinuxPermElevator UpdateManager::findPermElevatorForLinux() -{ -#if defined(Q_OS_LINUX) - QProcess proc; - proc.setProgram("which"); - - if (!SQLITESTUDIO->getEnv("DISPLAY").isEmpty()) - { - proc.setArguments({"kdesu"}); - proc.start(); - if (waitForProcess(proc)) - return LinuxPermElevator::KDESU; - - proc.setArguments({"gksu"}); - proc.start(); - if (waitForProcess(proc)) - return LinuxPermElevator::GKSU; - } - - proc.setArguments({"pkexec"}); - proc.start(); - if (waitForProcess(proc)) - return LinuxPermElevator::PKEXEC; -#endif - - return LinuxPermElevator::NONE; -} - -QString UpdateManager::wrapCmdLineArgument(const QString& arg) -{ - return "\"" + escapeCmdLineArgument(arg) + "\""; -} - -QString UpdateManager::escapeCmdLineArgument(const QString& arg) -{ - if (!arg.contains("\\") && !arg.contains("\"")) - return arg; - - QString str = arg; - return str.replace("\\", "\\\\").replace("\"", "\\\""); -} - -QString UpdateManager::getBackupDir(const QString &appDir) -{ - static_qstring(bakDirTpl, "%1.old%2"); - QDir backupDir(bakDirTpl.arg(appDir, "")); - int cnt = 1; - while (backupDir.exists()) - backupDir = QDir(bakDirTpl.arg(appDir, QString::number(cnt))); - - return backupDir.absolutePath(); -} - -bool UpdateManager::unpackToDir(const QString& packagePath, const QString& outputDir) -{ -#if defined(Q_OS_LINUX) - return unpackToDirLinux(packagePath, outputDir); -#elif defined(Q_OS_WIN32) - return unpackToDirWin(packagePath, outputDir); -#elif defined(Q_OS_MACX) - return unpackToDirMac(packagePath, outputDir); -#else - qCritical() << "Unknown update platform in UpdateManager::unpackToDir() for package" << packagePath; - return false; -#endif -} - -#if defined(Q_OS_LINUX) -bool UpdateManager::unpackToDirLinux(const QString &packagePath, const QString &outputDir) -{ - QProcess proc; - proc.setWorkingDirectory(outputDir); - proc.setStandardOutputFile(QProcess::nullDevice()); - proc.setStandardErrorFile(QProcess::nullDevice()); - - if (!packagePath.endsWith("tar.gz")) - { - updatingFailed(tr("Package not in tar.gz format, cannot install: %1").arg(packagePath)); - return false; - } - - proc.start("mv", {packagePath, outputDir}); - if (!waitForProcess(proc)) - { - updatingFailed(tr("Package %1 cannot be installed, because cannot move it to directory: %2").arg(packagePath, outputDir)); - return false; - } - - QString fileName = packagePath.split("/").last(); - QString newPath = outputDir + "/" + fileName; - proc.start("tar", {"-xzf", newPath}); - if (!waitForProcess(proc)) - { - updatingFailed(tr("Package %1 cannot be installed, because cannot unpack it: %2").arg(packagePath, readError(proc))); - return false; - } - - QProcess::execute("rm", {"-f", newPath}); - return true; -} -#endif - -#if defined(Q_OS_MACX) -bool UpdateManager::unpackToDirMac(const QString &packagePath, const QString &outputDir) -{ - QProcess proc; - proc.setWorkingDirectory(outputDir); - proc.setStandardOutputFile(QProcess::nullDevice()); - proc.setStandardErrorFile(QProcess::nullDevice()); - - if (!packagePath.endsWith("zip")) - { - updatingFailed(tr("Package not in zip format, cannot install: %1").arg(packagePath)); - return false; - } - - proc.start("unzip", {"-o", "-d", outputDir, packagePath}); - if (!waitForProcess(proc)) - { - updatingFailed(tr("Package %1 cannot be installed, because cannot unzip it to directory %2: %3") - .arg(packagePath, outputDir, readError(proc))); - return false; - } - - return true; -} -#endif - -#if defined(Q_OS_WIN32) -bool UpdateManager::unpackToDirWin(const QString& packagePath, const QString& outputDir) -{ - if (JlCompress::extractDir(packagePath, outputDir + "/..").isEmpty()) - { - updatingFailed(tr("Package %1 cannot be installed, because cannot unzip it to directory: %2").arg(packagePath, outputDir)); - return false; - } - - return true; -} -#endif - -void UpdateManager::handleStaticFail(const QString& errMsg) -{ - emit updatingFailed(errMsg); -} - -QString UpdateManager::getAppDirPath() const -{ - static QString appDir; - if (appDir.isNull()) - { - appDir = qApp->applicationDirPath(); -#ifdef Q_OS_MACX - QDir tmpAppDir(appDir); - tmpAppDir.cdUp(); - tmpAppDir.cdUp(); - appDir = tmpAppDir.absolutePath(); -#endif - } - return appDir; -} - -bool UpdateManager::moveDir(const QString& src, const QString& dst, bool contentsOnly) -{ - // If we're doing a rename in the very same parent directory then we don't want - // the 'move between partitions' to be involved, cause any failure to rename - // is due to permissions or file lock. - QFileInfo srcFi(src); - QFileInfo dstFi(dst); - bool sameParentDir = (srcFi.dir() == dstFi.dir()); - - QDir dir; - if (contentsOnly) - { - QString localSrc; - QString localDst; - QDir srcDir(src); - for (const QFileInfo& entry : srcDir.entryInfoList(QDir::Files|QDir::Dirs|QDir::NoDotAndDotDot|QDir::Hidden|QDir::System)) - { - localSrc = entry.absoluteFilePath(); - localDst = dst + "/" + entry.fileName(); - if (!dir.rename(localSrc, localDst) && (sameParentDir || !renameBetweenPartitions(localSrc, localDst))) - { - staticUpdatingFailed(tr("Could not rename directory %1 to %2.").arg(localSrc, localDst)); - return false; - } - } - } - else - { - if (!dir.rename(src, dst) && (sameParentDir || !renameBetweenPartitions(src, dst))) - { - staticUpdatingFailed(tr("Could not rename directory %1 to %2.").arg(src, dst)); - return false; - } - } - - return true; -} - -bool UpdateManager::deleteDir(const QString& path) -{ - QDir dir(path); - if (!dir.removeRecursively()) - { - staticUpdatingFailed(tr("Could not delete directory %1.").arg(path)); - return false; - } - - return true; -} - -bool UpdateManager::execCmd(const QString& cmd, const QStringList& args, QString* errorMsg) -{ - QProcess proc; - proc.start(cmd, args); - QString cmdString = QString("%1 \"%2\"").arg(cmd, args.join("\\\" \\\"")); - - if (!waitForProcess(proc)) - { - if (errorMsg) - *errorMsg = tr("Error executing update command: %1\nError message: %2").arg(cmdString).arg(readError(proc)); - - return false; - } - - return true; -} - -void UpdateManager::setRetryFunction(const RetryFunction &value) -{ - retryFunction = value; -} - -bool UpdateManager::doRequireAdminPrivileges() -{ - QString appDirPath = getAppDirPath(); - QDir appDir(appDirPath); - bool isWritable = isWritableRecursively(appDir.absolutePath()); - - appDir.cdUp(); - QFileInfo fi(appDir.absolutePath()); - isWritable &= fi.isWritable(); - - if (isWritable) - { - QDir backupDir(getBackupDir(appDirPath)); - QString backupDirName = backupDir.dirName(); - backupDir.cdUp(); - if (backupDir.mkdir(backupDirName)) - backupDir.rmdir(backupDirName); - else - isWritable = false; - } - - return !isWritable; -} - -void UpdateManager::finished(QNetworkReply* reply) -{ - if (reply == updatesCheckReply) - { - updatesCheckReply = nullptr; - handleAvailableUpdatesReply(reply); - return; - } - - if (reply == updatesGetUrlsReply) - { - updatesGetUrlsReply = nullptr; - handleUpdatesMetadata(reply); + if (results.trimmed().isEmpty()) { + emit noUpdatesAvailable(); return; } - if (reply == updatesGetReply) - { - handleDownloadReply(reply); - if (reply == updatesGetReply) // if no new download is requested - updatesGetReply = nullptr; + QRegularExpression re(R"(\<update\s+([^\>]+)\>)"); + QRegularExpression versionRe(R"(version\=\"([\d\.]+)\")"); + QRegularExpression nameRe(R"(name\=\"([^\"]+)\")"); - return; - } -} - -void UpdateManager::handleDownloadReply(QNetworkReply* reply) -{ - if (reply->error() != QNetworkReply::NoError) + QRegularExpressionMatchIterator reIter = re.globalMatch(results); + QString updateNode; + UpdateEntry theUpdate; + QList<UpdateEntry> updates; + while (reIter.hasNext()) { - updatingFailed(tr("An error occurred while downloading updates: %1. Updating aborted.").arg(reply->errorString())); - reply->deleteLater(); - return; + updateNode = reIter.next().captured(1); + theUpdate.version = versionRe.match(updateNode).captured(1); + theUpdate.compontent = nameRe.match(updateNode).captured(1); + updates << theUpdate; } - totalPercent = (totalDownloadsCount - updatesToDownload.size()) * 100 / (totalDownloadsCount + 1); - - readDownload(); - currentDownloadFile->close(); - - safe_delete(currentDownloadFile); - - reply->deleteLater(); - downloadUpdates(); -} - -void UpdateManager::downloadProgress(qint64 bytesReceived, qint64 totalBytes) -{ - int perc; - if (totalBytes < 0) - perc = -1; - else if (totalBytes == 0) - perc = 100; + if (updates.isEmpty()) + emit noUpdatesAvailable(); else - perc = bytesReceived * 100 / totalBytes; - - emit updatingProgress(currentJobTitle, perc, totalPercent); -} - -void UpdateManager::readDownload() -{ - currentDownloadFile->write(updatesGetReply->readAll()); + emit updatesAvailable(updates); } #endif // PORTABLE_CONFIG diff --git a/SQLiteStudio3/coreSQLiteStudio/services/updatemanager.h b/SQLiteStudio3/coreSQLiteStudio/services/updatemanager.h index bb33487..50f4b6b 100644 --- a/SQLiteStudio3/coreSQLiteStudio/services/updatemanager.h +++ b/SQLiteStudio3/coreSQLiteStudio/services/updatemanager.h @@ -18,122 +18,34 @@ class API_EXPORT UpdateManager : public QObject { Q_OBJECT public: - typedef std::function<bool(const QString& msg)> RetryFunction; - struct UpdateEntry { QString compontent; QString version; - QString url; }; explicit UpdateManager(QObject *parent = 0); ~UpdateManager(); - void checkForUpdates(bool force = false); + void checkForUpdates(); void update(); bool isPlatformEligibleForUpdate() const; - static bool executeFinalStep(const QString& tempDir, const QString& backupDir, const QString& appDir); - static bool handleUpdateOptions(const QStringList& argList, int& returnCode); - static QString getStaticErrorMessage(); - - static void setRetryFunction(const RetryFunction &value); - - static_char* UPDATE_OPTION_NAME = "--update-final-step"; - static_char* WIN_INSTALL_FILE = "install.dat"; - static_char* WIN_UPDATE_DONE_FILE = "UpdateFinished.lck"; private: - enum class LinuxPermElevator - { - KDESU, - GKSU, - PKEXEC, - NONE - }; + QString updateBinaryAbsolutePath; - QString getPlatformForUpdate() const; - QString getCurrentVersions() const; - void handleAvailableUpdatesReply(QNetworkReply* reply); - void handleDownloadReply(QNetworkReply* reply); - void getUpdatesMetadata(QNetworkReply*& replyStoragePointer, bool force = false); - void handleUpdatesMetadata(QNetworkReply* reply); - QList<UpdateEntry> readMetadata(const QJsonDocument& doc); - void downloadUpdates(); - void updatingFailed(const QString& errMsg); - void installUpdates(); - bool installComponent(const QString& component, const QString& tempDir); - bool executeFinalStep(const QString& tempDir); - bool executeFinalStepAsRoot(const QString& tempDir, const QString& backupDir, const QString& appDir); -#if defined(Q_OS_LINUX) - bool executeFinalStepAsRootLinux(const QString& tempDir, const QString& backupDir, const QString& appDir); - bool unpackToDirLinux(const QString& packagePath, const QString& outputDir); -#elif defined(Q_OS_MACX) - bool unpackToDirMac(const QString& packagePath, const QString& outputDir); - bool executeFinalStepAsRootMac(const QString& tempDir, const QString& backupDir, const QString& appDir); -#elif defined(Q_OS_WIN32) - bool runAnotherInstanceForUpdate(const QString& tempDir, const QString& backupDir, const QString& appDir, bool reqAdmin); - bool unpackToDirWin(const QString& packagePath, const QString& outputDir); -#endif - bool doRequireAdminPrivileges(); - bool unpackToDir(const QString& packagePath, const QString& outputDir); - void handleStaticFail(const QString& errMsg); - QString getAppDirPath() const; - void cleanup(); - - static bool moveDir(const QString& src, const QString& dst, bool contentsOnly = false); - static bool deleteDir(const QString& path); - static bool execCmd(const QString& cmd, const QStringList& args, QString* errorMsg = nullptr); - static bool waitForProcess(QProcess& proc); - static QString readError(QProcess& proc, bool reverseOrder = false); - static void staticUpdatingFailed(const QString& errMsg); - static LinuxPermElevator findPermElevatorForLinux(); - static QString wrapCmdLineArgument(const QString& arg); - static QString escapeCmdLineArgument(const QString& arg); - static QString getBackupDir(const QString& appDir); -#if defined(Q_OS_WIN32) - static bool executePreFinalStepWin(const QString& tempDir, const QString& backupDir, const QString& appDir, bool reqAdmin); - static bool executeFinalStepAsRootWin(const QString& tempDir, const QString& backupDir, const QString& appDir); - static bool executePostFinalStepWin(const QString& tempDir); - static bool waitForFileToDisappear(const QString& filePath, int seconds); - static bool waitForFileToAppear(const QString& filePath, int seconds); -#endif - - QNetworkAccessManager* networkManager = nullptr; - QNetworkReply* updatesCheckReply = nullptr; - QNetworkReply* updatesGetUrlsReply = nullptr; - QNetworkReply* updatesGetReply = nullptr; - bool updatesInProgress = false; - QList<UpdateEntry> updatesToDownload; - QHash<QString,QString> updatesToInstall; - QTemporaryDir* tempDir = nullptr; - QFile* currentDownloadFile = nullptr; - int totalPercent = 0; - int totalDownloadsCount = 0; - QString currentJobTitle; - bool requireAdmin = false; - static RetryFunction retryFunction; - - static QString staticErrorMessage; - static_char* WIN_PRE_FINAL_UPDATE_OPTION_NAME = "--update-pre-final-step"; - static_char* WIN_POST_FINAL_UPDATE_OPTION_NAME = "--update-post-final-step"; - static_char* WIN_UPDATER_BINARY = "UpdateSQLiteStudio.exe"; - static_char* updateServiceUrl = "http://sqlitestudio.pl/updates3.rvt"; - static_char* manualUpdatesHelpUrl = "http://wiki.sqlitestudio.pl/index.php/User_Manual#Manual"; - - private slots: - void finished(QNetworkReply* reply); - void downloadProgress(qint64 bytesReceived, qint64 totalBytes); - void readDownload(); + void checkForUpdatesAsync(); + bool waitForProcess(QProcess& proc); + void processCheckResults(const QByteArray& results); signals: void updatesAvailable(const QList<UpdateManager::UpdateEntry>& updates); void noUpdatesAvailable(); - void updatingProgress(const QString& jobTitle, int jobPercent, int totalPercent); - void updatingFinished(); void updatingError(const QString& errorMessage); }; +Q_DECLARE_METATYPE(QList<UpdateManager::UpdateEntry>) + #define UPDATES SQLITESTUDIO->getUpdateManager() #endif // PORTABLE_CONFIG |