RSS::Session Class Reference

#include <rss_session.h>

Inheritance diagram for RSS::Session:

Collaboration diagram for RSS::Session:

Public Slots
void	refresh ()

Signals
void	processingStateChanged (bool enabled)
void	maxArticlesPerFeedChanged (int n)
void	itemAdded (Item *item)
void	itemPathChanged (Item *item)
void	itemAboutToBeRemoved (Item *item)
void	feedIconLoaded (Feed *feed)
void	feedStateChanged (Feed *feed)

Public Member Functions
bool	isProcessingEnabled () const
void	setProcessingEnabled (bool enabled)
QThread *	workingThread () const
AsyncFileStorage *	confFileStorage () const
AsyncFileStorage *	dataFileStorage () const
int	maxArticlesPerFeed () const
void	setMaxArticlesPerFeed (int n)
int	refreshInterval () const
void	setRefreshInterval (int refreshInterval)
nonstd::expected< void, QString >	addFolder (const QString &path)
nonstd::expected< void, QString >	addFeed (const QString &url, const QString &path)
nonstd::expected< void, QString >	moveItem (const QString &itemPath, const QString &destPath)
nonstd::expected< void, QString >	moveItem (Item *item, const QString &destPath)
nonstd::expected< void, QString >	removeItem (const QString &itemPath)
QList< Item * >	items () const
Item *	itemByPath (const QString &path) const
QList< Feed * >	feeds () const
Feed *	feedByURL (const QString &url) const
Folder *	rootFolder () const

Static Public Member Functions
static Session *	instance ()

Private Slots
void	handleItemAboutToBeDestroyed (Item *item)
void	handleFeedTitleChanged (Feed *feed)

Private Member Functions
	Session ()
	~Session () override
QUuid	generateUID () const
void	load ()
void	loadFolder (const QJsonObject &jsonObj, Folder *folder)
void	loadLegacy ()
void	store ()
nonstd::expected< Folder *, QString >	prepareItemDest (const QString &path)
Folder *	addSubfolder (const QString &name, Folder *parentFolder)
Feed *	addFeedToFolder (const QUuid &uid, const QString &url, const QString &name, Folder *parentFolder)
void	addItem (Item *item, Folder *destFolder)

Private Attributes
CachedSettingValue< bool >	m_storeProcessingEnabled
CachedSettingValue< int >	m_storeRefreshInterval
CachedSettingValue< int >	m_storeMaxArticlesPerFeed
QThread *	m_workingThread
AsyncFileStorage *	m_confFileStorage
AsyncFileStorage *	m_dataFileStorage
QTimer	m_refreshTimer
QHash< QString, Item * >	m_itemsByPath
QHash< QUuid, Feed * >	m_feedsByUID
QHash< QString, Feed * >	m_feedsByURL

Static Private Attributes
static QPointer< Session >	m_instance = nullptr

Friends
class	::Application

Detailed Description

Definition at line 90 of file rss_session.h.

Constructor & Destructor Documentation

Session()

Session::Session ( )

private

