730 lines
27 KiB
C++
730 lines
27 KiB
C++
// This file is part of RSS Guard.
|
|
//
|
|
// Copyright (C) 2011-2015 by Martin Rotter <rotter.martinos@gmail.com>
|
|
//
|
|
// RSS Guard is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// RSS Guard is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with RSS Guard. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "core/feed.h"
|
|
|
|
#include "definitions/definitions.h"
|
|
#include "core/parsingfactory.h"
|
|
#include "core/feedsmodel.h"
|
|
#include "miscellaneous/databasefactory.h"
|
|
#include "miscellaneous/textfactory.h"
|
|
#include "miscellaneous/settings.h"
|
|
#include "miscellaneous/iconfactory.h"
|
|
#include "miscellaneous/simplecrypt/simplecrypt.h"
|
|
#include "network-web/networkfactory.h"
|
|
|
|
#include <QSqlDatabase>
|
|
#include <QSqlQuery>
|
|
#include <QSqlError>
|
|
#include <QVariant>
|
|
#include <QTextCodec>
|
|
#include <QDomDocument>
|
|
#include <QDomNode>
|
|
#include <QDomElement>
|
|
#include <QXmlStreamReader>
|
|
|
|
|
|
void Feed::init() {
|
|
m_passwordProtected = false;
|
|
m_username = QString();
|
|
m_password = QString();
|
|
m_status = Normal;
|
|
m_networkError = QNetworkReply::NoError;
|
|
m_type = Rss0X;
|
|
m_totalCount = 0;
|
|
m_unreadCount = 0;
|
|
m_autoUpdateType = DontAutoUpdate;
|
|
m_autoUpdateInitialInterval = DEFAULT_AUTO_UPDATE_INTERVAL;
|
|
m_autoUpdateRemainingInterval = DEFAULT_AUTO_UPDATE_INTERVAL;
|
|
m_encoding = QString();
|
|
m_url = QString();
|
|
m_kind = RootItem::Feeed;
|
|
}
|
|
|
|
Feed::Feed(RootItem *parent_item)
|
|
: RootItem(parent_item) {
|
|
init();
|
|
}
|
|
|
|
Feed::Feed(const Feed &other)
|
|
: RootItem(NULL) {
|
|
m_passwordProtected = other.passwordProtected();
|
|
m_username = other.username();
|
|
m_password = other.password();
|
|
m_status = other.status();
|
|
m_networkError = other.networkError();
|
|
m_type = other.type();
|
|
m_totalCount = other.countOfAllMessages();
|
|
m_unreadCount = other.countOfUnreadMessages();
|
|
m_autoUpdateType = other.autoUpdateType();
|
|
m_autoUpdateInitialInterval = other.autoUpdateInitialInterval();
|
|
m_autoUpdateRemainingInterval = other.autoUpdateRemainingInterval();
|
|
m_encoding = other.encoding();
|
|
m_url = other.url();
|
|
m_kind = RootItem::Feeed;
|
|
m_title = other.title();
|
|
m_id = other.id();
|
|
m_icon = other.icon();
|
|
m_childItems = other.childItems();
|
|
m_parentItem = other.parent();
|
|
m_creationDate = other.creationDate();
|
|
m_description = other.description();
|
|
}
|
|
|
|
Feed::~Feed() {
|
|
qDebug("Destroying Feed instance.");
|
|
}
|
|
|
|
int Feed::childCount() const {
|
|
// Because feed has no children.
|
|
return 0;
|
|
}
|
|
|
|
int Feed::countOfAllMessages() const {
|
|
return m_totalCount;
|
|
}
|
|
|
|
int Feed::countOfUnreadMessages() const {
|
|
return m_unreadCount;
|
|
}
|
|
|
|
QString Feed::typeToString(Feed::Type type) {
|
|
switch (type) {
|
|
case Atom10:
|
|
return QSL("ATOM 1.0");
|
|
|
|
case Rdf:
|
|
return QSL("RDF (RSS 1.0)");
|
|
|
|
case Rss0X:
|
|
return QSL("RSS 0.91/0.92/0.93");
|
|
|
|
case Rss2X:
|
|
default:
|
|
return QSL("RSS 2.0/2.0.1");
|
|
}
|
|
}
|
|
|
|
void Feed::updateCounts(bool including_total_count, bool update_feed_statuses) {
|
|
QSqlDatabase database = qApp->database()->connection(QSL("Feed"), DatabaseFactory::FromSettings);
|
|
QSqlQuery query_all(database);
|
|
|
|
query_all.setForwardOnly(true);
|
|
|
|
if (including_total_count) {
|
|
if (query_all.exec(QString("SELECT count(*) FROM Messages WHERE feed = %1 AND is_deleted = 0;").arg(id())) && query_all.next()) {
|
|
m_totalCount = query_all.value(0).toInt();
|
|
}
|
|
}
|
|
|
|
// Obtain count of unread messages.
|
|
if (query_all.exec(QString("SELECT count(*) FROM Messages WHERE feed = %1 AND is_deleted = 0 AND is_read = 0;").arg(id())) && query_all.next()) {
|
|
int new_unread_count = query_all.value(0).toInt();
|
|
|
|
if (update_feed_statuses && m_status == NewMessages && new_unread_count < m_unreadCount) {
|
|
m_status = Normal;
|
|
}
|
|
|
|
m_unreadCount = new_unread_count;
|
|
}
|
|
}
|
|
|
|
void Feed::fetchMetadataForItself() {
|
|
QPair<Feed*,QNetworkReply::NetworkError> metadata = guessFeed(url(), username(), password());
|
|
|
|
if (metadata.first != NULL && metadata.second == QNetworkReply::NoError) {
|
|
// Some properties are not updated when new metadata are fetched.
|
|
metadata.first->setParent(parent());
|
|
metadata.first->setUrl(url());
|
|
metadata.first->setPasswordProtected(passwordProtected());
|
|
metadata.first->setUsername(username());
|
|
metadata.first->setPassword(password());
|
|
metadata.first->setAutoUpdateType(autoUpdateType());
|
|
metadata.first->setAutoUpdateInitialInterval(autoUpdateInitialInterval());
|
|
|
|
editItself(metadata.first);
|
|
delete metadata.first;
|
|
}
|
|
else {
|
|
qApp->showGuiMessage(tr("Metadata not fetched"),
|
|
tr("Metadata was not fetched because: %1").arg(NetworkFactory::networkErrorText(metadata.second)),
|
|
QSystemTrayIcon::Critical);
|
|
}
|
|
}
|
|
|
|
QPair<Feed*,QNetworkReply::NetworkError> Feed::guessFeed(const QString &url, const QString &username, const QString &password) {
|
|
QPair<Feed*,QNetworkReply::NetworkError> result; result.first = NULL;
|
|
|
|
QByteArray feed_contents;
|
|
NetworkResult network_result = NetworkFactory::downloadFeedFile(url,
|
|
qApp->settings()->value(GROUP(Feeds),
|
|
SETTING(Feeds::UpdateTimeout)).toInt(),
|
|
feed_contents,
|
|
!username.isEmpty(),
|
|
username,
|
|
password);
|
|
result.second = network_result.first;
|
|
|
|
if (result.second == QNetworkReply::NoError) {
|
|
// Feed XML was obtained, now we need to try to guess
|
|
// its encoding before we can read further data.
|
|
QString xml_schema_encoding;
|
|
QString xml_contents_encoded;
|
|
QRegExp encoding_rexp(QSL("encoding=\"[^\"]\\S+\""));
|
|
|
|
if (encoding_rexp.indexIn(feed_contents) != -1 &&
|
|
!(xml_schema_encoding = encoding_rexp.cap(0)).isEmpty()) {
|
|
// Some "encoding" attribute was found get the encoding
|
|
// out of it.
|
|
encoding_rexp.setPattern(QSL("[^\"]\\S+[^\"]"));
|
|
encoding_rexp.indexIn(xml_schema_encoding, 9);
|
|
xml_schema_encoding = encoding_rexp.cap(0);
|
|
}
|
|
|
|
if (result.first == NULL) {
|
|
result.first = new Feed();
|
|
}
|
|
|
|
QTextCodec *custom_codec = QTextCodec::codecForName(xml_schema_encoding.toLocal8Bit());
|
|
|
|
if (custom_codec != NULL) {
|
|
// Feed encoding was probably guessed.
|
|
xml_contents_encoded = custom_codec->toUnicode(feed_contents);
|
|
result.first->setEncoding(xml_schema_encoding);
|
|
}
|
|
else {
|
|
// Feed encoding probably not guessed, set it as
|
|
// default.
|
|
xml_contents_encoded = feed_contents;
|
|
result.first->setEncoding(DEFAULT_FEED_ENCODING);
|
|
}
|
|
|
|
// Feed XML was obtained, guess it now.
|
|
QDomDocument xml_document;
|
|
QString error_msg;
|
|
int error_line, error_column;
|
|
|
|
if (!xml_document.setContent(xml_contents_encoded,
|
|
&error_msg,
|
|
&error_line,
|
|
&error_column)) {
|
|
qDebug("XML of feed '%s' is not valid and cannot be loaded. Error: '%s' "
|
|
"(line %d, column %d).",
|
|
qPrintable(url),
|
|
qPrintable(error_msg),
|
|
error_line, error_column);
|
|
|
|
result.second = QNetworkReply::UnknownContentError;
|
|
|
|
// XML is invalid, exit.
|
|
return result;
|
|
}
|
|
|
|
QDomElement root_element = xml_document.documentElement();
|
|
QString root_tag_name = root_element.tagName();
|
|
QList<QString> icon_possible_locations;
|
|
|
|
icon_possible_locations.append(url);
|
|
|
|
if (root_tag_name == QL1S("rdf:RDF")) {
|
|
// We found RDF feed.
|
|
QDomElement channel_element = root_element.namedItem(QSL("channel")).toElement();
|
|
|
|
result.first->setType(Rdf);
|
|
result.first->setTitle(channel_element.namedItem(QSL("title")).toElement().text());
|
|
result.first->setDescription(channel_element.namedItem(QSL("description")).toElement().text());
|
|
|
|
QString source_link = channel_element.namedItem(QSL("link")).toElement().text();
|
|
|
|
if (!source_link.isEmpty()) {
|
|
icon_possible_locations.prepend(source_link);
|
|
}
|
|
}
|
|
else if (root_tag_name == QL1S("rss")) {
|
|
// We found RSS 0.91/0.92/0.93/2.0/2.0.1 feed.
|
|
QString rss_type = root_element.attribute("version", "2.0");
|
|
|
|
if (rss_type == QL1S("0.91") || rss_type == QL1S("0.92") || rss_type == QL1S("0.93")) {
|
|
result.first->setType(Rss0X);
|
|
}
|
|
else {
|
|
result.first->setType(Rss2X);
|
|
}
|
|
|
|
QDomElement channel_element = root_element.namedItem(QSL("channel")).toElement();
|
|
|
|
result.first->setTitle(channel_element.namedItem(QSL("title")).toElement().text());
|
|
result.first->setDescription(channel_element.namedItem(QSL("description")).toElement().text());
|
|
|
|
QString source_link = channel_element.namedItem(QSL("link")).toElement().text();
|
|
|
|
if (!source_link.isEmpty()) {
|
|
icon_possible_locations.prepend(source_link);
|
|
}
|
|
}
|
|
else if (root_tag_name == QL1S("feed")) {
|
|
// We found ATOM feed.
|
|
result.first->setType(Atom10);
|
|
result.first->setTitle(root_element.namedItem(QSL("title")).toElement().text());
|
|
result.first->setDescription(root_element.namedItem(QSL("subtitle")).toElement().text());
|
|
|
|
QString source_link = root_element.namedItem(QSL("link")).toElement().text();
|
|
|
|
if (!source_link.isEmpty()) {
|
|
icon_possible_locations.prepend(source_link);
|
|
}
|
|
}
|
|
else {
|
|
// File was downloaded and it really was XML file
|
|
// but feed format was NOT recognized.
|
|
result.second = QNetworkReply::UnknownContentError;
|
|
}
|
|
|
|
// Try to obtain icon.
|
|
QIcon icon_data;
|
|
|
|
if ((result.second = NetworkFactory::downloadIcon(icon_possible_locations,
|
|
DOWNLOAD_TIMEOUT,
|
|
icon_data)) == QNetworkReply::NoError) {
|
|
// Icon for feed was downloaded and is stored now in _icon_data.
|
|
result.first->setIcon(icon_data);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
QVariant Feed::data(int column, int role) const {
|
|
switch (role) {
|
|
case Qt::DisplayRole:
|
|
if (column == FDS_MODEL_TITLE_INDEX) {
|
|
return m_title;
|
|
}
|
|
else if (column == FDS_MODEL_COUNTS_INDEX) {
|
|
return qApp->settings()->value(GROUP(Feeds), SETTING(Feeds::CountFormat)).toString()
|
|
.replace(PLACEHOLDER_UNREAD_COUNTS, QString::number(countOfUnreadMessages()))
|
|
.replace(PLACEHOLDER_ALL_COUNTS, QString::number(countOfAllMessages()));
|
|
}
|
|
else {
|
|
return QVariant();
|
|
}
|
|
|
|
case Qt::EditRole:
|
|
if (column == FDS_MODEL_TITLE_INDEX) {
|
|
return m_title;
|
|
}
|
|
else if (column == FDS_MODEL_COUNTS_INDEX) {
|
|
return countOfUnreadMessages();
|
|
}
|
|
else {
|
|
return QVariant();
|
|
}
|
|
|
|
case Qt::DecorationRole:
|
|
if (column == FDS_MODEL_TITLE_INDEX) {
|
|
return m_icon;
|
|
}
|
|
else {
|
|
return QVariant();
|
|
}
|
|
|
|
case Qt::ToolTipRole:
|
|
if (column == FDS_MODEL_TITLE_INDEX) {
|
|
QString auto_update_string;
|
|
|
|
switch (m_autoUpdateType) {
|
|
case DontAutoUpdate:
|
|
//: Describes feed auto-update status.
|
|
auto_update_string = tr("does not use auto-update");
|
|
break;
|
|
|
|
case DefaultAutoUpdate:
|
|
//: Describes feed auto-update status.
|
|
auto_update_string = tr("uses global settings");
|
|
break;
|
|
|
|
case SpecificAutoUpdate:
|
|
default:
|
|
//: Describes feed auto-update status.
|
|
auto_update_string = tr("uses specific settings "
|
|
"(%n minute(s) to next auto-update)",
|
|
0,
|
|
m_autoUpdateRemainingInterval);
|
|
break;
|
|
}
|
|
|
|
//: Tooltip for feed.
|
|
return tr("%1 (%2)"
|
|
"%3\n\n"
|
|
"Network status: %6\n"
|
|
"Encoding: %4\n"
|
|
"Auto-update status: %5").arg(m_title,
|
|
Feed::typeToString(m_type),
|
|
m_description.isEmpty() ? QString() : QString('\n') + m_description,
|
|
m_encoding,
|
|
auto_update_string,
|
|
NetworkFactory::networkErrorText(m_networkError));
|
|
}
|
|
else if (column == FDS_MODEL_COUNTS_INDEX) {
|
|
//: Tooltip for "unread" column of feed list.
|
|
return tr("%n unread message(s).", 0, countOfUnreadMessages());
|
|
}
|
|
else {
|
|
return QVariant();
|
|
}
|
|
|
|
case Qt::TextAlignmentRole:
|
|
if (column == FDS_MODEL_COUNTS_INDEX) {
|
|
return Qt::AlignCenter;
|
|
}
|
|
else {
|
|
return QVariant();
|
|
}
|
|
|
|
case Qt::FontRole:
|
|
return countOfUnreadMessages() > 0 ? m_boldFont : m_normalFont;
|
|
|
|
case Qt::ForegroundRole:
|
|
switch (m_status) {
|
|
case NewMessages:
|
|
return QColor(Qt::blue);
|
|
|
|
case NetworkError:
|
|
return QColor(Qt::red);
|
|
|
|
default:
|
|
return QVariant();
|
|
}
|
|
|
|
default:
|
|
return QVariant();
|
|
}
|
|
}
|
|
|
|
int Feed::update() {
|
|
QByteArray feed_contents;
|
|
int download_timeout = qApp->settings()->value(GROUP(Feeds), SETTING(Feeds::UpdateTimeout)).toInt();
|
|
m_networkError = NetworkFactory::downloadFeedFile(url(), download_timeout, feed_contents,
|
|
passwordProtected(), username(), password()).first;
|
|
|
|
if (m_networkError != QNetworkReply::NoError) {
|
|
qWarning("Error during fetching of new messages for feed '%s' (id %d).", qPrintable(url()), id());
|
|
m_status = NetworkError;
|
|
return 0;
|
|
}
|
|
else {
|
|
m_status = Normal;
|
|
}
|
|
|
|
// Encode downloaded data for further parsing.
|
|
QTextCodec *codec = QTextCodec::codecForName(encoding().toLocal8Bit());
|
|
QString formatted_feed_contents;
|
|
|
|
if (codec == NULL) {
|
|
// No suitable codec for this encoding was found.
|
|
// Use non-converted data.
|
|
formatted_feed_contents = feed_contents;
|
|
}
|
|
else {
|
|
formatted_feed_contents = codec->toUnicode(feed_contents);
|
|
}
|
|
|
|
// Feed data are downloaded and encoded.
|
|
// Parse data and obtain messages.
|
|
QList<Message> messages;
|
|
|
|
switch (type()) {
|
|
case Feed::Rss0X:
|
|
case Feed::Rss2X:
|
|
messages = ParsingFactory::parseAsRSS20(formatted_feed_contents);
|
|
break;
|
|
|
|
case Feed::Rdf:
|
|
messages = ParsingFactory::parseAsRDF(formatted_feed_contents);
|
|
break;
|
|
|
|
case Feed::Atom10:
|
|
messages = ParsingFactory::parseAsATOM10(formatted_feed_contents);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return updateMessages(messages);
|
|
}
|
|
|
|
bool Feed::removeItself() {
|
|
QSqlDatabase database = qApp->database()->connection(QSL("Feed"), DatabaseFactory::FromSettings);
|
|
QSqlQuery query_remove(database);
|
|
|
|
query_remove.setForwardOnly(true);
|
|
|
|
// Remove all messages from this standard feed.
|
|
query_remove.prepare(QSL("DELETE FROM Messages WHERE feed = :feed;"));
|
|
query_remove.bindValue(QSL(":feed"), id());
|
|
|
|
if (!query_remove.exec()) {
|
|
return false;
|
|
}
|
|
|
|
// Remove feed itself.
|
|
query_remove.prepare(QSL("DELETE FROM Feeds WHERE id = :feed;"));
|
|
query_remove.bindValue(QSL(":feed"), id());
|
|
|
|
return query_remove.exec();
|
|
}
|
|
|
|
bool Feed::addItself(RootItem *parent) {
|
|
// Now, add feed to persistent storage.
|
|
QSqlDatabase database = qApp->database()->connection(QSL("Feed"), DatabaseFactory::FromSettings);
|
|
QSqlQuery query_add_feed(database);
|
|
|
|
query_add_feed.setForwardOnly(true);
|
|
query_add_feed.prepare("INSERT INTO Feeds "
|
|
"(title, description, date_created, icon, category, encoding, url, protected, username, password, update_type, update_interval, type) "
|
|
"VALUES (:title, :description, :date_created, :icon, :category, :encoding, :url, :protected, :username, :password, :update_type, :update_interval, :type);");
|
|
query_add_feed.bindValue(QSL(":title"), title());
|
|
query_add_feed.bindValue(QSL(":description"), description());
|
|
query_add_feed.bindValue(QSL(":date_created"), creationDate().toMSecsSinceEpoch());
|
|
query_add_feed.bindValue(QSL(":icon"), qApp->icons()->toByteArray(icon()));
|
|
query_add_feed.bindValue(QSL(":category"), parent->id());
|
|
query_add_feed.bindValue(QSL(":encoding"), encoding());
|
|
query_add_feed.bindValue(QSL(":url"), url());
|
|
query_add_feed.bindValue(QSL(":protected"), (int) passwordProtected());
|
|
query_add_feed.bindValue(QSL(":username"), username());
|
|
query_add_feed.bindValue(QSL(":password"), TextFactory::encrypt(password()));
|
|
query_add_feed.bindValue(QSL(":update_type"), (int) autoUpdateType());
|
|
query_add_feed.bindValue(QSL(":update_interval"), autoUpdateInitialInterval());
|
|
query_add_feed.bindValue(QSL(":type"), (int) type());
|
|
|
|
if (!query_add_feed.exec()) {
|
|
qDebug("Failed to add feed to database: %s.", qPrintable(query_add_feed.lastError().text()));
|
|
|
|
// Query failed.
|
|
return false;
|
|
}
|
|
|
|
query_add_feed.prepare(QSL("SELECT id FROM Feeds WHERE url = :url;"));
|
|
query_add_feed.bindValue(QSL(":url"), url());
|
|
if (query_add_feed.exec() && query_add_feed.next()) {
|
|
// New feed was added, fetch is primary id from the database.
|
|
setId(query_add_feed.value(0).toInt());
|
|
}
|
|
else {
|
|
// Something failed.
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Feed::editItself(Feed *new_feed_data) {
|
|
QSqlDatabase database = qApp->database()->connection(QSL("Feed"), DatabaseFactory::FromSettings);
|
|
QSqlQuery query_update_feed(database);
|
|
Feed *original_feed = this;
|
|
RootItem *new_parent = new_feed_data->parent();
|
|
|
|
query_update_feed.setForwardOnly(true);
|
|
query_update_feed.prepare("UPDATE Feeds "
|
|
"SET title = :title, description = :description, icon = :icon, category = :category, encoding = :encoding, url = :url, protected = :protected, username = :username, password = :password, update_type = :update_type, update_interval = :update_interval, type = :type "
|
|
"WHERE id = :id;");
|
|
query_update_feed.bindValue(QSL(":title"), new_feed_data->title());
|
|
query_update_feed.bindValue(QSL(":description"), new_feed_data->description());
|
|
query_update_feed.bindValue(QSL(":icon"), qApp->icons()->toByteArray(new_feed_data->icon()));
|
|
query_update_feed.bindValue(QSL(":category"), new_parent->id());
|
|
query_update_feed.bindValue(QSL(":encoding"), new_feed_data->encoding());
|
|
query_update_feed.bindValue(QSL(":url"), new_feed_data->url());
|
|
query_update_feed.bindValue(QSL(":protected"), (int) new_feed_data->passwordProtected());
|
|
query_update_feed.bindValue(QSL(":username"), new_feed_data->username());
|
|
query_update_feed.bindValue(QSL(":password"), TextFactory::encrypt(new_feed_data->password()));
|
|
query_update_feed.bindValue(QSL(":update_type"), (int) new_feed_data->autoUpdateType());
|
|
query_update_feed.bindValue(QSL(":update_interval"), new_feed_data->autoUpdateInitialInterval());
|
|
query_update_feed.bindValue(QSL(":type"), new_feed_data->type());
|
|
query_update_feed.bindValue(QSL(":id"), original_feed->id());
|
|
|
|
if (!query_update_feed.exec()) {
|
|
// Persistent storage update failed, no way to continue now.
|
|
return false;
|
|
}
|
|
|
|
// Setup new model data for the original item.
|
|
original_feed->setTitle(new_feed_data->title());
|
|
original_feed->setDescription(new_feed_data->description());
|
|
original_feed->setIcon(new_feed_data->icon());
|
|
original_feed->setEncoding(new_feed_data->encoding());
|
|
original_feed->setDescription(new_feed_data->description());
|
|
original_feed->setUrl(new_feed_data->url());
|
|
original_feed->setPasswordProtected(new_feed_data->passwordProtected());
|
|
original_feed->setUsername(new_feed_data->username());
|
|
original_feed->setPassword(new_feed_data->password());
|
|
original_feed->setAutoUpdateType(new_feed_data->autoUpdateType());
|
|
original_feed->setAutoUpdateInitialInterval(new_feed_data->autoUpdateInitialInterval());
|
|
original_feed->setType(new_feed_data->type());
|
|
|
|
// Editing is done.
|
|
return true;
|
|
}
|
|
|
|
int Feed::updateMessages(const QList<Message> &messages) {
|
|
int feed_id = id();
|
|
int updated_messages = 0;
|
|
QSqlDatabase database = qApp->database()->connection(QSL("Feed"), DatabaseFactory::FromSettings);
|
|
bool remove_duplicates = qApp->settings()->value(GROUP(Messages), SETTING(Messages::RemoveDuplicates)).toBool();
|
|
|
|
// Prepare queries.
|
|
QSqlQuery query_select(database);
|
|
QSqlQuery query_update(database);
|
|
QSqlQuery query_insert(database);
|
|
|
|
// Used to check if given feed contains any message with given title, url and date_created.
|
|
// WARNING: One feed CANNOT contain two (or more) messages with same AUTHOR AND TITLE AND URL AND DATE_CREATED.
|
|
query_select.setForwardOnly(true);
|
|
query_select.prepare("SELECT id, feed, date_created FROM Messages "
|
|
"WHERE feed = :feed AND title = :title AND url = :url AND author = :author;");
|
|
|
|
// Used to insert new messages.
|
|
query_insert.setForwardOnly(true);
|
|
query_insert.prepare("INSERT INTO Messages "
|
|
"(feed, title, url, author, date_created, contents, enclosures) "
|
|
"VALUES (:feed, :title, :url, :author, :date_created, :contents, :enclosures);");
|
|
|
|
if (remove_duplicates) {
|
|
query_update.setForwardOnly(true);
|
|
query_update.prepare(QSL("UPDATE Messages SET contents = :contents enclosures = :enclosures WHERE id = :id;"));
|
|
}
|
|
|
|
if (!database.transaction()) {
|
|
database.rollback();
|
|
qDebug("Transaction start for message downloader failed.");
|
|
return updated_messages;
|
|
}
|
|
|
|
foreach (Message message, messages) {
|
|
// Check if messages contain relative URLs and if they do, then replace them.
|
|
if (message.m_url.startsWith(QL1S("/"))) {
|
|
QString new_message_url = url();
|
|
int last_slash = new_message_url.lastIndexOf(QL1S("/"));
|
|
|
|
if (last_slash >= 0) {
|
|
new_message_url = new_message_url.left(last_slash);
|
|
}
|
|
|
|
new_message_url += message.m_url;
|
|
message.m_url = new_message_url;
|
|
}
|
|
|
|
query_select.bindValue(QSL(":feed"), feed_id);
|
|
query_select.bindValue(QSL(":title"), message.m_title);
|
|
query_select.bindValue(QSL(":url"), message.m_url);
|
|
query_select.bindValue(QSL(":author"), message.m_author);
|
|
query_select.exec();
|
|
|
|
QList<qint64> datetime_stamps;
|
|
QList<int> ids;
|
|
|
|
while (query_select.next()) {
|
|
ids << query_select.value(0).toInt();
|
|
datetime_stamps << query_select.value(2).value<qint64>();
|
|
}
|
|
|
|
query_select.finish();
|
|
|
|
if (datetime_stamps.isEmpty()) {
|
|
// Message is not fetched in this feed yet.
|
|
query_insert.bindValue(QSL(":feed"), feed_id);
|
|
query_insert.bindValue(QSL(":title"), message.m_title);
|
|
query_insert.bindValue(QSL(":url"), message.m_url);
|
|
query_insert.bindValue(QSL(":author"), message.m_author);
|
|
query_insert.bindValue(QSL(":date_created"), message.m_created.toMSecsSinceEpoch());
|
|
query_insert.bindValue(QSL(":contents"), message.m_contents);
|
|
query_insert.bindValue(QSL(":enclosures"), Enclosures::encodeEnclosuresToString(message.m_enclosures));
|
|
|
|
if (query_insert.exec() && query_insert.numRowsAffected() == 1) {
|
|
setStatus(NewMessages);
|
|
updated_messages++;
|
|
}
|
|
|
|
query_insert.finish();
|
|
|
|
qDebug("Adding new message '%s' to DB.", qPrintable(message.m_title));
|
|
}
|
|
else if (message.m_createdFromFeed && !datetime_stamps.contains(message.m_created.toMSecsSinceEpoch())) {
|
|
if (remove_duplicates && datetime_stamps.size() == 1) {
|
|
// Message is already in feed and new message has new unique time but user wishes to update existing
|
|
// messages and there is exactly ONE existing duplicate.
|
|
query_update.bindValue(QSL(":id"), ids.at(0));
|
|
query_update.bindValue(QSL(":contents"), message.m_contents);
|
|
query_update.bindValue(QSL(":enclosures"), Enclosures::encodeEnclosuresToString(message.m_enclosures));
|
|
query_update.exec();
|
|
query_update.finish();
|
|
|
|
qDebug("Updating contents of duplicate message '%s'.", qPrintable(message.m_title));
|
|
}
|
|
else {
|
|
// Message with same title, author and url exists, but new message has new unique time and
|
|
// user does not wish to update duplicates.
|
|
query_insert.bindValue(QSL(":feed"), feed_id);
|
|
query_insert.bindValue(QSL(":title"), message.m_title);
|
|
query_insert.bindValue(QSL(":url"), message.m_url);
|
|
query_insert.bindValue(QSL(":author"), message.m_author);
|
|
query_insert.bindValue(QSL(":date_created"), message.m_created.toMSecsSinceEpoch());
|
|
query_insert.bindValue(QSL(":contents"), message.m_contents);
|
|
query_insert.bindValue(QSL(":enclosures"), Enclosures::encodeEnclosuresToString(message.m_enclosures));
|
|
|
|
if (query_insert.exec() && query_insert.numRowsAffected() == 1) {
|
|
setStatus(NewMessages);
|
|
updated_messages++;
|
|
}
|
|
|
|
query_insert.finish();
|
|
|
|
qDebug("Adding new duplicate (with potentially updated contents) message '%s' to DB.", qPrintable(message.m_title));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!database.commit()) {
|
|
database.rollback();
|
|
|
|
qDebug("Transaction commit for message downloader failed.");
|
|
}
|
|
|
|
return updated_messages;
|
|
}
|
|
|
|
QNetworkReply::NetworkError Feed::networkError() const {
|
|
return m_networkError;
|
|
}
|
|
|
|
Feed::Feed(const QSqlRecord &record) : RootItem(NULL) {
|
|
m_kind = RootItem::Feeed;
|
|
|
|
setTitle(record.value(FDS_DB_TITLE_INDEX).toString());
|
|
setId(record.value(FDS_DB_ID_INDEX).toInt());
|
|
setDescription(record.value(FDS_DB_DESCRIPTION_INDEX).toString());
|
|
setCreationDate(TextFactory::parseDateTime(record.value(FDS_DB_DCREATED_INDEX).value<qint64>()).toLocalTime());
|
|
setIcon(qApp->icons()->fromByteArray(record.value(FDS_DB_ICON_INDEX).toByteArray()));
|
|
setEncoding(record.value(FDS_DB_ENCODING_INDEX).toString());
|
|
setUrl(record.value(FDS_DB_URL_INDEX).toString());
|
|
setPasswordProtected(record.value(FDS_DB_PROTECTED_INDEX).toBool());
|
|
setUsername(record.value(FDS_DB_USERNAME_INDEX).toString());
|
|
setPassword(TextFactory::decrypt(record.value(FDS_DB_PASSWORD_INDEX).toString()));
|
|
setAutoUpdateType(static_cast<Feed::AutoUpdateType>(record.value(FDS_DB_UPDATE_TYPE_INDEX).toInt()));
|
|
setAutoUpdateInitialInterval(record.value(FDS_DB_UPDATE_INTERVAL_INDEX).toInt());
|
|
updateCounts();
|
|
}
|