- QSqlQuery insertServersQuery(logDb());
- insertServersQuery.prepare(queryString("insert_server"));
- foreach(QVariant server_, info.serverList) {
- QVariantMap server = server_.toMap();
- insertServersQuery.bindValue(":hostname", server["Host"]);
- insertServersQuery.bindValue(":port", server["Port"].toInt());
- insertServersQuery.bindValue(":password", server["Password"]);
- insertServersQuery.bindValue(":ssl", server["UseSSL"].toBool() ? 1 : 0);
- insertServersQuery.bindValue(":userid", user.toInt());
- insertServersQuery.bindValue(":networkid", info.networkId.toInt());
-
- safeExec(insertServersQuery);
- if(!watchQuery(insertServersQuery))
- return false;
- }
-
- return true;
-}
-
-bool SqliteStorage::removeNetwork(UserId user, const NetworkId &networkId) {
- if(!isValidNetwork(user, networkId))
- return false;
-
- bool withTransaction = logDb().driver()->hasFeature(QSqlDriver::Transactions);
- if(withTransaction) {
- sync();
- if(!logDb().transaction()) {
- qWarning() << "SqliteStorage::removeNetwork(): cannot start transaction. continuing with out rollback support!";
- withTransaction = false;
- }
- }
-
- QSqlQuery deleteBacklogQuery(logDb());
- deleteBacklogQuery.prepare(queryString("delete_backlog_for_network"));
- deleteBacklogQuery.bindValue(":networkid", networkId.toInt());
- safeExec(deleteBacklogQuery);
- if(!watchQuery(deleteBacklogQuery)) {
- if(withTransaction)
- logDb().rollback();
- return false;
- }
-
- QSqlQuery deleteBuffersQuery(logDb());
- deleteBuffersQuery.prepare(queryString("delete_buffers_for_network"));
- deleteBuffersQuery.bindValue(":networkid", networkId.toInt());
- safeExec(deleteBuffersQuery);
- if(!watchQuery(deleteBuffersQuery)) {
- if(withTransaction)
- logDb().rollback();
- return false;
- }
-
- QSqlQuery deleteServersQuery(logDb());
- deleteServersQuery.prepare(queryString("delete_ircservers_for_network"));
- deleteServersQuery.bindValue(":networkid", networkId.toInt());
- safeExec(deleteServersQuery);
- if(!watchQuery(deleteServersQuery)) {
- if(withTransaction)
- logDb().rollback();
- return false;
- }
-
- QSqlQuery deleteNetworkQuery(logDb());
- deleteNetworkQuery.prepare(queryString("delete_network"));
- deleteNetworkQuery.bindValue(":networkid", networkId.toInt());
- safeExec(deleteNetworkQuery);
- if(!watchQuery(deleteNetworkQuery)) {
- if(withTransaction)
- logDb().rollback();
- return false;
- }
+bool SqliteStorage::updateIdentity(UserId user, const CoreIdentity& identity)
+{
+ QSqlDatabase db = logDb();
+ bool error = false;
+ db.transaction();
+
+ {
+ QSqlQuery checkQuery(db);
+ checkQuery.prepare(queryString("select_checkidentity"));
+ checkQuery.bindValue(":identityid", identity.id().toInt());
+ checkQuery.bindValue(":userid", user.toInt());
+ lockForRead();
+ safeExec(checkQuery);
+
+ // there should be exactly one identity for the given id and user
+ error = (!checkQuery.first() || checkQuery.value(0).toInt() != 1);
+ }
+ if (error) {
+ unlock();
+ return false;
+ }
+
+ {
+ QSqlQuery query(db);
+ query.prepare(queryString("update_identity"));
+ query.bindValue(":identityname", identity.identityName());
+ query.bindValue(":realname", identity.realName());
+ query.bindValue(":awaynick", identity.awayNick());
+ query.bindValue(":awaynickenabled", identity.awayNickEnabled() ? 1 : 0);
+ query.bindValue(":awayreason", identity.awayReason());
+ query.bindValue(":awayreasonenabled", identity.awayReasonEnabled() ? 1 : 0);
+ query.bindValue(":autoawayenabled", identity.awayReasonEnabled() ? 1 : 0);
+ query.bindValue(":autoawaytime", identity.autoAwayTime());
+ query.bindValue(":autoawayreason", identity.autoAwayReason());
+ query.bindValue(":autoawayreasonenabled", identity.autoAwayReasonEnabled() ? 1 : 0);
+ query.bindValue(":detachawayenabled", identity.detachAwayEnabled() ? 1 : 0);
+ query.bindValue(":detachawayreason", identity.detachAwayReason());
+ query.bindValue(":detachawayreasonenabled", identity.detachAwayReasonEnabled() ? 1 : 0);
+ query.bindValue(":ident", identity.ident());
+ query.bindValue(":kickreason", identity.kickReason());
+ query.bindValue(":partreason", identity.partReason());
+ query.bindValue(":quitreason", identity.quitReason());
+ query.bindValue(":sslcert", identity.sslCert().toPem());
+ query.bindValue(":sslkey", identity.sslKey().toPem());
+ query.bindValue(":identityid", identity.id().toInt());
+ safeExec(query);
+ watchQuery(query);
+
+ QSqlQuery deleteNickQuery(db);
+ deleteNickQuery.prepare(queryString("delete_nicks"));
+ deleteNickQuery.bindValue(":identityid", identity.id().toInt());
+ safeExec(deleteNickQuery);
+ watchQuery(deleteNickQuery);
+
+ QSqlQuery insertNickQuery(db);
+ insertNickQuery.prepare(queryString("insert_nick"));
+ foreach (QString nick, identity.nicks()) {
+ insertNickQuery.bindValue(":identityid", identity.id().toInt());
+ insertNickQuery.bindValue(":nick", nick);
+ safeExec(insertNickQuery);
+ watchQuery(insertNickQuery);
+ }
+ db.commit();
+ }
+ unlock();
+ return true;
+}
+
+void SqliteStorage::removeIdentity(UserId user, IdentityId identityId)
+{
+ QSqlDatabase db = logDb();
+ db.transaction();
+
+ bool error = false;
+ {
+ QSqlQuery checkQuery(db);
+ checkQuery.prepare(queryString("select_checkidentity"));
+ checkQuery.bindValue(":identityid", identityId.toInt());
+ checkQuery.bindValue(":userid", user.toInt());
+ lockForRead();
+ safeExec(checkQuery);
+
+ // there should be exactly one identity for the given id and user
+ error = (!checkQuery.first() || checkQuery.value(0).toInt() != 1);
+ }
+ if (error) {
+ unlock();
+ return;
+ }
+
+ {
+ QSqlQuery deleteNickQuery(db);
+ deleteNickQuery.prepare(queryString("delete_nicks"));
+ deleteNickQuery.bindValue(":identityid", identityId.toInt());
+ safeExec(deleteNickQuery);
+
+ QSqlQuery deleteIdentityQuery(db);
+ deleteIdentityQuery.prepare(queryString("delete_identity"));
+ deleteIdentityQuery.bindValue(":identityid", identityId.toInt());
+ deleteIdentityQuery.bindValue(":userid", user.toInt());
+ safeExec(deleteIdentityQuery);
+ db.commit();
+ }
+ unlock();
+}
+
+std::vector<CoreIdentity> SqliteStorage::identities(UserId user)
+{
+ std::vector<CoreIdentity> identities;
+ QSqlDatabase db = logDb();
+ db.transaction();
+
+ {
+ QSqlQuery query(db);
+ query.prepare(queryString("select_identities"));
+ query.bindValue(":userid", user.toInt());
+
+ QSqlQuery nickQuery(db);
+ nickQuery.prepare(queryString("select_nicks"));
+
+ lockForRead();
+ safeExec(query);
+
+ while (query.next()) {
+ CoreIdentity identity(IdentityId(query.value(0).toInt()));
+
+ identity.setIdentityName(query.value(1).toString());
+ identity.setRealName(query.value(2).toString());
+ identity.setAwayNick(query.value(3).toString());
+ identity.setAwayNickEnabled(!!query.value(4).toInt());
+ identity.setAwayReason(query.value(5).toString());
+ identity.setAwayReasonEnabled(!!query.value(6).toInt());
+ identity.setAutoAwayEnabled(!!query.value(7).toInt());
+ identity.setAutoAwayTime(query.value(8).toInt());
+ identity.setAutoAwayReason(query.value(9).toString());
+ identity.setAutoAwayReasonEnabled(!!query.value(10).toInt());
+ identity.setDetachAwayEnabled(!!query.value(11).toInt());
+ identity.setDetachAwayReason(query.value(12).toString());
+ identity.setDetachAwayReasonEnabled(!!query.value(13).toInt());
+ identity.setIdent(query.value(14).toString());
+ identity.setKickReason(query.value(15).toString());
+ identity.setPartReason(query.value(16).toString());
+ identity.setQuitReason(query.value(17).toString());
+ identity.setSslCert(query.value(18).toByteArray());
+ identity.setSslKey(query.value(19).toByteArray());
+
+ nickQuery.bindValue(":identityid", identity.id().toInt());
+ QList<QString> nicks;
+ safeExec(nickQuery);
+ watchQuery(nickQuery);
+ while (nickQuery.next()) {
+ nicks << nickQuery.value(0).toString();
+ }
+ identity.setNicks(std::move(nicks));
+ identities.push_back(std::move(identity));
+ }
+ db.commit();
+ }
+ unlock();
+ return identities;
+}
+
+NetworkId SqliteStorage::createNetwork(UserId user, const NetworkInfo& info)
+{
+ NetworkId networkId;
+
+ QSqlDatabase db = logDb();
+ db.transaction();
+
+ bool error = false;
+ {
+ QSqlQuery query(db);
+ query.prepare(queryString("insert_network"));
+ query.bindValue(":userid", user.toInt());
+ bindNetworkInfo(query, info);
+ lockForWrite();
+ safeExec(query);
+ if (!watchQuery(query)) {
+ db.rollback();
+ error = true;
+ }
+ else {
+ networkId = query.lastInsertId().toInt();
+ }
+ }
+ if (error) {
+ unlock();
+ return {};
+ }
+
+ {
+ QSqlQuery insertServersQuery(db);
+ insertServersQuery.prepare(queryString("insert_server"));
+ foreach (Network::Server server, info.serverList) {
+ insertServersQuery.bindValue(":userid", user.toInt());
+ insertServersQuery.bindValue(":networkid", networkId.toInt());
+ bindServerInfo(insertServersQuery, server);
+ safeExec(insertServersQuery);
+ if (!watchQuery(insertServersQuery)) {
+ db.rollback();
+ error = true;
+ break;
+ }
+ }
+ if (!error)
+ db.commit();
+ }
+ unlock();
+ if (error)
+ return {};
+ else
+ return networkId;
+}
+
+void SqliteStorage::bindNetworkInfo(QSqlQuery& query, const NetworkInfo& info)
+{
+ query.bindValue(":networkname", info.networkName);
+ query.bindValue(":identityid", info.identity.toInt());
+ query.bindValue(":encodingcodec", QString(info.codecForEncoding));
+ query.bindValue(":decodingcodec", QString(info.codecForDecoding));
+ query.bindValue(":servercodec", QString(info.codecForServer));
+ query.bindValue(":userandomserver", info.useRandomServer ? 1 : 0);
+ query.bindValue(":perform", info.perform.join("\n"));
+ query.bindValue(":useautoidentify", info.useAutoIdentify ? 1 : 0);
+ query.bindValue(":autoidentifyservice", info.autoIdentifyService);
+ query.bindValue(":autoidentifypassword", info.autoIdentifyPassword);
+ query.bindValue(":usesasl", info.useSasl ? 1 : 0);
+ query.bindValue(":saslaccount", info.saslAccount);
+ query.bindValue(":saslpassword", info.saslPassword);
+ query.bindValue(":useautoreconnect", info.useAutoReconnect ? 1 : 0);
+ query.bindValue(":autoreconnectinterval", info.autoReconnectInterval);
+ query.bindValue(":autoreconnectretries", info.autoReconnectRetries);
+ query.bindValue(":unlimitedconnectretries", info.unlimitedReconnectRetries ? 1 : 0);
+ query.bindValue(":rejoinchannels", info.rejoinChannels ? 1 : 0);
+ // Custom rate limiting
+ query.bindValue(":usecustomessagerate", info.useCustomMessageRate ? 1 : 0);
+ query.bindValue(":messagerateburstsize", info.messageRateBurstSize);
+ query.bindValue(":messageratedelay", info.messageRateDelay);
+ query.bindValue(":unlimitedmessagerate", info.unlimitedMessageRate ? 1 : 0);
+ if (info.networkId.isValid())
+ query.bindValue(":networkid", info.networkId.toInt());
+}
+
+void SqliteStorage::bindServerInfo(QSqlQuery& query, const Network::Server& server)
+{
+ query.bindValue(":hostname", server.host);
+ query.bindValue(":port", server.port);
+ query.bindValue(":password", server.password);
+ query.bindValue(":ssl", server.useSsl ? 1 : 0);
+ query.bindValue(":sslversion", server.sslVersion);
+ query.bindValue(":useproxy", server.useProxy ? 1 : 0);
+ query.bindValue(":proxytype", server.proxyType);
+ query.bindValue(":proxyhost", server.proxyHost);
+ query.bindValue(":proxyport", server.proxyPort);
+ query.bindValue(":proxyuser", server.proxyUser);
+ query.bindValue(":proxypass", server.proxyPass);
+ query.bindValue(":sslverify", server.sslVerify ? 1 : 0);
+}
+
+bool SqliteStorage::updateNetwork(UserId user, const NetworkInfo& info)
+{
+ QSqlDatabase db = logDb();
+ bool error = false;
+ db.transaction();
+
+ {
+ QSqlQuery updateQuery(db);
+ updateQuery.prepare(queryString("update_network"));
+ updateQuery.bindValue(":userid", user.toInt());
+ bindNetworkInfo(updateQuery, info);
+
+ lockForWrite();
+ safeExec(updateQuery);
+ if (!watchQuery(updateQuery) || updateQuery.numRowsAffected() != 1) {
+ error = true;
+ db.rollback();
+ }
+ }
+ if (error) {
+ unlock();
+ return false;
+ }
+
+ {
+ QSqlQuery dropServersQuery(db);
+ dropServersQuery.prepare("DELETE FROM ircserver WHERE networkid = :networkid");
+ dropServersQuery.bindValue(":networkid", info.networkId.toInt());
+ safeExec(dropServersQuery);
+ if (!watchQuery(dropServersQuery)) {
+ error = true;
+ db.rollback();
+ }
+ }
+ if (error) {
+ unlock();
+ return false;
+ }
+
+ {
+ QSqlQuery insertServersQuery(db);
+ insertServersQuery.prepare(queryString("insert_server"));
+ foreach (Network::Server server, info.serverList) {
+ insertServersQuery.bindValue(":userid", user.toInt());
+ insertServersQuery.bindValue(":networkid", info.networkId.toInt());
+ bindServerInfo(insertServersQuery, server);
+ safeExec(insertServersQuery);
+ if (!watchQuery(insertServersQuery)) {
+ error = true;
+ db.rollback();
+ break;
+ }
+ }
+ }