Definition at line 60 of file rss_session.cpp.

    : m_storeProcessingEnabled("RSS/Session/EnableProcessing")
    , m_storeRefreshInterval("RSS/Session/RefreshInterval", 30)
    , m_storeMaxArticlesPerFeed("RSS/Session/MaxArticlesPerFeed", 50)
    , m_workingThread(new QThread(this))
{
    Q_ASSERT(!m_instance); // only one instance is allowed
    m_instance = this;
 
    m_confFileStorage = new AsyncFileStorage(
                Utils::Fs::expandPathAbs(specialFolderLocation(SpecialFolder::Config) + QLatin1Char('/') + ConfFolderName));
    m_confFileStorage->moveToThread(m_workingThread);
    connect(m_workingThread, &QThread::finished, m_confFileStorage, &AsyncFileStorage::deleteLater);
    connect(m_confFileStorage, &AsyncFileStorage::failed, [](const QString &fileName, const QString &errorString)
    {
        Logger::instance()->addMessage(QString("Couldn't save RSS Session configuration in %1. Error: %2")
                                       .arg(fileName, errorString), Log::WARNING);
    });
 
    m_dataFileStorage = new AsyncFileStorage(
                Utils::Fs::expandPathAbs(specialFolderLocation(SpecialFolder::Data) + QLatin1Char('/') + DataFolderName));
    m_dataFileStorage->moveToThread(m_workingThread);
    connect(m_workingThread, &QThread::finished, m_dataFileStorage, &AsyncFileStorage::deleteLater);
    connect(m_dataFileStorage, &AsyncFileStorage::failed, [](const QString &fileName, const QString &errorString)
    {
        Logger::instance()->addMessage(QString("Couldn't save RSS Session data in %1. Error: %2")
                                       .arg(fileName, errorString), Log::WARNING);
    });
 
    m_itemsByPath.insert("", new Folder); // root folder
 
    m_workingThread->start();
    load();
 
    connect(&m_refreshTimer, &QTimer::timeout, this, &Session::refresh);
    if (isProcessingEnabled())
    {
        m_refreshTimer.start(refreshInterval() * MsecsPerMin);
        refresh();
    }
 
    // Remove legacy/corrupted settings
    // (at least on Windows, QSettings is case-insensitive and it can get
    // confused when asked about settings that differ only in their case)
    auto settingsStorage = SettingsStorage::instance();
    settingsStorage->removeValue("Rss/streamList");
    settingsStorage->removeValue("Rss/streamAlias");
    settingsStorage->removeValue("Rss/open_folders");
    settingsStorage->removeValue("Rss/qt5/splitter_h");
    settingsStorage->removeValue("Rss/qt5/splitterMain");
    settingsStorage->removeValue("Rss/hosts_cookies");
    settingsStorage->removeValue("RSS/streamList");
    settingsStorage->removeValue("RSS/streamAlias");
    settingsStorage->removeValue("RSS/open_folders");
    settingsStorage->removeValue("RSS/qt5/splitter_h");
    settingsStorage->removeValue("RSS/qt5/splitterMain");
    settingsStorage->removeValue("RSS/hosts_cookies");
    settingsStorage->removeValue("Rss/Session/EnableProcessing");
    settingsStorage->removeValue("Rss/Session/RefreshInterval");
    settingsStorage->removeValue("Rss/Session/MaxArticlesPerFeed");
    settingsStorage->removeValue("Rss/AutoDownloader/EnableProcessing");
}

References Logger::addMessage(), ConfFolderName(), Config, Data, DataFolderName(), Utils::Fs::expandPathAbs(), AsyncFileStorage::failed(), Utils::Fs::fileName(), Logger::instance(), SettingsStorage::instance(), isProcessingEnabled(), load(), m_confFileStorage, m_dataFileStorage, m_instance, m_itemsByPath, m_refreshTimer, m_workingThread, MsecsPerMin, refresh(), refreshInterval(), specialFolderLocation(), and Log::WARNING.

Here is the call graph for this function:

~Session()

Session::~Session ( )

overrideprivate

Definition at line 123 of file rss_session.cpp.

{
    qDebug() << "Deleting RSS Session...";
 
    m_workingThread->quit();
    m_workingThread->wait();
 
    //store();
    delete m_itemsByPath[""]; // deleting root folder
 
    qDebug() << "RSS Session deleted.";
}

References m_itemsByPath, and m_workingThread.

Member Function Documentation

addFeed()

nonstd::expected< void, QString > Session::addFeed	(	const QString &	url,
		const QString &	path
	)

Definition at line 153 of file rss_session.cpp.

{
    if (m_feedsByURL.contains(url))
        return nonstd::make_unexpected(tr("RSS feed with given URL already exists: %1.").arg(url));
 
    const nonstd::expected<Folder *, QString> result = prepareItemDest(path);
    if (!result)
        return result.get_unexpected();
 
    const auto destFolder = result.value();
    addItem(new Feed(generateUID(), url, path, this), destFolder);
    store();
    if (isProcessingEnabled())
        feedByURL(url)->refresh();
 
    return {};
}

References addItem(), feedByURL(), generateUID(), isProcessingEnabled(), m_feedsByURL, prepareItemDest(), RSS::Feed::refresh(), and store().

Referenced by RSSController::addFeedAction(), loadLegacy(), and RSSWidget::on_newFeedButton_clicked().

Here is the call graph for this function:

Here is the caller graph for this function:

addFeedToFolder()

Feed * Session::addFeedToFolder ( const QUuid &  uid, const QString &  url, const QString &  name, Folder *  parentFolder  )

private

Definition at line 401 of file rss_session.cpp.

{
    auto feed = new Feed(uid, url, Item::joinPath(parentFolder->path(), name), this);
    addItem(feed, parentFolder);
    return feed;
}

References addItem(), RSS::Item::joinPath(), and RSS::Item::path().

Referenced by loadFolder().

Here is the call graph for this function:

Here is the caller graph for this function:

addFolder()

nonstd::expected< void, QString > Session::addFolder

(

const QString &

path

)

Definition at line 141 of file rss_session.cpp.

{
    const nonstd::expected<Folder *, QString> result = prepareItemDest(path);
    if (!result)
        return result.get_unexpected();
 
    const auto destFolder = result.value();
    addItem(new Folder(path), destFolder);
    store();
    return {};
}

References addItem(), prepareItemDest(), and store().

Referenced by RSSController::addFolderAction(), RSSWidget::askNewFolder(), and loadLegacy().

Here is the call graph for this function:

Here is the caller graph for this function:

addItem()

void Session::addItem ( Item *  item, Folder *  destFolder  )

private

Definition at line 408 of file rss_session.cpp.

{
    if (auto feed = qobject_cast<Feed *>(item))
    {
        connect(feed, &Feed::titleChanged, this, &Session::handleFeedTitleChanged);
        connect(feed, &Feed::iconLoaded, this, &Session::feedIconLoaded);
        connect(feed, &Feed::stateChanged, this, &Session::feedStateChanged);
        m_feedsByUID[feed->uid()] = feed;
        m_feedsByURL[feed->url()] = feed;
    }
 
    connect(item, &Item::pathChanged, this, &Session::itemPathChanged);
    connect(item, &Item::aboutToBeDestroyed, this, &Session::handleItemAboutToBeDestroyed);
    m_itemsByPath[item->path()] = item;
    destFolder->addItem(item);
    emit itemAdded(item);
}

References RSS::Item::aboutToBeDestroyed(), RSS::Folder::addItem(), feedIconLoaded(), feedStateChanged(), handleFeedTitleChanged(), handleItemAboutToBeDestroyed(), RSS::Feed::iconLoaded(), itemAdded(), itemPathChanged(), m_feedsByUID, m_feedsByURL, m_itemsByPath, RSS::Item::path(), RSS::Item::pathChanged(), RSS::Feed::stateChanged(), and RSS::Feed::titleChanged().

Referenced by addFeed(), addFeedToFolder(), addFolder(), and addSubfolder().

Here is the call graph for this function:

Here is the caller graph for this function:

addSubfolder()

Folder * Session::addSubfolder ( const QString &  name, Folder *  parentFolder  )

private

Definition at line 394 of file rss_session.cpp.

{
    auto folder = new Folder(Item::joinPath(parentFolder->path(), name));
    addItem(folder, parentFolder);
    return folder;
}

References addItem(), RSS::Item::joinPath(), and RSS::Item::path().

Referenced by loadFolder().

Here is the call graph for this function:

Here is the caller graph for this function:

confFileStorage()

AsyncFileStorage * Session::confFileStorage

(

)

const

Definition at line 450 of file rss_session.cpp.

{
    return m_confFileStorage;
}

References m_confFileStorage.

dataFileStorage()

AsyncFileStorage * Session::dataFileStorage

(

)

const

Definition at line 455 of file rss_session.cpp.

{
    return m_dataFileStorage;
}

References m_dataFileStorage.

Referenced by RSS::Feed::cleanup(), RSS::Feed::Feed(), RSS::Feed::load(), and RSS::Feed::store().

Here is the caller graph for this function:

feedByURL()

Feed * Session::feedByURL

(

const QString &

url

)

const

Definition at line 470 of file rss_session.cpp.

{
    return m_feedsByURL.value(url);
}

References m_feedsByURL.

Referenced by addFeed(), RSSController::matchingArticlesAction(), and AutomatedRssDownloader::updateMatchingArticles().

Here is the caller graph for this function:

feedIconLoaded

void RSS::Session::feedIconLoaded ( Feed *  feed )

signal

Referenced by addItem(), and FeedListWidget::FeedListWidget().

Here is the caller graph for this function:

feeds()

QList< Feed * > Session::feeds

(

)

const

Definition at line 465 of file rss_session.cpp.

{
    return m_feedsByURL.values();
}

References m_feedsByURL.

feedStateChanged

void RSS::Session::feedStateChanged ( Feed *  feed )

signal

Referenced by addItem(), and FeedListWidget::FeedListWidget().

Here is the caller graph for this function:

generateUID()

QUuid Session::generateUID ( ) const

private

Definition at line 513 of file rss_session.cpp.

{
    QUuid uid = QUuid::createUuid();
    while (m_feedsByUID.contains(uid))
        uid = QUuid::createUuid();
 
    return uid;
}

References m_feedsByUID.

Referenced by addFeed(), and loadFolder().

Here is the caller graph for this function:

handleFeedTitleChanged

void Session::handleFeedTitleChanged ( Feed *  feed )

privateslot

Definition at line 505 of file rss_session.cpp.

{
    if (feed->name() == feed->url())
        // Now we have something better than a URL.
        // Trying to rename feed...
        moveItem(feed, Item::joinPath(Item::parentPath(feed->path()), feed->title()));
}

References RSS::Item::joinPath(), moveItem(), RSS::Item::name(), RSS::Item::parentPath(), RSS::Item::path(), RSS::Feed::title(), and RSS::Feed::url().

Referenced by addItem().

Here is the call graph for this function:

Here is the caller graph for this function:

handleItemAboutToBeDestroyed

void Session::handleItemAboutToBeDestroyed ( Item *  item )

privateslot

Definition at line 494 of file rss_session.cpp.

{
    m_itemsByPath.remove(item->path());
    auto feed = qobject_cast<Feed *>(item);
    if (feed)
    {
        m_feedsByUID.remove(feed->uid());
        m_feedsByURL.remove(feed->url());
    }
}

References m_feedsByUID, m_feedsByURL, m_itemsByPath, and RSS::Item::path().

Referenced by addItem().

Here is the call graph for this function:

Here is the caller graph for this function:

instance()

Session * Session::instance ( )

static

Definition at line 136 of file rss_session.cpp.

{
    return m_instance;
}

References m_instance.

Referenced by RSSController::addFeedAction(), RSSController::addFolderAction(), RSSWidget::askNewFolder(), Application::cleanup(), RSSWidget::deleteSelectedItems(), MainWindow::displayRSSTab(), FeedListWidget::dropEvent(), FeedListWidget::FeedListWidget(), FeedListWidget::handleItemAdded(), FeedListWidget::handleItemPathChanged(), FeedListWidget::handleItemUnreadCountChanged(), RSS::AutoDownloader::handleTorrentDownloadFinished(), RSSWidget::handleUnreadCountChanged(), RSSController::itemsAction(), AutomatedRssDownloader::loadFeedList(), OptionsDialog::loadOptions(), RSSController::markAsReadAction(), RSSController::matchingArticlesAction(), RSSController::moveItemAction(), RSSWidget::on_newFeedButton_clicked(), AppController::preferencesAction(), RSS::AutoDownloader::processJob(), RSSWidget::refreshAllFeeds(), RSSController::refreshItemAction(), RSSController::removeItemAction(), RSSWidget::renameSelectedRSSItem(), RSS::AutoDownloader::resetProcessingQueue(), RSSWidget::RSSWidget(), OptionsDialog::saveOptions(), AppController::setPreferencesAction(), RSS::AutoDownloader::setProcessingEnabled(), RSS::AutoDownloader::startProcessing(), AutomatedRssDownloader::updateMatchingArticles(), and RSSWidget::updateRefreshInterval().

Here is the caller graph for this function:

isProcessingEnabled()

bool Session::isProcessingEnabled

(

)

const

Definition at line 426 of file rss_session.cpp.

{
    return m_storeProcessingEnabled;
}

References m_storeProcessingEnabled.

Referenced by addFeed(), RSS::Feed::Feed(), OptionsDialog::loadOptions(), AppController::preferencesAction(), and Session().

Here is the caller graph for this function:

itemAboutToBeRemoved

void RSS::Session::itemAboutToBeRemoved ( Item *  item )

signal

Referenced by FeedListWidget::FeedListWidget(), and removeItem().

Here is the caller graph for this function:

itemAdded

void RSS::Session::itemAdded ( Item *  item )

signal

Referenced by addItem(), and FeedListWidget::FeedListWidget().

Here is the caller graph for this function:

itemByPath()

Item * Session::itemByPath

(

const QString &

path

)

const

Definition at line 229 of file rss_session.cpp.

{
    return m_itemsByPath.value(path);
}

References m_itemsByPath.

Referenced by RSSWidget::askNewFolder(), FeedListWidget::handleItemPathChanged(), RSSController::markAsReadAction(), RSSWidget::on_newFeedButton_clicked(), and RSSController::refreshItemAction().

Here is the caller graph for this function:

itemPathChanged

void RSS::Session::itemPathChanged ( Item *  item )

signal

Referenced by addItem(), and FeedListWidget::FeedListWidget().

Here is the caller graph for this function:

items()

QList< Item * > Session::items

(

)

const

Definition at line 224 of file rss_session.cpp.

{
    return m_itemsByPath.values();
}

References m_itemsByPath.

load()

void Session::load ( )

private

Definition at line 234 of file rss_session.cpp.

{
    QFile itemsFile(m_confFileStorage->storageDir().absoluteFilePath(FeedsFileName));
    if (!itemsFile.exists())
    {
        loadLegacy();
        return;
    }
 
    if (!itemsFile.open(QFile::ReadOnly))
    {
        Logger::instance()->addMessage(
                    QString("Couldn't read RSS Session data from %1. Error: %2")
                    .arg(itemsFile.fileName(), itemsFile.errorString()), Log::WARNING);
        return;
    }
 
    QJsonParseError jsonError;
    const QJsonDocument jsonDoc = QJsonDocument::fromJson(itemsFile.readAll(), &jsonError);
    if (jsonError.error != QJsonParseError::NoError)
    {
        Logger::instance()->addMessage(
                    QString("Couldn't parse RSS Session data from %1. Error: %2")
                    .arg(itemsFile.fileName(), jsonError.errorString()), Log::WARNING);
        return;
    }
 
    if (!jsonDoc.isObject())
    {
        Logger::instance()->addMessage(
                    QString("Couldn't load RSS Session data from %1. Invalid data format.")
                    .arg(itemsFile.fileName()), Log::WARNING);
        return;
    }
 
    loadFolder(jsonDoc.object(), rootFolder());
}

References Logger::addMessage(), FeedsFileName(), Logger::instance(), loadFolder(), loadLegacy(), m_confFileStorage, rootFolder(), AsyncFileStorage::storageDir(), and Log::WARNING.

Referenced by Session().

Here is the call graph for this function:

Here is the caller graph for this function:

loadFolder()

void Session::loadFolder ( const QJsonObject &  jsonObj, Folder *  folder  )

private

Definition at line 272 of file rss_session.cpp.

{
    bool updated = false;
    for (const QString &key : asConst(jsonObj.keys()))
    {
        const QJsonValue val {jsonObj[key]};
        if (val.isString())
        {
            // previous format (reduced form) doesn't contain UID
            QString url = val.toString();
            if (url.isEmpty())
                url = key;
            addFeedToFolder(generateUID(), url, key, folder);
            updated = true;
        }
        else if (val.isObject())
        {
            const QJsonObject valObj {val.toObject()};
            if (valObj.contains("url"))
            {
                if (!valObj["url"].isString())
                {
                    LogMsg(tr("Couldn't load RSS Feed '%1'. URL is required.")
                           .arg(QString("%1\\%2").arg(folder->path(), key)), Log::WARNING);
                    continue;
                }
 
                QUuid uid;
                if (valObj.contains("uid"))
                {
                    uid = QUuid {valObj["uid"].toString()};
                    if (uid.isNull())
                    {
                        LogMsg(tr("Couldn't load RSS Feed '%1'. UID is invalid.")
                               .arg(QString("%1\\%2").arg(folder->path(), key)), Log::WARNING);
                        continue;
                    }
 
                    if (m_feedsByUID.contains(uid))
                    {
                        LogMsg(tr("Duplicate RSS Feed UID: %1. Configuration seems to be corrupted.")
                               .arg(uid.toString()), Log::WARNING);
                        continue;
                    }
                }
                else
                {
                    // previous format doesn't contain UID
                    uid = generateUID();
                    updated = true;
                }
 
                addFeedToFolder(uid, valObj["url"].toString(), key, folder);
            }
            else
            {
                loadFolder(valObj, addSubfolder(key, folder));
            }
        }
        else
        {
            LogMsg(tr("Couldn't load RSS Item '%1'. Invalid data format.")
                   .arg(QString::fromLatin1("%1\\%2").arg(folder->path(), key)), Log::WARNING);
        }
    }
 
    if (updated)
        store(); // convert to updated format
}

References addFeedToFolder(), addSubfolder(), asConst(), generateUID(), LogMsg(), m_feedsByUID, RSS::Item::path(), store(), anonymous_namespace{session.cpp}::toString(), and Log::WARNING.

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

loadLegacy()

void Session::loadLegacy ( )

private

Definition at line 342 of file rss_session.cpp.

{
    const auto legacyFeedPaths = SettingsStorage::instance()->loadValue<QStringList>("Rss/streamList");
    const auto feedAliases = SettingsStorage::instance()->loadValue<QStringList>("Rss/streamAlias");
    if (legacyFeedPaths.size() != feedAliases.size())
    {
        Logger::instance()->addMessage("Corrupted RSS list, not loading it.", Log::WARNING);
        return;
    }
 
    uint i = 0;
    for (QString legacyPath : legacyFeedPaths)
    {
        if (Item::PathSeparator == QString(legacyPath[0]))
            legacyPath.remove(0, 1);
        const QString parentFolderPath = Item::parentPath(legacyPath);
        const QString feedUrl = Item::relativeName(legacyPath);
 
        for (const QString &folderPath : asConst(Item::expandPath(parentFolderPath)))
            addFolder(folderPath);
 
        const QString feedPath = feedAliases[i].isEmpty()
                ? legacyPath
                : Item::joinPath(parentFolderPath, feedAliases[i]);
        addFeed(feedUrl, feedPath);
        ++i;
    }
 
    store(); // convert to new format
}

References addFeed(), addFolder(), Logger::addMessage(), asConst(), RSS::Item::expandPath(), Logger::instance(), SettingsStorage::instance(), RSS::Item::joinPath(), SettingsStorage::loadValue(), RSS::Item::parentPath(), RSS::Item::PathSeparator, RSS::Item::relativeName(), store(), and Log::WARNING.

Referenced by load().

Here is the call graph for this function:

Here is the caller graph for this function:

maxArticlesPerFeed()

int Session::maxArticlesPerFeed

(

)

const

Definition at line 522 of file rss_session.cpp.

{
    return m_storeMaxArticlesPerFeed;
}

References m_storeMaxArticlesPerFeed.

Referenced by RSS::Feed::addArticle(), OptionsDialog::loadOptions(), AppController::preferencesAction(), and RSS::Feed::updateArticles().

Here is the caller graph for this function:

maxArticlesPerFeedChanged

void RSS::Session::maxArticlesPerFeedChanged ( int  n )

signal

Referenced by RSS::Feed::Feed(), and setMaxArticlesPerFeed().

Here is the caller graph for this function:

moveItem() [1/2]

nonstd::expected< void, QString > Session::moveItem	(	const QString &	itemPath,
		const QString &	destPath
	)

Definition at line 171 of file rss_session.cpp.

{
    if (itemPath.isEmpty())
        return nonstd::make_unexpected(tr("Cannot move root folder."));
 
    auto item = m_itemsByPath.value(itemPath);
    if (!item)
        return nonstd::make_unexpected(tr("Item doesn't exist: %1.").arg(itemPath));
 
    return moveItem(item, destPath);
}

References m_itemsByPath.

Referenced by FeedListWidget::dropEvent(), handleFeedTitleChanged(), RSSController::moveItemAction(), and RSSWidget::renameSelectedRSSItem().

Here is the caller graph for this function:

moveItem() [2/2]

nonstd::expected< void, QString > Session::moveItem	(	Item *	item,
		const QString &	destPath
	)

Definition at line 183 of file rss_session.cpp.

{
    Q_ASSERT(item);
    Q_ASSERT(item != rootFolder());
 
    const nonstd::expected<Folder *, QString> result = prepareItemDest(destPath);
    if (!result)
        return result.get_unexpected();
 
    auto srcFolder = static_cast<Folder *>(m_itemsByPath.value(Item::parentPath(item->path())));
    const auto destFolder = result.value();
    if (srcFolder != destFolder)
    {
        srcFolder->removeItem(item);
        destFolder->addItem(item);
    }
    m_itemsByPath.insert(destPath, m_itemsByPath.take(item->path()));
    item->setPath(destPath);
    store();
    return {};
}

References m_itemsByPath, RSS::Item::parentPath(), RSS::Item::path(), prepareItemDest(), RSS::Folder::removeItem(), rootFolder(), RSS::Item::setPath(), and store().

Here is the call graph for this function:

prepareItemDest()

nonstd::expected< Folder *, QString > Session::prepareItemDest ( const QString &  path )

private

Definition at line 378 of file rss_session.cpp.

{
    if (!Item::isValidPath(path))
        return nonstd::make_unexpected(tr("Incorrect RSS Item path: %1.").arg(path));
 
    if (m_itemsByPath.contains(path))
        return nonstd::make_unexpected(tr("RSS item with given path already exists: %1.").arg(path));
 
    const QString destFolderPath = Item::parentPath(path);
    const auto destFolder = qobject_cast<Folder *>(m_itemsByPath.value(destFolderPath));
    if (!destFolder)
        return nonstd::make_unexpected(tr("Parent folder doesn't exist: %1.").arg(destFolderPath));
 
    return destFolder;
}

References RSS::Item::isValidPath(), m_itemsByPath, and RSS::Item::parentPath().

Referenced by addFeed(), addFolder(), and moveItem().

Here is the call graph for this function:

Here is the caller graph for this function:

processingStateChanged

void RSS::Session::processingStateChanged ( bool  enabled )

signal

Referenced by RSS::Feed::Feed(), RSS::Feed::handleSessionProcessingEnabledChanged(), RSSWidget::RSSWidget(), and setProcessingEnabled().

Here is the caller graph for this function:

refresh

void Session::refresh ( )

slot

Definition at line 536 of file rss_session.cpp.

{
    // NOTE: Should we allow manually refreshing for disabled session?
    rootFolder()->refresh();
}

References RSS::Folder::refresh(), and rootFolder().

Referenced by RSSWidget::refreshAllFeeds(), Session(), and setProcessingEnabled().

Here is the call graph for this function:

Here is the caller graph for this function:

refreshInterval()

int Session::refreshInterval

(

)

const

Definition at line 475 of file rss_session.cpp.

{
    return m_storeRefreshInterval;
}

References m_storeRefreshInterval.

Referenced by OptionsDialog::loadOptions(), AppController::preferencesAction(), Session(), setProcessingEnabled(), and setRefreshInterval().

Here is the caller graph for this function:

removeItem()

nonstd::expected< void, QString > Session::removeItem

(

const QString &

itemPath

)

Definition at line 205 of file rss_session.cpp.

{
    if (itemPath.isEmpty())
        return nonstd::make_unexpected(tr("Cannot delete root folder."));
 
    auto *item = m_itemsByPath.value(itemPath);
    if (!item)
        return nonstd::make_unexpected(tr("Item doesn't exist: %1.").arg(itemPath));
 
    emit itemAboutToBeRemoved(item);
    item->cleanup();
 
    auto folder = static_cast<Folder *>(m_itemsByPath.value(Item::parentPath(item->path())));
    folder->removeItem(item);
    delete item;
    store();
    return {};
}

References itemAboutToBeRemoved(), m_itemsByPath, RSS::Item::parentPath(), RSS::Folder::removeItem(), and store().

Referenced by RSSWidget::deleteSelectedItems(), and RSSController::removeItemAction().

Here is the call graph for this function:

Here is the caller graph for this function:

rootFolder()

Folder * Session::rootFolder

(

)

const

Definition at line 460 of file rss_session.cpp.

{
    return static_cast<Folder *>(m_itemsByPath.value(""));
}

References m_itemsByPath.

Referenced by RSSWidget::askNewFolder(), FeedListWidget::dropEvent(), FeedListWidget::FeedListWidget(), RSSController::itemsAction(), load(), moveItem(), RSSWidget::on_newFeedButton_clicked(), refresh(), and store().

Here is the caller graph for this function:

setMaxArticlesPerFeed()

void Session::setMaxArticlesPerFeed

(

int

n

)

Definition at line 527 of file rss_session.cpp.

{
    if (m_storeMaxArticlesPerFeed != n)
    {
        m_storeMaxArticlesPerFeed = n;
        emit maxArticlesPerFeedChanged(n);
    }
}

References m_storeMaxArticlesPerFeed, and maxArticlesPerFeedChanged().

Referenced by OptionsDialog::saveOptions(), and AppController::setPreferencesAction().

Here is the caller graph for this function:

setProcessingEnabled()

void Session::setProcessingEnabled

(

bool

enabled

)

Definition at line 431 of file rss_session.cpp.

{
    if (m_storeProcessingEnabled != enabled)
    {
        m_storeProcessingEnabled = enabled;
        if (enabled)
        {
            m_refreshTimer.start(refreshInterval() * MsecsPerMin);
            refresh();
        }
        else
        {
            m_refreshTimer.stop();
        }
 
        emit processingStateChanged(enabled);
    }
}

References m_refreshTimer, m_storeProcessingEnabled, MsecsPerMin, processingStateChanged(), refresh(), and refreshInterval().

Referenced by OptionsDialog::saveOptions(), and AppController::setPreferencesAction().

Here is the call graph for this function:

Here is the caller graph for this function:

setRefreshInterval()

void Session::setRefreshInterval

(

int

refreshInterval

)

Definition at line 480 of file rss_session.cpp.

{
    if (m_storeRefreshInterval != refreshInterval)
    {
        m_storeRefreshInterval = refreshInterval;
        m_refreshTimer.start(m_storeRefreshInterval * MsecsPerMin);
    }
}

References m_refreshTimer, m_storeRefreshInterval, MsecsPerMin, and refreshInterval().

Referenced by OptionsDialog::saveOptions(), AppController::setPreferencesAction(), and RSSWidget::updateRefreshInterval().

Here is the call graph for this function:

Here is the caller graph for this function:

store()

void Session::store ( )

private

Definition at line 373 of file rss_session.cpp.

{
    m_confFileStorage->store(FeedsFileName, QJsonDocument(rootFolder()->toJsonValue().toObject()).toJson());
}

References FeedsFileName(), m_confFileStorage, rootFolder(), AsyncFileStorage::store(), and anonymous_namespace{rss_autodownloadrule.cpp}::toJsonValue().

Referenced by addFeed(), addFolder(), loadFolder(), loadLegacy(), moveItem(), and removeItem().

Here is the call graph for this function:

Here is the caller graph for this function:

workingThread()

QThread * Session::workingThread

(

)

const

Definition at line 489 of file rss_session.cpp.

{
    return m_workingThread;
}

References m_workingThread.

Referenced by RSS::Feed::Feed().

Here is the caller graph for this function:

Friends And Related Function Documentation

::Application

friend class ::Application

friend

Definition at line 95 of file rss_session.h.

Member Data Documentation

m_confFileStorage

AsyncFileStorage* RSS::Session::m_confFileStorage

private

Definition at line 162 of file rss_session.h.

Referenced by confFileStorage(), load(), Session(), and store().

m_dataFileStorage

AsyncFileStorage* RSS::Session::m_dataFileStorage

private

Definition at line 163 of file rss_session.h.

Referenced by dataFileStorage(), and Session().

m_feedsByUID

QHash<QUuid, Feed *> RSS::Session::m_feedsByUID

private

Definition at line 166 of file rss_session.h.

Referenced by addItem(), generateUID(), handleItemAboutToBeDestroyed(), and loadFolder().

m_feedsByURL

QHash<QString, Feed *> RSS::Session::m_feedsByURL

private

Definition at line 167 of file rss_session.h.

Referenced by addFeed(), addItem(), feedByURL(), feeds(), and handleItemAboutToBeDestroyed().

m_instance

QPointer< Session > Session::m_instance = nullptr

staticprivate

Definition at line 156 of file rss_session.h.

Referenced by instance(), and Session().

m_itemsByPath

QHash<QString, Item *> RSS::Session::m_itemsByPath

private

Definition at line 165 of file rss_session.h.

Referenced by addItem(), handleItemAboutToBeDestroyed(), itemByPath(), items(), moveItem(), prepareItemDest(), removeItem(), rootFolder(), Session(), and ~Session().

m_refreshTimer

QTimer RSS::Session::m_refreshTimer

private

Definition at line 164 of file rss_session.h.

Referenced by Session(), setProcessingEnabled(), and setRefreshInterval().

m_storeMaxArticlesPerFeed

CachedSettingValue<int> RSS::Session::m_storeMaxArticlesPerFeed

private

Definition at line 160 of file rss_session.h.

Referenced by maxArticlesPerFeed(), and setMaxArticlesPerFeed().

m_storeProcessingEnabled

CachedSettingValue<bool> RSS::Session::m_storeProcessingEnabled

private

Definition at line 158 of file rss_session.h.

Referenced by isProcessingEnabled(), and setProcessingEnabled().

m_storeRefreshInterval

CachedSettingValue<int> RSS::Session::m_storeRefreshInterval

private

Definition at line 159 of file rss_session.h.

Referenced by refreshInterval(), and setRefreshInterval().

m_workingThread

QThread* RSS::Session::m_workingThread

private

Definition at line 161 of file rss_session.h.

Referenced by Session(), workingThread(), and ~Session().

---

The documentation for this class was generated from the following files:

• src/base/rss/rss_session.h
• src/base/rss/rss_session.cpp